mexico - consumo datos att mx inicio

Limitaciones de la sintaxis de ensamblado de Intel en comparación con AT & T

Question

Para mí, la sintaxis de Intel es mucho más fácil de leer. Si voy por el bosque de ensamblaje concentrándome solo en la sintaxis de Intel, ¿me perderé algo? ¿Hay alguna razón por la que quisiera cambiar a AT & T (aparte de poder leer el ensamble de AT & T de otros)? Mi primera pista es que gdb usa AT & T por defecto.

Si esto es importante, mi atención se centra únicamente en cualquier relación de ensamblaje y sintaxis que pueda tener con Linux / BSD y el lenguaje C.

Answer 1

Es el "mismo idioma", ya que se compila con el mismo código de máquina, tiene los mismos códigos de operación, etc. Por otro lado, si está usando GCC, probablemente quiera aprender la sintaxis de AT & T, solo porque es el valor predeterminado: no cambiar las opciones del compilador, etc. para obtenerlo.

Yo también me corté los dientes con Intel-syntax x86 ASM (también en DOS) y me pareció más intuitivo inicialmente al cambiar a C / UNIX. Pero una vez que aprendas AT & T, se verá igual de fácil.

No le daría mucha importancia --- es fácil aprender AT & T una vez que conoces a Intel, y viceversa. El lenguaje real es mucho más difícil de asimilar que la sintaxis. Así que, por supuesto, solo concéntrese en uno y luego aprenda el otro cuando se presente.

Answer 2

Es un signo de profesionalismo que esté dispuesto a ajustarse a lo que está en uso. No hay una ventaja real para uno u otro. La sintaxis de Intel es común en el mundo de Microsoft, AT & T es el estándar en Linux / Unix. Como no hay ventaja para ninguno de los dos, las personas tienden a imprimir lo que vieron primero. Dicho esto, un programador profesional plantea cosas así arriba. Usa lo que usan en el trabajo o en el dominio en el que estás trabajando.

Answer 3

La sintaxis de Intel cubre todo (suponiendo que el ensamblador / desensamblador esté actualizado con la última basura que Intel agregó a su conjunto de instrucciones). Estoy seguro de que at & t es lo mismo.

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]

... y se vuelve más complicado con instrucciones más complejas

''dijo nuff.

Answer 4

La sintaxis primaria para el ensamblador GNU (GAS) es AT & T. La sintaxis de Intel es una adición relativamente nueva. El ensamblaje x86 en el kernel de Linux está en sintaxis de AT & T. En el mundo de Linux, es la sintaxis común. En el mundo de MS, la sintaxis de Intel es más común.

Personalmente, odio la sintaxis de AT & T. Hay muchos ensambladores gratuitos (NASM, YASM) junto con GAS que también son compatibles con la sintaxis de Intel, por lo que no habrá problemas en la sintaxis de Intel en Linux.

Más allá de eso, es solo una diferencia sintáctica. El resultado de ambos será el mismo código de máquina x86.

Answer 5

Mi primer lenguaje ensamblador fue MIPS, que me he dado cuenta es muy similar a la sintaxis de ATT. Así que prefiero la sintaxis de ATT, pero en realidad no importa, siempre que puedas leerla.

Answer 6

Realmente no hay ninguna ventaja para uno sobre el otro. Aunque estoy de acuerdo en que la sintaxis de Intel es mucho más fácil de leer. Tenga en cuenta que, AFAIK, todas las herramientas de GNU tienen la opción de usar la sintaxis de Intel también.

Parece que puedes hacer que GDB use la sintaxis de Intel con esto:

set disassembly-flavor intel

GCC puede hacer la sintaxis de Intel con -masm=intel .

Answer 7

Realmente no hay ninguna ventaja para uno sobre el otro. No estoy de acuerdo, sin embargo, que la sintaxis de Intel sea mucho más fácil de leer, porque personalmente odio la sintaxis de Intel . Tenga en cuenta que, AFAIK, todas las herramientas de GNU tienen la opción de usar la sintaxis de Intel también.

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]

... y se vuelve más complicado con instrucciones más complejas

''dijo nuff.

PD: Esta respuesta existe principalmente por la razón de resaltar las debilidades (en mi humilde opinión) en algunas otras respuestas, que en realidad no son respuestas, sino opiniones. Y, por supuesto, esta respuesta en realidad es solo mi humilde opinión.

PPS: No odio la sintaxis de Intel, simplemente no me importa.