Récupérer des valeurs en mémoire

**TheFatalError** · 30/12/2014, 23h27

Bonjour à tous,

Je débute en assembleur. Je voulais explorer un peu le sujet et faire un petit fizzbuzz pour commencer dans ce langage, histoire de me faire la main. Ceci dit, je souhaite le faire en TDD. Mais, je n'ai pas trouvé de framework en assembleur. Alors, j'ai décidé d'en faire un, un très basique qui vérifie les égalités via un assertEqual.

Alors, je suis sous Linux et utilise Nasm. Architecture x86, 64bits, syntaxe Intel.

Mon problème c'est que dans mon fichier FizzBuzz.asm j'entre deux valeurs via push (j'ai aussi essayé en utilisant mov) que je voudrais vérifier dans le fichier AUnit.asm via un call assertEqual. Mais je n'arrive pas à récupérer mes valeurs entrés dans le fichier FizzBuzz (push 1 et push 1) pour les faire passer dans ma boucle dans AUnit.

Mon fichier AUnit se présente comme ça :

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
segment .text
  global main
 
segment .data
 
  msg_green:     db "Passed", 10
  size_green:     equ $ - msg_green
  msg_red:     db "Failed", 10
  size_red:     equ $ - msg_red
 
  main:
 
    assertEqual:
      mov rax, 1
      mov rbx, 1
    loop:
      cmp rax, rbx
      je found
      jne notfound
    found:
      mov rax, 4
      mov rbx, 1
      mov rcx, msg_green
      mov rdx, size_green
      int 80h
      jmp exit
    notfound:
      mov rax, 4
      mov rbx, 1
      mov rcx, msg_red
      mov rdx, size_red
      int 80h
 
    exit:
      mov rax, 1
      mov rbx, 0
      int 80h

Bon, le code fonctionne mais avec des valeurs en "dur", ici 1 et 1 qui vérifie l'égalité.

Je souhaite pouvoir récupérer ces valeurs à partir du fichier FizzBuzz. Mais j'arrive pas à connecter les deux. J'ai essayé de jouer avec les registres et la pile en vain. Voilà, je m'en remets à vous car je tourne en rond.

Pour avoir une idée de mon fichier FizzBuzz :

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
%include "AUnit.asm"
 
segment .text
 
    global main
 
      _main:
 
      test_truth:
        push 1
        push 1
        call assertEqual
 
        mov rax, 1
        mov rbx, 0
        int 80h

**TheFatalError** · 01/01/2015, 22h39

Pourquoi lorsque j'essaie de récupérer la valeur dans la pile ça ne fonctionne pas ?

Fichier AUNit

Code :

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

1
2
3
assertEqual:
      mov rax, [rsp+4]
      mov rbx, [rsp+8]

Fichier FizzBuzz

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
%include "AUnit.asm"
 
segment .text
 
    global main
 
      _main:
 
        test_truth:
        push 1
        push 1
        call assertEqual
        add rsp, 8
 
        mov rax, 1
        mov rbx, 0
        int 80h

Je ne vois vraiment pas comment faire...

**bifur** · 02/01/2015, 00h11

la je m'apprête a me coucher donc je n'ais hélas pas asser de neurone pour analyser tout ton probleme mais en survolant le truc je suis tombé sur ça:

Code :

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

1
2
3
assertEqual:
      mov rax, [rsp+4]
      mov rbx, [rsp+8]

si c'est sensé récupérer (sans dépiler) les valeur de la pile il me semble qu'il va y avoir un petit soucis avec les décalage car les registre qui commence par R font 64bit soit 8 octets a ta place j'essayerait ceci:

Code :

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

1
2
3
assertEqual:
      mov rax, [rsp+8]
      mov rbx, [rsp+16]

sur ce bonne nuit...

et bonne année aussi!

**TheFatalError** · 02/01/2015, 01h02

Merci pour ta réponse et bonne année !

Tu as surement raison pour le décalage. Hélas, j'avais déjà essayé avec +8 et +16 sans que cela fonctionne.

J'ai l'impression de passer au travers des valeurs du fichier FizzBuzz.

Normalement, si j'ai bien compris. En utilisant push, j'envoie ma valeur dans la pile (et ce qui crée aussi un décalage en octet) et je peux la récupérer via un pop (qui annule le décalage) sinon la méthode que j'ai utilisé est celle qui consiste à rajouter à rsp le décalage créer par les push.

Je me demande ce qui cloche...

En tout cas merci, d'avoir essayé.

**bifur** · 03/01/2015, 13h34

j'avait pas vu que c'etait après un call que tu essayait de recuperer les valeur...
mais il faut se mefier car lors d'un call, l'adresse de retour est sauvegardé sur la pile, si le call est dans le même segment de mémoire on ne sauvegarde que (e)ip et lorsque que c'est dans un autre segment de mémoire on sauvegarde aussi cs. par contre je t'ais décrit le fonctionnement en 32 et 16bits, je ne sait pas comment ça fonctionne en 64bits mais je suis certains que quelquechose est mis sur la pile lors d'un call en 64bits

le plus simple pour toi serait de passer les argument par les registres plutôt que par la pile

**TheFatalError** · 03/01/2015, 16h40

Lorsque je passe par les registres, je passe aussi au travers...

Le pire, c'est que rsp+8 et rsp+16 fonctionne lorsque tout est mis dans le même fichier mais dès que j'appelle le même code dans un autre fichier, je perds quelque chose en route et impossible d'afficher les bons résultats.

Invité · 03/01/2015, 18h58

Salut,

Je n'arrive pas à comprendre comment tu n'as pas d'erreur en ne spécifiant aucun type de donnée:

Code :

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

1
2
3
 
push 1
push 1

Normalement, il faut en mettre un (byte, word, dword, qword) avant la valeur.

Comment se déroule l'assemblage de ton programme ? je voit deux .global main, pourquoi ?

Je te conseille vivement d'utilise des variables globales pour passer des parametres dans les fonctions quant tu code en assembleur: la pile, c'est le mal

Je voit que tu utilise la pille sans l'initialisé:

Code :

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

1
2
3
4
5
6
 
main:
sub    rsp, {value#0}
      ; code
add    rsp, {value#0}
ret

N'oublie pas que si tu utilises la pile sans l'initialiser, tu fausse l'adresse de retour que l'OS a sauvegarder dans sa propre pile, l'OS fait un call vers ton programme et par conséquent il sauvegarde l'adresse de retour de ton prog.

D'ailleurs c'est un bon hack ce genre de manoeuvre, dans le sens que si tu est dans une sous fonction de ton programme et que tu veux quitter ton programme sans passer dans les sous fonctions superieurs jusqu'au main.

Tu ajoutes à rsp, toutes les valeurs précédemment soustraite à ce registre utilisé pour la pile + l'adresse de retour que l'OS a sauvegardé avant l'appel de ton programme (OS 64-bit: 8 bytes, 32-bit: 4 byte)

PS:

Code :

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

 size_red:     equ $ - msg_red

peut etre transformé en

Code :

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

 size_red:     size_red - msg_red

ou encore en:

Code :

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

size_red:

Code :

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

mov    rdx, size_red - msg_red

**TheFatalError** · 04/01/2015, 18h56

En effet, le global dans le fichier FizzBuzz était un résidu d'un autre code, je l'ai nettoyé. J'ai aussi initialisé la pile et rajouter un qword. Ceci dit, cela n'a pas réglé le problème.

En tout cas, merci pour les conseils.

Invité · 04/01/2015, 21h06

Ok, et si tu re-post ton code complet, ça serait plus aisé de repérer le problème.

**TheFatalError** · 04/01/2015, 22h48

Ok, voilà.

AUnit :

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
segment .text
 
  global main
 
segment .data
 
  msg_green:     db "Passed", 10 
  size_green:     equ $ - msg_green
  msg_red:     db "Failed", 10 
  size_red:     equ $ - msg_red
 
  main:
 
    assertEqual:
      mov rax, [rsp+8]
      mov rbx, [rsp+16]
    loop:
      cmp rax, rbx
      je found
      jne notfound
    found:
      mov rax, 4
      mov rbx, 1
      mov rcx, msg_green
      mov rdx, size_green
      int 80h
      jmp exit
    notfound:
      mov rax, 4
      mov rbx, 1
      mov rcx, msg_red
      mov rdx, size_red
      int 80h
 
    exit:
      mov rax, 1
      mov rbx, 0
      int 80h

FizzBuzz :

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
%include "AUnit.asm"
 
segment .text
 
	  test_truth:
            sub rsp, 0
	    push qword 1
	    push qword 1
	    call assertEqual
	    add rsp, 16
 
            add rsp, 0
            ret
            mov rax, 1
	    mov rbx, 0
            int 80h

PS : J'ai remarqué que lorsque j'initialisé la pile et que je mets tout sur le même fichier cela me donne passed et failed à la suite... alors que je devrais juste avoir passed...

Invité · 05/01/2015, 00h31

Essaye avec ça:

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
 
 
global main
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
segment .data
 
	msg_green		db "Passed", 10
	end_msg_green:
 
	msg_red			db "Failed", 10 
	end_msg_red:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
segment .text
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
assert_equal:
	mov 	eax, [rsp + 8]
	cmp 	eax, [rsp + 12]
	jne		not_found
		found:
				mov		rax, 4
				mov		rbx, 1
				mov		rcx, msg_green
				mov		rdx, end_msg_green - msg_green
				int		0x80
			jmp		exit
	not_found:
			mov		rax, 4
			mov		rbx, 1
			mov		rcx, msg_red
			mov		rdx, end_msg_red - msg_red
		int		0x80
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
test_truth:
sub		rsp, (4 + 4)
		mov		[rsp], dword 1
		mov		[rsp + 4], dword 1
	call 	assert_equal
add 	rsp, (4 + 4)
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Start:
	call	test_truth
 
	; Exit program
		mov		rax, 1
		mov		rbx, 0
		int		0x80
; ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Je te conseille de travailler sur des variables/données de 4 octets, plus compact et plus économe en mémoire, 2^32 - 1 possibilitées est pas mal.

**TheFatalError** · 05/01/2015, 01h04

Ça donne des failed en boucle jusqu'au segment fault. C'est un peu le stack level too deep en langage haut niveau.

Ceci dit, le code précédent fonctionne sur un même fichier mais lorsque je sépare celui ci, ça ne fonctionne plus. D'où mon interrogation. Je me dis que cela doit être possible sinon comment on aurait inventer les librairies...

[edit]La boucle infinie était du a cause du manque d'un jump vers exit dans notfound. De toute façon, la valeur était fausse.

Invité · 05/01/2015, 02h52

Bon je t'ai apporté un petit correctif, dingue que j'ai pas vu ce genre de faute:

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
70
71
72
 
 
global main
;================================================================================================
;CODE	CODE	CODE	CODE	CODE	CODE	CODE	CODE	CODE	CODE	CODE	CODE
;================================================================================================
[section .code use64]
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
main:
	call	test_truth
 
	; Exit program
			mov		rax, 1
			mov		rbx, 0
		int		0x80
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;================================================================================================
;END_CODE	END_CODE	END_CODE	END_CODE	END_CODE	END_CODE	END_CODE	END_CODE
;================================================================================================
 
;========================================================================================================
;FONCTIONS		FONCTIONS		FONCTIONS		FONCTIONS		FONCTIONS		FONCTIONS		FONCTIONS
;========================================================================================================
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
assert_equal:
	mov 	eax, [rsp + 8]
	cmp 	eax, [rsp + 12]
	jne		not_found
		found:
				mov		rax, 4
				mov		rbx, 1
				mov		rcx, msg_green
				mov		rdx, end_msg_green - msg_green
			int		0x80
		ret
	not_found:
		mov		rax, 4
		mov		rbx, 1
		mov		rcx, msg_red
		mov		rdx, end_msg_red - msg_red
	int		0x80
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
test_truth:
sub		rsp, (4 + 4)
		mov		[rsp], dword 1
		mov		[rsp + 4], dword 1
	call 	assert_equal
add		rsp, (4 + 4)
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;====================================================================================================
;END_FONCTIONS		END_FONCTIONS		  END_FONCTIONS	    	END_FONCTIONS	    	END_FONCTIONS
;====================================================================================================
 
;================================================================================================
;DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA
;================================================================================================
[section .data use64]
 
	msg_green		db "Passed", 10
	end_msg_green:
 
	msg_red			db "Failed", 10 
	end_msg_red:
 
;================================================================================================
;END_DATA	END_DATA	END_DATA	END_DATA	END_DATA	END_DATA	END_DATA	END_DATA
;================================================================================================

**TheFatalError** · 05/01/2015, 04h44

Ça fonctionne au top mais pas lorsque je sépare les fichiers.

Je pense que je vais arrêter de me prendre la tête et tout mettre sur un même fichier. Même si cela m'embête...

En tout cas merci pour les conseils, j'aurais appris des choses.

Le sujet reste ouvert au cas où certain aurait la solution.

Invité · 05/01/2015, 05h53

De rien, mais qu'entend tu par séparer tes fichiers, tu veux avoir combien d'exécutables ?

Ou cherches-tu as appelé ta fonction (assert_equal) asm assemblé, avec d'autres langages ?

**Forthman** · 05/01/2015, 14h11

zut, j'avais fait une réponse, mais j'ai du oublier de la poster

En gros, je disais que comme le soulignais Bifur, un CALL en 64 bits laisse sur la pile, une adresse
de retour de ... 64 bits

donc effectivement il faut commencer à lire à partir du 8eme octet pour avoir la valeur précédente de la pile (à condition que le call en question
ne dépose que l'adresse et pas autre-chose)

Je ne connais pas Nasm, et ton fichier AUnit.asm me semble bizarre car ayant lui aussi un "global main"
mais peut-être que ça doit se passer comme ça avec Nasm

Par contre, la dernière remarque de Typoli me fait me poser une question :
tu ne cherches pas à créer deux fichiers exécutables distincts si ?

**TheFatalError** · 05/01/2015, 14h21

Je voulais juste faire un petit framework accessible sous Linux en 32-64bit que d'autres pourraient utilisés si besoin pour faire du TDD.

Invité · 05/01/2015, 15h00

-C'est quoi du TDD ?

Et pour ton framework et bien tu pourrais laisser le code-source tel quel, puis de définir le prologue de ta fonction, comme ceci:

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
 
;=============================================================================
 ; void assert_equal(dword nbr#0, dword nbr#1)
 ; Compare l'égalité entre nbr#0 et nbr#1, et affiche Passed si égalité et Failed, si ce n'est pas égale.
 ; Entrée : rsp + 8 : nbr#0
 ;		rsp + 12 : nbr#1
 ; Sortie: rbx
 ; Destroyed: rax - rbx - rcx - rdx
 ; DATA:
	msg_green		db "Passed", 10
	end_msg_green:
 
	msg_red			db "Failed", 10 
	end_msg_red:
;=============================================================================
assert_equal:
	mov 	eax, [rsp + 8]
	cmp 	eax, [rsp + 12]
	jne		not_found
		found:
				mov		rax, 4
				mov		rbx, 1
				mov		rcx, msg_green
				mov		rdx, end_msg_green - msg_green
			int		0x80
		ret
	not_found:
		mov		rax, 4
		mov		rbx, 1
		mov		rcx, msg_red
		mov		rdx, end_msg_red - msg_red
	int		0x80
ret
		;=============================================================================================================
 ; / assert_equal	;=============================================================================================================

Hack: Tu peux mélanger les données et le code tant que tu n'essaieras pas de modifier les data et que tu ne les exécutes pas. C'est pour une meilleure lisibilité du code.

**TheFatalError** · 05/01/2015, 18h46

Le TDD, c'est le développement piloté par les tests. C'est une pratique de l'Extreme Programming, c'est aussi une méthode agile. Ça consiste en gros de faire des tests avant d'écrire son code. Ca aide à avoir confiance en son code surtout lorsque celui-ci devient volumineux.

Il y a cette page qui en parle simplement : http://referentiel.institut-agile.fr/tdd.html