Discussion :

[Linquisiteur]

Bonjour, j'ai remarquer que une jolie commande: "gcc -S prog.c"
permettait de transformer un code en c en temps que assembleur

par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
#include <stdio.h>		
#include <stdlib.h>
 
int main(void)
 { 
 int a, b, c, calcul ;
  a = 5 ;
  b = 3 ;
  c = a + b ;
  printf ("Dafuck : (%d + %d) = %d\n", a, b, c) ;
  printf ("a=%d b=%d c=%d \n",a,b,c);
 a = 2 ;
 c = b - a ;
 printf ("Trololo : (%d - %d) = %d\n", b, a, c) ;
 printf ("a=%d b=%d c=%d \n",a,b,c);
 
  return EXIT_SUCCESS;
 }

est devenue:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
	.file	"Exercice1.c"
	.section	".rodata"
	.align 8
.LLC0:
	.asciz	"Dafuck : (%d + %d) = %d\n"
	.align 8
.LLC1:
	.asciz	"a=%d b=%d c=%d \n"
	.align 8
.LLC2:
	.asciz	"Trololo : (%d - %d) = %d\n"
	.section	".text"
	.align 4
	.global main
	.type	main, #function
	.proc	04
main:
	!#PROLOGUE# 0
	save	%sp, -128, %sp
	!#PROLOGUE# 1
	mov	5, %g1
	st	%g1, [%fp-20]
	mov	3, %g1
	st	%g1, [%fp-24]
	ld	[%fp-20], %o5
	ld	[%fp-24], %g1
	add	%o5, %g1, %g1
	st	%g1, [%fp-28]
	sethi	%hi(.LLC0), %g1
	or	%g1, %lo(.LLC0), %o0
	ld	[%fp-20], %o1
	ld	[%fp-24], %o2
	ld	[%fp-28], %o3
	call	printf, 0
	 nop
	sethi	%hi(.LLC1), %g1
	or	%g1, %lo(.LLC1), %o0
	ld	[%fp-20], %o1
	ld	[%fp-24], %o2
	ld	[%fp-28], %o3
	call	printf, 0
	 nop
	mov	2, %g1
	st	%g1, [%fp-20]
	ld	[%fp-24], %o5
	ld	[%fp-20], %g1
	sub	%o5, %g1, %g1
	st	%g1, [%fp-28]
	sethi	%hi(.LLC2), %g1
	or	%g1, %lo(.LLC2), %o0
	ld	[%fp-24], %o1
	ld	[%fp-20], %o2
	ld	[%fp-28], %o3
	call	printf, 0
	 nop
	sethi	%hi(.LLC1), %g1
	or	%g1, %lo(.LLC1), %o0
	ld	[%fp-20], %o1
	ld	[%fp-24], %o2
	ld	[%fp-28], %o3
	call	printf, 0
	 nop
	mov	0, %g1
	mov	%g1, %i0
	ret
	restore
	.size	main, .-main
	.ident	"GCC: (GNU) 3.3.2"

Qui est de l'assembleur linux. J'aimerais savoir si il existait un convertisseur (ou une commande) pour avoir ce code en asm windows. Ou un outil quelconque qui me permettrait de transformer manuellement et facilement

Merci d'avance

[Obsidian]

Bonjour,

Il n'y a pas « d'assembleur Linux » et « d'assembleur Windows ». Il n'y a que des assembleurs pour le type de micro-processeur pour lequel tu compiles, indépendamment du système d'exploitation que tu utilises et même de la machine sur laquelle tu travailles pourvu qu'elles soient toutes équipées du même CPU.

En revanche, il y a deux choses à souligner :

• Le programme généré va être évidemment adapté à l'OS pour lequel tu compiles, mais les différentes versions d'un même programme travailleront quand même avec les mêmes instructions micro-processeur ;
• Il y a différentes syntaxes pour écrire un même programme en assembleur : généralement, la syntaxe est celle définie par le fondeur de ton CPU mais AT&T a notamment défini une façon propre de les rédiger et c'est elle qui est en vigueur sous Unix par défaut.

Les deux grandes syntaxes d'assembleur sur PC sont donc « Intel » et « AT&T ». Si tu veux que GCC te produise de l'assembleur Intel, il faut lui passer l'option « -masm=intel ».

Tu obtiendras donc le même programme rédigé sous une forme plus habituelle. Ça ne veut pas dire pour autant qu'un programme compilé pour Linux fonctionnera sous Windows (et vice versa) à cause de cela.

[Invité]

gcc (GNU C Compiler) est un élément de la collection de compilateurs GCC (GNU Compilers Collection), dédié au compilation des codes source C. C'est le compilateur C principal des systèmes GNU/Linux. En général, La phase de compilation commence par le prétraitement (preprocess) du code source et se termine par la transformation du code intermédiaire en un code cible, c'est le code assembleur que vous avez obtenu. Pour le gcc le prétraitement est une phase indépendante de la phase du compilation!

Le gcc utilise par défaut l'assembleur GNU as pour assembler. C'est pour ce-là vous avez obtenu avec "gcc -S prog.c" un code cible écrit en assembleur GNU (style AT&T). Donc vous devez utiliser l'option "-masm=intel" pour obtenir un code cible écrit avec la syntaxe Intel. Ce code ne peut être assembler qu'en utilisant le compilateur gcc !