Limitações da sintaxe Intel Assembly em comparação com a AT&T [fechado]

Para mim, a sintaxe da Intel é muito mais fácil de ler. Se eu for perambular pela floresta de montagem concentrando-me apenas na sintaxe da Intel, vou perder alguma coisa? Há algum motivo para eu querer mudar para a AT&T (além de ser capaz de ler a montagem da AT&T de outras pessoas)? Minha primeira dica é que o gdb usa AT&T por padrão.

Se isso for importante, meu foco é apenas em qualquer relação assembly e sintaxe que possa ter para Linux / BSD e a linguagem C.

Não há realmente nenhuma vantagem para um sobre o outro. Eu concordo, porém, que a sintaxe da Intel é muito mais fácil de ler. Lembre-se de que, AFAIK, todas as ferramentas GNU também têm a opção de usar a sintaxe Intel.

Parece que você pode fazer o GDB usar a sintaxe Intel com isto:

definir informações de sabor de desmontagem

O GCC pode fazer sintaxe Intel com -masm=intel.

A sintaxe primária para o GNU assembler (GAS) é AT&T. A sintaxe da Intel é uma adição relativamente nova a ele. A montagem x86 no kernel Linux está na sintaxe AT&T. No mundo Linux, é a sintaxe comum. No mundo MS, a sintaxe Intel é mais comum.

Pessoalmente, odeio a sintaxe da AT&T . Existem muitos assemblers gratuitos (NASM, YASM) junto com o GAS que também suportam a sintaxe Intel, então não haverá problemas para fazer a sintaxe Intel no Linux.

Além disso, é apenas uma diferença sintática. O resultado de ambos será o mesmo código de máquina x86.

Não há realmente nenhuma vantagem para um sobre o outro. Eu discordo que a sintaxe da Intel é muito mais fácil de ler, porque pessoalmente odeio a sintaxe da Intel . Lembre-se de que, AFAIK, todas as ferramentas GNU também têm a opção de usar a sintaxe Intel.

at&t noprefix                   intel
mov eax, -4(ebp,edx,4)          mov DWORD PTR[-4 +ebp +edx *4], eax
mov eax, -4(ebp)                mov DWORD PTR[-4 +ebp], eax
mov edx, (ecx)                  mov DWORD PTR[ecx], edx
lea (   ,eax,4), eax            lea eax, DWORD PTR[8 + eax*4]
lea (eax,eax,2), eax            lea eax, DWORD PTR[eax*2+eax]

... e fica mais complicado com instruções mais complexas

'nuff disse.

PS: Esta resposta existe principalmente para destacar pontos fracos (IMHO) em algumas outras respostas, que na verdade não são respostas, mas opiniões. E é claro que essa resposta na realidade é apenas minha humilde opinião.

PPS: Eu não odeio a sintaxe da Intel, simplesmente não me importo.

É a "mesma linguagem", na medida em que compila no mesmo código de máquina, tem os mesmos opcodes, etc. Por outro lado, se você estiver usando GCC, provavelmente vai querer aprender a sintaxe AT&T, só porque é o padrão - sem alterar as opções do compilador, etc. para obtê-lo.

Eu também comecei a trabalhar com Intel-syntax x86 ASM (no DOS também) e achei mais intuitivo inicialmente ao mudar para C / UNIX. Mas, depois de aprender a AT&T, parecerá igualmente fácil.

Eu não pensaria muito nisso --- é fácil aprender AT&T depois que você conhece a Intel, e vice-versa. A linguagem real é muito mais difícil de entrar em sua cabeça do que a sintaxe. Então, por suposto, concentre-se em um e aprenda o outro quando ele surgir.

É um sinal de profissionalismo que você está disposto a se ajustar ao que quer que esteja em uso. Não há vantagem real para um ou para outro. A sintaxe intel é comum no mundo da Microsoft, AT&T é o padrão no Linux / Unix. Como não há vantagem para nenhum dos dois, as pessoas tendem a imprimir no que quer que vejam primeiro. Dito isso, um programador profissional eleva-se acima de coisas assim. Use tudo o que eles usam no trabalho ou no domínio em que você está trabalhando.

A sintaxe da Intel cobre tudo (assumindo que o montador / desmontador está atualizado com o mais recente lixo da Intel adicionado ao conjunto de instruções). Tenho certeza que at & t é o mesmo.

at & t intel
movl -4 (% ebp,% edx, 4),% eax mov eax, [ebp-4 + edx * 4]
movl -4 (% ebp),% eax mov eax, [ebp-4]
movl (% ecx),% edx mov edx, [ecx]
leal 8 (,% eax, 4),% eax lea eax, [eax * 4 + 8]
leal (% eax,% eax, 2),% eax lea eax, [eax * 2 + eax]

... e fica mais complicado com instruções mais complexas

'nuff disse.

Minha primeira linguagem assembly foi MIPS, que notei ser muito semelhante à sintaxe ATT. Portanto, prefiro a sintaxe ATT, mas isso realmente não importa, contanto que você possa lê-la.