Help please! ( C / asm inside )

Salut tout le monde.

Je suis en licence d’info et j’ai un petit probleme : j’ai un projet à réaliser en traduction, qui consiste à réaliser un mini-compilateur en C qui compile du langage C-ex en générant le code assembleur correspondant.

Ce langage (comme son nom le laisse présager) ressemble fortement au C, et les deux seuls types de variables que le mini-compilateur est sensé gérer sont les entiers (4 octets) et les tableaux d’entiers (dimension aléatoire). Les exceptions sont aussi implémentées dans ce langage avec un bloc “try catch finally” (comme en java).

Le problème qui me préoccupe est que je doit rendre un pré-rapport indiquant comment on souhaite traiter les allocations de tableaux et les exceptions, mais je ne vois absolument pas comment m’y prendre! Je sais qu’il y a moyen d’exécuter des portions de code C dans l’assembleur généré via des fichiers .c, et je pense même que c’est le seul moyen d’y arriver, mais tout cela reste bien obscur (en fait c’est même carrément tout noir là).
Donc si quelqu’un s’y connaît dans ce domaine et pourrait m’indiquer la marche à suivre je lui en serait ma foi fort reconnaissant (je vous demande pas de faire le truc à ma place hein, juste des indications, la marche à suivre…)

Si vous êtes chaud pour lire tout le sujet cliquez donc là.

PS: en ce qui concerne les exceptions, j’ai lu les manpages des fonctions setjmp et longjmp mais je ne vois pas comment les implémenter avec de l’assembleur…

undefined
Ce message a été édité par TwinSidE le 16/03/2004

Je peut pas directement t’aider, mais y’a le numero 104 de Login (mars-avril 2003) qui traite du sujet, ils expliquent comment creer un petit compilateur pour un langage C léger (dans le genre du tien apparemment). Les sources de l’exemple sont fournie sur le CD (pour zieuter comment ils ont procédés ça peut être utile).

Déjà merci de répondre si vite.
Login n°104 tu dis ? mars-avril 2003 ? 'tain chuis à la bourre…
Et sinon tu pourrais pas m’envoyer les sources en question par hasard et/ou un scan de l’article en question ?

Ouai enfin on va pas te faire tes devoirs non plus

Nan franchement je vous demande pas de me faire mes devoirs ca servirait à rien.
Je voudrais juste avoir de quoi me lancer parce que sur ce coup là je suis vraiment à la rue je galère depuis plusieurs jours… en plus on a eu un pauv’ td d’intro à l’assembleur et basta… ça le fait pas.  Tout ce que je voudrais savoir c’est le comportement à adopter pour gérer ce foutu bloc “try catch finally” qui va bientôt être responsable d’une calvitie prématurée si ça continue .
Je demande en aucun cas de me pondre tout le code, et d’ailleurs j’oserai même pas.

Tu peux matter l’implementation de rotor du CLR de MS qui est open source et qui implemente le try/catch/finally. J’ai meme vu plusieurs articles sur le sujet sur comment c’etait implemente dans le .Net framework. Si tu trouves pas sur google j’essaierai de te retrouver les liens ce soir quand je serais a la maison.

Eh ben… merci (ça me fait bizarre que ce soit le glop qui s’occupe de tout plein de trucs inhérents à la cafzone qui s’intéresse à mon petit problème )
Je pense avoir un (tout petit) peu avancé avec mon problème de try catch finally en réflechissant à une fonction C à nombre d’arguments variables (les exceptions à attraper) et qui vérifierait l’état de l’environnement mais c’est qu’à létat embryonnaire.
En ce qui concerne les codes sources dont tu me parles j’y jetterai un oeil attentif demain (pour cause de dodo time).

Encore merci.

sinon, tu peux zieuter au code d’un pseudo-compilateur de C qui est vraiment pas gros (en comparaison de la partie C de gcc) qui se trouve sur http://www.tinycc.org. Je pense que tu devrais trouver ton bonheur sans avoir trop de débroussaillage à faire

