Depende de lo que quieras decir. Desde 10,000 pies, todos los lenguajes de ensamblaje se parecen bastante. Pero en los detalles, pueden ser muy diferentes. Debe consultar los respectivos manuales de arquitectura para conocer las diferencias (ARM vs x86 / x64).
Aquí está el mismo programa (Cuadrados mágicos de orden impar) compilado para cada arquitectura:
[ [correo electrónico protegido] ~] $ cc -arch armv5 -S -O3 foo.c
[ [correo electrónico protegido] ~] $ cat foo.s
.section __TEXT, __ text, regular, pure_instructions
.section __TEXT, __ textcoal_nt, coalesced, pure_instructions
.section __TEXT, __ const_coal, unido
.section __TEXT, __ picsymbolstub4, symbol_stubs, none, 16
.section __TEXT, __ StaticInit, regular, pure_instructions
.section __TEXT, __ cstring, cstring_literals
.sintaxis unificada
.section __TEXT, __ text, regular, pure_instructions
.globl _f
.align 2
_f: @ @f
@ BB # 0:
mov r3, r0
agregue r0, r1, r2, lsl # 1
agregue r0, r0, # 1
mov r1, r3
b ___modsi3
.globl _main
.align 2
_Principal Principal
@ BB # 0:
empujar {r4, r5, r6, r7, lr}
mov r7, sp
empujar {r8, r10, r11}
sub sp, sp, # 12
ldr r0, [r1, # 4]
bl _atoi
mov r11, r0
cmp r11, # 0
ble LBB1_5
@ BB # 1:
ldr r8, LCPI1_0
mov r0, # 0
mov r1, # 1
mov r2, r11
LPC1_0:
ldr r8, [pc, r8]
LBB1_2:
@ => Este encabezado de bucle: Profundidad = 1
@ Child Loop BB1_3 Profundidad 2
str r2, [sp] @ Derrame de 4 bytes
str r1, [sp, # 4] @ Derrame de 4 bytes
str r0, [sp, # 8] @ Derrame de 4 bytes
mov r6, r1
mov r10, r11
mov r5, r2
LBB1_3: @ Parent Loop BB1_2 Profundidad = 1
@ => Este encabezado de bucle interno: Profundidad = 2
mov r0, r5
mov r1, r11
bl ___modsi3
mov r4, r0
mov r0, r6
mov r1, r11
bl ___modsi3
mla r1, r4, r11, r0
mov r0, r8
agregar r1, r1, # 1
bl _printf
agregue r6, r6, # 1
subs r10, r10, # 1
sub r5, r5, # 1
bne LBB1_3
@ BB # 4: @ en bucle: Encabezado = BB1_2 Profundidad = 1
mov r0, # 10
bl _putchar
ldr r1, [sp, # 4] @ 4 bytes Recargar
ldr r2, [sp] @ 4 bytes de recarga
ldr r0, [sp, # 8] @ 4 bytes Recargar
agregue r0, r0, # 1
agregue r1, r1, # 2
agregar r2, r2, # 2
cmp r0, r11
bne LBB1_2
LBB1_5: @% ._ crit_edge3
mov r0, # 0
sub sp, r7, # 12
pop {r8, r10, r11}
pop {r4, r5, r6, r7, pc}
.align 2
@ BB # 6:
.data_region
LCPI1_0:
.long L_.str- (LPC1_0 + 8)
.end_data_region
.section __TEXT, __ cstring, cstring_literals
L_.str: @ @ .str
.asciz “% 4d”
.subsections_via_symbols
E Intel:
[ [correo electrónico protegido] ~] $ cc -arch i386 -S -O3 foo.c
[ [correo electrónico protegido] ~] $ cat foo.s
.section __TEXT, __ text, regular, pure_instructions
.globl _f
.align 4, 0x90
_f: ## @f
## BB # 0:
pushl% ebp
movl% esp,% ebp
movl 16 (% ebp),% eax
movl 12 (% ebp),% ecx
leal 1 (% ecx,% eax, 2),% eax
cltd
idivl 8 (% ebp)
movl% edx,% eax
popl% ebp
retl
.globl _main
.align 4, 0x90
_Principal Principal
## BB # 0:
pushl% ebp
movl% esp,% ebp
pushl% ebx
pushl% edi
pushl% esi
subl $ 44,% esp
calll L1 $ pb
L1 $ pb:
popl% esi
movl 12 (% ebp),% eax
movl 4 (% eax),% eax
movl% eax, (% esp)
calll _atoi
movl% eax, -20 (% ebp) ## Derrame de 4 bytes
testl% eax,% eax
jle LBB1_5
## BB # 1:
xorl% eax,% eax
movl $ 1,% ecx
leal L_.str-L1 $ pb (% esi),% edx
movl% edx, -24 (% ebp) ## Derrame de 4 bytes
movl -20 (% ebp),% edx ## Recarga de 4 bytes
.align 4, 0x90
LBB1_4:
## => Este encabezado de bucle: Profundidad = 1
## Child Loop BB1_2 Profundidad 2
movl% edx, -36 (% ebp) ## Derrame de 4 bytes
movl% ecx, -32 (% ebp) ## Derrame de 4 bytes
movl% eax, -28 (% ebp) ## Derrame de 4 bytes
movl% ecx,% edi
movl -20 (% ebp),% eax ## Recarga de 4 bytes
movl% edx,% ebx
.align 4, 0x90
LBB1_2: ## Parent Loop BB1_4 Profundidad = 1
## => Este encabezado de bucle interno: Profundidad = 2
movl% eax, -16 (% ebp) ## Derrame de 4 bytes
movl% ebx,% eax
cltd
movl -20 (% ebp),% esi ## Recarga de 4 bytes
idivl% esi
movl% edx,% ecx
inull% esi,% ecx
movl% edi,% eax
cltd
idivl% esi
movl -24 (% ebp),% esi ## Recarga de 4 bytes
leal 1 (% edx,% ecx),% eax
movl% esi, (% esp)
movl% eax, 4 (% esp)
calll _printf
movl -16 (% ebp),% eax ## Recarga de 4 bytes
decl% ebx
incl% edi
decl% eax
jne LBB1_2
## BB # 3: ## en Loop: Encabezado = BB1_4 Profundidad = 1
movl $ 10, (% esp)
calll _putchar
movl -28 (% ebp),% eax ## Recarga de 4 bytes
incl% eax
movl -36 (% ebp),% edx ## Recarga de 4 bytes
addl $ 2,% edx
movl -32 (% ebp),% ecx ## Recarga de 4 bytes
addl $ 2,% ecx
cmpl -20 (% ebp),% eax ## Recarga plegada de 4 bytes
jne LBB1_4
LBB1_5: ##% ._ crit_edge3
xorl% eax,% eax
addl $ 44,% esp
popl% esi
popl% edi
popl% ebx
popl% ebp
retl
.section __TEXT, __ cstring, cstring_literals
L_.str: ## @ .str
.asciz “% 4d”
.subsections_via_symbols
