Structure fichiers executable Unix

Version imprimable

Bonjour à tous,
je cherche à creer mon propre assembleur, je sais tout ce qu' il faut faire (opcodes, analyses, tout ça...) mais ce qu' il me manque, c' est une validation de l' exemple de syntaxe de fichiers executable au format ELF 32 : (c' est un exemple incomplet, hein, juste une partie de l' en-tête du fichier :arf:)
Code:

1 2 3 4 0x7F/E/L/F/0/0/0/0/0/0/0/1/0/0/0/0/0/0/0/1/0/0/0/0/0/0/0/1/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0 /0/0/0/0/0/0/0/0/0/0/0/0/0/0/...(c est les zéros du bourage).../0/0/0/0/0/1/0/0/0/0/0/0/0/1/1/0/0/0/0/ 0/0/0/0/0/0/0/0/0/0/0/1/...ect, ect
:zekill: :massacre:

ps/ump (ahah:lol:) : http://www-verimag.imag.fr/~moy/cour...-liens-nup.pdf

a+

19/10/2013, 23h14
bifur

j'avoue ne pas comprendre exactement ce que tu attend, si ton pb viens de la doc pour le format de fichier ELF il y a un bon exemple ici pour comprendr commet est fait un fichier elf de base i386 32bit
20/10/2013, 10h33
AND66

Oui d' accord, mais j' ai déjà été sur ce site, mais ce que je veux, c' est créer un assembleur, donc compiler de l' assembleur vers de l' assembleur...:cry:
20/10/2013, 13h47
n5Rzn1D9dC

As-tu déjà codé un seul programme assembleur ?
Pourquoi veux-tu créer un assembleur ?

Je ne dis pas ça pour t'ennuyer, mais à voir les autres topiques que tu as créé, tu n'as clairement pas le niveau pour créer un assembleur. Tu ne dois pas te rendre compte de la complexité de la chose et surtout du temps que cela prend.
A ton niveau actuel, le temps qu'il te faudrait pour créer un assembleur se compterait en années (tu en est encore à poser des questions sur les sockets).

Si tu veux te rendre compte de la chose, regarde le code source de Fasm par exemple (qui contient plus de 30 000 lignes de code).
20/10/2013, 14h01
Obsidian

Citation:

Envoyé par AND66

Oui d' accord, mais j' ai déjà été sur ce site, mais ce que je veux, c' est créer un assembleur, donc compiler de l' assembleur vers de l' assembleur...:cry:

Qu'entends-tu par « compiler de l'assembleur vers l'assembleur » ? Tu veux pouvoir assembler et désassembler ? C'est faisable mais ce sont deux choses distinctes.

Pour le reste, en principe, le code objet produit par l'assembleur proprement dit et le format de stockage, ici ELF, sont deux choses bien différentes également. C'est normalement le linker qui prend en charge le second mais comme les fichiers objets ont quand même besoin de méta-données pour être exploités, les assembleurs comme NASM ou autre prennent directement en charge une liste de formats « finaux » pour pouvoir le faire.
21/10/2013, 14h19
AND66

Oui, j' ai déjà codé des programmaes en assembleur (nasm), si j' ai posé la question - ' comment créer un socket en nasm ' - c' est parce que ça n' est que très récemment que je me le suis demandé, alors, cherchant une réponse sur internet je me dis, bon, pour aller plus vite, je pose la question sur developpez, au moins, c' est français.
Mais i je veux créer un assembleur, c' est juste pédagogique, et aussi parce que les syntaxes intel et AT & T ne me plaisent pas. comme ça, j' ai ma syntaxe, mes instructions et mon compilo.:frenchy:
21/10/2013, 17h01
n5Rzn1D9dC

Fait comme tu veux, c'est juste un conseil que je t'ai donné.
Je trouve que tu t'engages dans une voie démeusurée par rapport à ton niveau actuel.

Après tout est une question de temps..
Demain je peux me dire "tiens, je vais essayer de comprendre la théorie de la relativité restreinte".
Tout dépend combien de temps je suis près à sacrifier pour ça, étant donné que je n'ai carrément pas le niveau actuel pour la comprendre dans un délai "normal", et que j'aurais énormément de choses à comprendre en collatéral.

Faire un compilo asm, c'est du niveau expert. Pas élite, mais expert au minimum.
Il y a des milliers de choses tout aussi pédagogiques, et beaucoup plus rapides à comprendre que tu pourrais faire en assembleur avant de partir dans la création d'un compilo.