C’est cool merci.
Je sens que mon week-end va etre place sous le signe de ce fabuleux langage qu’est l’assembleur…

Si ton compilateur est pour véranda il y a un moyen evil, inscrit toi dans la chaîne SEH…

Bon en général, on fait dans ce style. Exemple de programme :
#include <stdio.h>
#include <tchar.h>
 
void exception_function(void)
{
 
 try
 {
printf(_T(“caca
”));
throw 1;
printf(_T(“pipi
”));
 }
 
 
 catch(int i)
 {
printf(_T(“blah blah %d
”), i);
 }
 
}
 
int main(int argc, char **argv, char **envp)
{
 
 
 exception_function();
 
}
Ta fonction exception_function va avoir cette gueule :
exception_function proc near   ; CODE XREF: sub_401080p
 
var_18   = dword ptr -18h
var_14   = dword ptr -14h
var_10   = dword ptr -10h
var_C = dword ptr -0Ch
var_4 = dword ptr -4
 
  push   ebp
  mov ebp, esp
  push   0FFFFFFFFh
  push   offset frame_handler
  mov eax, large fs:0
  push   eax
  mov large fs:0, esp
  sub esp, 0Ch
  push   ebx
  push   esi
  push   edi
  mov [ebp+var_10], esp
  push   offset aCaca   ; “caca

  mov [ebp+var_4], 0
  call   printf
  add esp, 4
  push   offset unk_407F28
  lea eax, [ebp+var_14]
  push   eax
  mov [ebp+var_14], 1
  call   __CxxThrowException@8 ; _CxxThrowException(x,x)
  mov ecx, [ebp+var_18]
  push   ecx
  push   offset aBlahBlahD ; “blah blah %d

  call   printf
  add esp, 8
  mov eax, offset loc_401061
  retn
 
loc_401061:
  mov ecx, [ebp+var_C]
  pop edi
  pop esi
  mov large fs:0, ecx
  pop ebx
  mov esp, ebp
  pop ebp
  retn
exception_function endp
Bon comme tu le vois c’est super simple. En fait ton throw c’est une pauvre fonction qui va juste faire appel à RaiseException. Dans le prologue de ta fonction tu t’es inscrit dans la chaîne (c’est le mov fs:[0], esp, car fs:[0] contient la chaîne SEH, et comme tu l’as vu tu as empilé ton frame handler et la valeur précédente de la chaîne SEH), il faut se désinscrire dans l’épilogue. Bon, le gros du boulot  est en fait dans le frame handler… Selon la qualité de ton filtre (unwind etc.) tu vas avoir plus ou moins de code, la consolation c’est que tu l’écris qu’une fois et que tu peux commencer par un truc super trivial au début. Ah oui, autre astuce, tu as vu pour quitter la fonction, on met dans eax l’épilogue car on a empilé pour le SEH… Tu comprends ?

Sinon je trouve que le sujet est un petit peu dur pour le niveau licence d’informatique… Ca sent la masturbation intellectuelle de prof qui a pas bien mesuré la porté de sa question… Ou c’est moi qui ait mal compris ?Sans compter que faire ça en norme AT&T franchement ça mérite la peine de mort… Bref, have phun…

oulah c’est super obscur ce dont tu me parles.
On a vraiment un niveau tres bas en asm on a juste vu les operateurs arithmetiques, bit a bit et push, pop et tout ce qui est movl…
En ce qui concerne les registres on connait que les 4 eXx (de eax a edx), ebp et esp. Jamais entendu parler de chaine SEH, de framehandler et autre… ou alors sinon on l’a vu sans le savoir…

Sinon j’ai essayé de compiler ton exemple mais visiblement en le C ne gère pas try/catch/finally parce que ça ne marche pas…

Enfin je pense quand meme pouvoir m’en sortir en me mettant à fond dedans.

