RISOLTO Sintassi Assembly

[Matteo34]

Una domanda veloce, sono assai confuso : (
Da quel che so, la sintassi assembly usata da un processore non cambia in base al sistema operativo o mi sbaglio?
Se disassemblo un programma su Ubuntu mi esce questo:

main:
        pushq   %rbp
        movq    %rsp, %rbp
        movl    $5, -4(%rbp)
        movl    $6, -8(%rbp)
        movl    -4(%rbp), %edx
        movl    -8(%rbp), %eax
        addl    %edx, %eax
        movl    %eax, -12(%rbp)
        movl    $0, %eax
        popq    %rbp
        ret

Se disassemblo su windows invece questo:

main:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], 5
        mov     DWORD PTR [rbp-8], 6
        mov     edx, DWORD PTR [rbp-4]
        mov     eax, DWORD PTR [rbp-8]
        add     eax, edx
        mov     DWORD PTR [rbp-12], eax
        mov     eax, 0
        pop     rbp
        ret

Perché su Linux usa la sintassi AT&T e su Windows quella Intel, cambia la sintassi da un sistema operativo all'altro, la CPU che ho è una Intel, quindi mi sarei aspettato la sintassi intel.
Perché succede questa cosa?

 

[Dumah Brazorf]

https://www.google.com/search?q=assembly+at&t+vs+intel+syntax

 

[Matteo34]

https://www.google.com/search?q=assembly+at&t+vs+intel+syntax

Si ok, ma volevo sapere perché sul mio PC vengono usate due sintassi

 

[Dumah Brazorf]

Perchè la sintassi intel è quella predefinita su dos e windows mentre la at&t su unix.

 

[DispatchCode]

Una domanda veloce, sono assai confuso : (
Da quel che so, la sintassi assembly usata da un processore non cambia in base al sistema operativo o mi sbaglio?
Se disassemblo un programma su Ubuntu mi esce questo:

main:
        pushq   %rbp
        movq    %rsp, %rbp
        movl    $5, -4(%rbp)
        movl    $6, -8(%rbp)
        movl    -4(%rbp), %edx
        movl    -8(%rbp), %eax
        addl    %edx, %eax
        movl    %eax, -12(%rbp)
        movl    $0, %eax
        popq    %rbp
        ret

Se disassemblo su windows invece questo:

main:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], 5
        mov     DWORD PTR [rbp-8], 6
        mov     edx, DWORD PTR [rbp-4]
        mov     eax, DWORD PTR [rbp-8]
        add     eax, edx
        mov     DWORD PTR [rbp-12], eax
        mov     eax, 0
        pop     rbp
        ret

Perché su Linux usa la sintassi AT&T e su Windows quella Intel, cambia la sintassi da un sistema operativo all'altro, la CPU che ho è una Intel, quindi mi sarei aspettato la sintassi intel.
Perché succede questa cosa?

Come dice giustamente Dumah, la AT&T è usata di default nel mondo Linux. In Windows trovi solo la Intel. In generale nei manuali ufficiali vedrai sempre la Intel.
Si tratta solo di sintassi, l'operazione (a livello di codice macchina) è la medesima.

Poi con queste architetture ci sono espressioni che possono anche essere codificate in più modi, ma non ha comunque a che vedere con la sintassi.

Ricorda che alla fine è un file di testo che viene parsato ed elaborato da un assembler.

 

[pabloski]

Se stai usando gdb, appena sei al prompt, dagli il comando

set disassembly-flavor intel

e da quel momento userà la sintassi Intel per visualizzare il disassemblato.

Però, inutile dire che la conoscere la sintassi AT&T è fondamentale, visto che la usano tutti gli Unix ed è abbastanza usata pure nel mondo della cybersecurity.

 

[Utente cancellato 371741]

Da quel che so, la sintassi assembly usata da un processore non cambia in base al sistema operativo o mi sbaglio?

sbagli,

Le sintassi AT&T o Intel sono sono appunto "sintassi" e nulla hanno a cheffare con la cpu.
Ce ne sono molte di piu, in windows a seconda del compilatore, tasm, tasm ideal mode, masm32, fasm, intel etc hai diverse varianti tutte simili. In linux si usa per lo piu AT&T anche se a seconda dell'architettura, compilatore gcc / gas usa delle varianti.

 

[Utente 16812]

Una domanda veloce, sono assai confuso : (
Da quel che so, la sintassi assembly usata da un processore non cambia in base al sistema operativo o mi sbaglio?
Se disassemblo un programma su Ubuntu mi esce questo:

main:
        pushq   %rbp
        movq    %rsp, %rbp
        movl    $5, -4(%rbp)
        movl    $6, -8(%rbp)
        movl    -4(%rbp), %edx
        movl    -8(%rbp), %eax
        addl    %edx, %eax
        movl    %eax, -12(%rbp)
        movl    $0, %eax
        popq    %rbp
        ret

Se disassemblo su windows invece questo:

main:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], 5
        mov     DWORD PTR [rbp-8], 6
        mov     edx, DWORD PTR [rbp-4]
        mov     eax, DWORD PTR [rbp-8]
        add     eax, edx
        mov     DWORD PTR [rbp-12], eax
        mov     eax, 0
        pop     rbp
        ret

Perché su Linux usa la sintassi AT&T e su Windows quella Intel, cambia la sintassi da un sistema operativo all'altro, la CPU che ho è una Intel, quindi mi sarei aspettato la sintassi intel.
Perché succede questa cosa?

Salve @Matteo34,
ciò che non cambia è il linguaggio macchina (cioè il set di istruzioni) relativo ad una micro-architettura di un processore ma la sintassi Assembly può essere differente a seconda dell'assemblatore utilizzato, ne ho parlato qui:
https://forum.tomshw.it/threads/linguaggio-assembly.817036/post-7611627 (e seguenti)
I disassemblatori si limitano a ricreare il codice Assembly dal codice macchina (binario), essenzialmente leggendo i bytes ed eseguendo una tabella di "lookup", ma generalmente non c'è alcuna corrispondenza tra il sorgente Assembly originario e l'output disassemblato.
La sintassi delle istruzioni può essere Intel, AT&T o HLA.
Sostanzialmente i problemi dei disassemblatori riguardano due aspetti: la separazione tra codice e dati (in quanto dati binari memorizzati in un eseguibile) e la perdita degli identificatori testuali definiti dall'utente.
A presto ?

 

[Matteo34]

Salve @Matteo34,
ciò che non cambia è il linguaggio macchina (cioè il set di istruzioni) relativo ad una micro-architettura di un processore ma la sintassi Assembly può essere differente a seconda dell'assemblatore utilizzato, ne ho parlato qui:
https://forum.tomshw.it/threads/linguaggio-assembly.817036/post-7611627 (e seguenti)
I disassemblatori si limitano a ricreare il codice Assembly dal codice macchina (binario), essenzialmente leggendo i bytes ed eseguendo una tabella di "lookup", ma generalmente non c'è alcuna corrispondenza tra il sorgente Assembly originario e l'output disassemblato.
La sintassi delle istruzioni può essere Intel, AT&T o HLA.
Sostanzialmente i problemi dei disassemblatori riguardano due aspetti: la separazione tra codice e dati (in quanto dati binari memorizzati in un eseguibile) e la perdita degli identificatori testuali definiti dall'utente.
A presto ?

Tutto chiaro : )