Tu dis "mes intructions".
Une instruction est une instruction, point barre.
Un "mov eax,0" restera un "mov eax,0", quelque soit le compilo (et les variantes de l'opcode).

Concernant la syntaxe qui te dérange. Une simple macro sous Fasm écrite en 5 minutes et le problème est résolu.
22/10/2013, 14h25
AND66

correction

pour obsidian,
dans la phrase, 'ce que je veux c' est créer assembleur, donc compiler de l' assembleur vers de l' assembleur...' les points suspensions signifient que je ne veux pas compiler de l' asm vers de l' asm.
juste à titre d' nformation
DSL:cry:
22/10/2013, 14h28
AND66

Et pour N5R,
Quand je dis, mes instructions, je peux par exemple, remplacer mov eax, imm par set eax, imm si la valeur immédiate est une constante;
exemple:

Code:

set eax, 'A'

est égal à :

Code:

mov eax, 'A'

mais n' est pas égal à :

Code:

mov eax, ebx
22/10/2013, 14h33
AND66

Et je tiens à préciser que pour moi (en tout cas), il est parfaitement possible de créer un assembleur sans pour autant être un expert sur le sujet, pour moi, les connaissances requises sont :
-la syntaxe du programme en général (pour à peu près tout les assembleur) : le segment de données, celui de code, et le bss;
-les instructions intel 80x86 avec leurs opcodes, (gladir.com);
-connaissance d' un langage de programmation qui servira à compiler le compilateur lui écris dns l' assembleur que je veux créer;

:D
22/10/2013, 14h53
n5Rzn1D9dC

Yep, bah écoute lances-toi si vraiment tu es motivé.

Pour la structure d'un elf32 ou 64, il y a des exemples dans Fasm. Et qui fonctionnent parfaitement.

Tu peux aussi faire simplement un "man elf".
23/10/2013, 08h49
Forthman

Citation:

Envoyé par AND66

Et pour N5R,
Quand je dis, mes instructions, je peux par exemple, remplacer mov eax, imm par set eax, imm si la valeur immédiate est une constante;
exemple:

Code:

set eax, 'A'

est égal à :

Code:

mov eax, 'A'

mais n' est pas égal à :

Code:

mov eax, ebx

? heu.. c'est quoi le but ? :aie:

Mais pour en revenir à la question de départ, je veux savoir comment on passe de ça :

Code:

1
2
.text
movb $0x02, %al

à ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ELF\00\00\00\00\00\00\00\00\00\00\00\00\00\00T\804\00\00\00x\
00\00\00\00\00\00\004\00 \00\00(\00\00\00\00\00\00\00\00\00\00\00\80
\00\80V\00\00\00V\00\00\00\00\00\00\00\00\00\B0\00.symtab\00.strtab
\00.shstrtab\00.text\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00
\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00
\00\00\00\00\00\00\00\00\00\00\00\00\00T\80T\00\00\00\00\00\00\00\00\00
\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00
\00\00\00V\00\00\00!\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00
\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00@\00\00`\00\00\00\00\00
\00\00\00\00\00\00\00\00\00\00	\00\00\00\00\00\00\00\00\00\00\00
\00\00\00\A0\00\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00
\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00T\80
\00\00\00\00\00\00\00\00\00T\80\00\00\00\00\00\00\00\00\00V\90\00\00
\00\00\00\00\00\00\00V\90\00\00\00\00\00\00\00\00\00X\90\00\00\00\00\00
\00\00_start\00__bss_start\00_edata\00_end\00

24/10/2013, 16h28
n5Rzn1D9dC

Citation:

Envoyé par n5Rzn1D9dC

Yep, bah écoute lances-toi si vraiment tu es motivé.

Pour la structure d'un elf32 ou 64, il y a des exemples dans Fasm. Et qui fonctionnent parfaitement.

Tu peux aussi faire simplement un "man elf".
24/10/2013, 17h04
Kannagi

Citation:

Envoyé par AND66

Mais pour en revenir à la question de départ, je veux savoir comment on passe de ça :
à ça :

Si le but est qu'on te fasse ton boulot j'en vois pas l’intérêt (en plus t’être ton projet) , je ne vois pas intérêt si tu ne le fais pas toi même sans comprendre :roll:
Si tu sais pas le faire ben c'est un peu méchant mais abandonne ton projet :aie:

Sinon il y a sur la page wikipédia entete en FR et EN.
Et si tu es un peu plus malin tu l'aurais codé ton code et tu l'aurai compilé avec nasm et t'aurai regardé avec un éditeur hexadécimale le résultat (tout en t'aidant du la doc).
24/10/2013, 17h51
Forthman

Rien que pour toi : lien wiki pour le format ELF

Je pense que tu as du boulot quand-même... :roll:
24/10/2013, 18h54
Obsidian

Citation:

Envoyé par AND66

Mais pour en revenir à la question de départ, je veux savoir comment on passe de ça :

Tu brûles les étapes et comme tu as une idée en tête, ça t'empêche d'explorer les autres possibilités.

On ne passe pas directement de .text movb $0x02, %al à ELF\00\00\00\00\00\ […] 00\00X\90\00\00\00\00\00\00\00_start\00__bss_start\00_edata\00_end\00

… mais de ceci

Code:

MOV AL,02h ; Syntaxe Intel

… à ceci

Code:

B0 02

C'est l'unique code produit par l'assembleur pour la ligne source donnée. Ça te permet notamment de constater que c'est extrêmement concis (et heureusement, sinon les ordinateurs ne se seraient jamais développés ces quarante dernières années).

Ce n'est qu'ensuite que ce code va être encapsulé en tant que ressource dans un format plus ou moins versatile qui permettra de le manipuler et éventuellement de l'associer à d'autres codes compilés. Normalement, c'est le travail de l'éditeur de liens de faire tout cela. Le linker LD de GNU dispose d'une suite de descripteurs de formats binaires appelés BFD qui permettent de faire cela de manière unifiée (et évolutive). L'ennui, c'est que pour manipuler le code, assembleurs, compilateurs et éditeurs de liens ont besoin de méta-informations le concernant et à cause de cela, les assembleurs sont donc obligés de produire leurs fichiers de sortie directement dans le format final. La plupart d'entre eux prennent donc en charge un nombre minimum de formats.

Pour le parsing en particulier, bien que la syntaxe de l'assembleur soit très rudimentaire, il est toujours utile de connaître un minimum de langage formel car la génération du code machine associé est toujours beaucoup plus contextuelle qu'on ne le croit. En outre, il te faudra tenir compte de toutes les directives d'assemblages et être capable de résoudre des expressions arithmétiques complexes, qui sont parfaitement admissibles au sein d'un source en assembleur tant que le résultat est compatible avec le format de l'opérande que l'on cherche à renseigner.
25/10/2013, 10h06
AND66

Pour Obsidian,
B0 02, c' est bien mais je fais comment pour executer ça moi ?
Et pour les autres, je ne vous demande pas de faire le travail à ma place, mais la syntaxe elf dans les détails, je peux pas trouver ça tout seul.

ps : il y a quoi comme éditeur hexa ? 8O
25/10/2013, 11h35
Forthman

Si tu comptes te faire une entête "standard" et jeter ton code à la suite...
tu peux oublier :aie:

Et si tu trouve si peu de personnes pouvant te renseigner, c'est que seules
celles qui ont créé un compilateur peuvent vraiment te répondre :P

Si ton but est "juste" de remplacer une syntaxe par la tienne genre :
mov ax,666 serait remplacé par set regAX = 666
Tu devrais plutôt faire un programme qui fasse la transformation
ton asm -> asm standard (genre FASM qui est assez simple )
et quand tu compiles, et bien tu compies avec fasm mais en l'appelant depuis
ton programme. :roll:

bien que pour moi la meilleure solution est de trouver un assembleur existant à son goût :mrgreen:
25/10/2013, 13h33
Obsidian

Citation:

Envoyé par AND66

Pour Obsidian,
B0 02, c' est bien mais je fais comment pour executer ça moi ?

Eh bien tu lis les commentaires ! Forthman t'a donné le lien vers le format des fichiers ELF !

Y a une première entête qui donne les informations générales sur le fichier et notamment sur l'architecture pour laquelle il a été produit. Puis, le reste de ce fichier est découpé en un certain nombre de sections. C'est le nom de ces sections qui commence par un point « . » comme « .bss », « .text », « .rodata », etc.

Parmi elles, il y en a une, nommée section header, qui forme le catalogue de toutes les sections existantes dans le fichier et qui est référencée directement par l'entête de fichier. Le code exécutable, lui, se trouve dans la section « .text ».

Il y a une autre section spéciale, nommée program header, qui elle sert à indiquer comment on doit charger le programme en mémoire. Elle indique entre autre l'adresse d'implantation, le point d'entrée du programme en mémoire, mais aussi les différentes sections impliquées, ce qui est nécessaire quand l'exécutable à lancer est lié dynamiquement à d'autres bibliothèques.

C'est un format universel et très versatile mais, par conséquent, assez compliqué à mettre en place.