En ce qui concerne la difficulté du truc moi aussi je trouve que c’est assez balèze par rapport à ce qu’on a pu se voir proposer jusqu’ici mais ce qu’on fait en td est assez dirigiste et pas à pas.

En fait y a que les exceptions qui foutent la merde ! Mais bon je m’égare…
Merci en tout cas.

SEH = Structured Exception Handling, c’est tout simplement le gestionnaire d’exception de véranda ! Rien de miraculeux ! Il s’agit d’une chaîne de pointeur vers des fonctions qui vont gérer une exception ou la passer à la fonction suivante dans la chaîne, jusqu’à arriver au handler par défaut (la fameuse messagebox avec la croix…). Des API te permettent de t’inscrire dans la chaîne pour que ton application gère ses exceptions avant l’OS (ce qui te permet soit de récupérér l’erreur soit de planter proprement).

Sinon il y a rien de très eleet sur le plan asm dans ce que j’ai mis. Mon exemple est du C++, il doit compiler avec n’importe quel compilateur C++ sous Windows (à cause des includes). Il s’adapte en C++ “ANSI” en enlevant tchar.h et les macros _T("").

Je comprends pas ce que veulent tes profs en fait, les exceptions rendent effectivement l’exercice bien dur, car pour le faire correctement, il faut le faire comme je te l’ai montré (t’as vu je suis ouvert d’esprit :P), et ça dépend énormément de l’OS (ici véranda)… Bref, ils n’ont pas trop réfléchi à leur sujet ? A mon avis il faudrait que tu en discutes avec eux un minimum, parce que franchement pour des licences c’est trop h4rD0r.

Sous BSD tu peux émuler un SEH en te servant des signaux, mais là aussi c’est plutôt chaud…

Alors je suis allé faire un tour et j’ai un peu plus compris ce dont tu me parlais (j’avais même pas capté ce à quoi “véranda” faisait allusion au départ ).
Par contre ma lecture n’est pas allé bien loin quand je me suis rendu compte que justement la technique décrite ne marche que pour windows (si jamais tu parles de l’OS à billou en présence de profs autres que ceux de développement web, tu provoques une pluie de mollards sur ta personne).

Si tu as le temps je suis preneur pour une petite explication rapide sur les signaux à gérer en cas d’exception (au moins ça ça me parle), d’autant plus qu’il est conseillé d’utiliser ses propres bibliothèques C pour gérer plus ou moins ce qu’on veut au cours du processus de compilation, comme l’allocation dynamique de tableaux par exemple.

Merci

Ce message a été édité par susmab le 20/03/2004

En cherchant sur le net, j’ai trouvé ça :

http://www.pps.jussieu.fr/~emmanuel/Public…/TD3/node1.html

Si tu veux mon conseil, le mieux c’est de hacker le compte de ton prof, prendre le corrigé, le passer dans une moulinette et jouer à FarCry tout le week-end.

[quote]Par contre ma lecture n’est pas allé bien loin quand je me suis rendu compte que justement la technique décrite ne marche que pour windows (si jamais tu parles de l’OS à billou en présence de profs autres que ceux de développement web, tu provoques une pluie de mollards sur ta personne).[/quote]Pfff et ca, ca me degoute. De quel droit? Il y a une difference entre apprendre les concepts generaux de l’informatique sans se lier a un OS particulier ou une application particuliere (je suis 110% pour) et denigrer volontairement, publiquement l’OS sur lequel vont bosser une grande partie desdits etudiants et ne rien leur apprendre dessus, si ce n’est pour le critiquer. N’en deplaise a ces gens la, il y a quelques trucs  techniques interessants a apprendre aussi chez MS. Je connais un ou deux specialiste mondiaux dans leur domaine qui le prouvent tout les jours, si ils daignaient ecouter…C’est le meme genre de mentalite bornee qui empeche des collaborations efficace public/prive par ideologie parceque l’un voit le grand satan et l’autre une bande de feignants qui fuient a la moindre mention du mot “application concrete”. N’importe quoi…
Ce message a été édité par GloP le 21/03/2004