[C++/Assembler] Meccanismo di traduzione

[cionci]

Mi servirebbe qualche documentazione che parla del meccanismo di traduzione che fa il compilatore GNU per tradurre da C++ ad assembler (prima di assemblare e linkare)...

Vi faccio un esempio :
prova.cpp

#include "prova.h"
cl::cl(st* ps = 0, int aa[] = 0)
{ int i;
if (ps!=0 && aa!=0) for (i=0;i<4;i++)
{ ii[i]= aa[i]; dd[i] = 0;
s.vv1[i] = ps->vv1[i]; s.vv2[i] = ps->vv2[i];
s.vv3[i] = ps->vv3[i];
}
}
cl cl::elab1(cl cla)
{ int i; cl cc(cla);
for (i=0;i<4;i++)
{ cc.ii[i] = ii[i];
cc.s.vv1[i] = cc.s.vv2[i] = s.vv1[i]+s.vv2[i];
}
return cc;
}

Se io lancio il compilatore con

g++ -S prova.cpp -o prova.asm

ottengo il corrispondente assembler :

.file "prova.cpp"
gcc2_compiled.:
___gnu_compiled_cplusplus:
.def ___terminate; .scl 2; .type 32; .endef
.def ___sjthrow; .scl 2; .type 32; .endef
.text
.align 4
.globl ___2clP2stPi
.def ___2clP2stPi; .scl 2; .type 32; .endef
___2clP2stPi:
pushl %ebp
movl %esp,%ebp
subl $28,%esp
pushl %edi
pushl %esi
pushl %ebx
movl 8(%ebp),%edx
cmpl $0,12(%ebp)
je L302
cmpl $0,16(%ebp)
je L302
movl $0,-4(%ebp)
.align 4
L298:
cmpl $3,-4(%ebp)
jle L301
jmp L302
.align 4
L301:
movl -4(%ebp),%eax
movl %eax,%ecx
leal 0(,%ecx,4),%eax
movl -4(%ebp),%ecx
leal 0(,%ecx,4),%ebx
movl 16(%ebp),%ecx
movl (%ecx,%ebx),%ebx
movl %ebx,(%eax,%edx)
movl -4(%ebp),%eax
movl %eax,%ecx
leal 0(,%ecx,8),%eax
leal 16(%edx),%ecx
movl $0,(%eax,%ecx)
movl $0,4(%eax,%ecx)
movl -4(%ebp),%eax
movl %eax,%ecx
leal 0(,%ecx,4),%eax
leal 48(%edx),%ecx
movl 12(%ebp),%ebx
movl -4(%ebp),%esi
movl %esi,%edi
leal 0(,%edi,4),%esi
movl (%esi,%ebx),%ebx
movl %ebx,(%eax,%ecx)
movl -4(%ebp),%eax
movl %eax,%ecx
leal 0(,%ecx,4),%eax
leal 64(%edx),%ecx
movl 12(%ebp),%ebx
movl -4(%ebp),%esi
movl %esi,%edi
leal 0(,%edi,4),%esi
addl $16,%ebx
movl (%esi,%ebx),%esi
movl %esi,(%eax,%ecx)
movl -4(%ebp),%eax
movl %eax,%ecx
leal 0(,%ecx,8),%eax
leal 80(%edx),%ecx
movl 12(%ebp),%ebx
movl -4(%ebp),%esi
movl %esi,%edi
leal 0(,%edi,8),%esi
addl $32,%ebx
fldl (%esi,%ebx)
fstpl (%eax,%ecx)
L300:
incl -4(%ebp)
jmp L298
.align 4
L299:
L297:
L302:
movl %edx,%eax
jmp L296
L296:
leal -40(%ebp),%esp
popl %ebx
popl %esi
popl %edi
leave
ret
.align 4
.globl _elab1__2clT0
.def _elab1__2clT0; .scl 2; .type 32; .endef
_elab1__2clT0:
pushl %ebp
movl %esp,%ebp
subl $188,%esp
pushl %edi
pushl %esi
pushl %ebx
movl 8(%ebp),%eax
movl 12(%ebp),%edx
leal -128(%ebp),%edi
leal 16(%ebp),%esi
cld
movl $28,%ecx
rep
movsl
movl $0,-4(%ebp)
.align 4
L304:
cmpl $3,-4(%ebp)
jle L307
jmp L305
.align 4
L307:
movl -4(%ebp),%ecx
movl %ecx,%ebx
leal 0(,%ebx,4),%ecx
leal -128(%ebp),%ebx
movl -4(%ebp),%esi
movl %esi,%edi
leal 0(,%edi,4),%esi
movl (%esi,%edx),%edi
movl %edi,(%ecx,%ebx)
movl -4(%ebp),%ecx
movl %ecx,%ebx
leal 0(,%ebx,4),%ecx
leal -80(%ebp),%ebx
movl -4(%ebp),%esi
movl %esi,%edi
leal 0(,%edi,4),%esi
leal -64(%ebp),%edi
movl %edi,-168(%ebp)
movl -168(%ebp),%edi
addl %esi,%edi
movl %edi,-164(%ebp)
movl -4(%ebp),%edi
movl %edi,-132(%ebp)
movl -132(%ebp),%esi
sall $2,%esi
movl %esi,-168(%ebp)
leal 48(%edx),%edi
movl %edi,-136(%ebp)
movl -4(%ebp),%esi
movl %esi,-140(%ebp)
movl -140(%ebp),%edi
movl %edi,-144(%ebp)
movl -144(%ebp),%esi
sall $2,%esi
movl %esi,-148(%ebp)
leal 64(%edx),%edi
movl %edi,-152(%ebp)
movl -136(%ebp),%esi
movl -168(%ebp),%edi
movl (%edi,%esi),%esi
movl %esi,-168(%ebp)
movl -152(%ebp),%edi
movl -148(%ebp),%esi
movl (%esi,%edi),%edi
movl %edi,-156(%ebp)
movl -168(%ebp),%edi
addl -156(%ebp),%edi
movl %edi,-160(%ebp)
movl -160(%ebp),%edi
movl -164(%ebp),%esi
movl %edi,(%esi)
movl -160(%ebp),%esi
movl %esi,(%ecx,%ebx)
L306:
incl -4(%ebp)
jmp L304
.align 4
L305:
movl %eax,%edi
leal -128(%ebp),%esi
cld
movl $28,%ecx
rep
movsl
jmp L303
L303:
movl %eax,%eax
leal -200(%ebp),%esp
popl %ebx
popl %esi
popl %edi
leave
ret $4

Per la traduzione del codice non ho bisogno di aiuto, quello che mi serve è la convenzione per la traduzione dei nomi di funzione e di classe...

Grazie :)

[ilsensine]

L'enoteca sotto casa tua deve fare affari d'oro :D
A parte gli scherzi, sperando che non intendi sapere come il gcc effettua la traduzione in assembler, non ho capito...cosa non hai capito

[cionci]

Mi serve di sapere il metodo con cui il gcc traduce i nomi delle funzioni in assembler...

Ad esempio :

___2clP2stPi è la traduzione del costruttore di cl...
Dal nome della funzione si vedono anche i parametri che deve ricevere...P2st è un puntatore a una struttura st...Pi è un puntatore ad un intero...

_elab1__2clT0 è la traduzione di cl::elab1...ed anche qui si dovrebbe capire ciò che viene passato dalla nomenclatura...

C'è uno standard ben preciso per assegnare questi nomi...
Mi serve per un esame...
Quello che devo fare in questo scritto è scrivere da un file .cpp un traduzione in assembler con i nomi di funzione compatibili in modo che possa venire linkato insieme al normale codice C++ (ad un main per esempio)...
In pratica devo simulare ciò che fa il compilatore...facendogli "saltare" il primo passo di compilazione...

[ilsensine]

Ovviamente fino a un paio di mesi fa lo sapevo...

[ilsensine]

Ok ho ritrovato qualcosa...
il "nome" dell'oggetto è una combinazione del nome di classe, nome (e tipo) dell'oggetto, tipo dei parametri. Il tipo dei parametri può essere esaminato con typeid; ad es. esegui questo programma:

#include <typeinfo>
#include <iostream>

class foo {
public:
int bar1(char *, int, float, double);
void bar2(char *, int, float, double);
};

int foo::bar1(char *, int, float, double) {
return 0;
}

void foo::bar2(char *, int, float, double) {
}

int main(int argc, char **argv) {

cout << "suffisso di classe: " << typeid(foo).name() << endl <<
"int foo::bar1(char *, int, float, double) " << typeid(foo::bar1).name() << endl <<
"void foo::bar2(char *, int, float, double) " << typeid(foo::bar2).name() << endl <<
"Nomi effettivi: objdump -t " << argv[0] << " |grep foo" << endl;
return 0;
}

Nota che il risultato può variare da compilatore a compilatore, a seconda dello standard abi utilizzato.

[cionci]

Ti ringrazio...ma ho trovato tutto su una dispensa che mi ero scordato di avere :)
Comunque il tuo metodo mi potrebbe servire...

[xp2200+]

Ti ringrazio...ma ho trovato tutto su una dispensa che mi ero scordato di avere :)
Comunque il tuo metodo mi potrebbe servire...

calcolatori elettronici con Frosini??