Bonsoir,

Voilà, cela fait un certain moment que je suis bloqué sur le fonctionnement de la pile en assembleur.
Dans le cadre de mes études, je suis en train d'apprendre (sur le tas), la programmation en ASM sur un environnement Linux (GNU). Cela fait un certain temps que j'avais fait un peu d'ASM mais en utilisant les instructions Intel et les registres ax,bx,cx ; du coup, je suis encore un peu largué avec les différentes notations ..... m'enfin la question n'est pas là !
Dernièrement, on a commencé à intégrer du code ASM à des prog C, mais pas directement dans le code C mais en ayant deux fichiers un .c et .s

L'objectif est simple, coder une calculette en notation polonaise, donc devoir empiler les arguments.

L'exemple est tiré du modèle du cours, d'où l'utilisation des registres rax,rbx (sur 64 bits), aussi ayant encore du mal à appréhender l'utilisation de la pile pour les fonctions, au lieu de push rbp j'ai utilisé le registre r15 comme tampon, mais bon toujours aucun résultat ....

Le problème est évident, comment retrouver la bonne valeur du sommet de la pile pour pouvoir récupérer la bonne valeur apres un pop.... Le problème est que, passant par des fonctions, on doit sauvegarder l'état de la pile pour pouvoir en crée une autre pour les var du sous prog, puis revenir aux anciennes valeurs de la pile. Mais bon, clairement quelque chose m'échappe !

Trêve de bavardage :p

Makefile
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
 
pol_calcul: 	pol_calculA pol_calculC
		    	gcc -gstabs -o pol_calcul pol_calculA.o pol_calculC.o
 
pol_calculA: 	pol_calcul.s
				gcc -c -g -o pol_calculA.o pol_calcul.s
 
pol_calculC: 	pol_calcul.c
				gcc -c -g -o pol_calculC.o pol_calcul.c
pol_calcul.c
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
 
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
 
void empiler(int64_t *);
int64_t* depiler();
 
#define MAX_SIZE 100
 
int main() 
{
	int64_t tmp = 2;
	int64_t* d;
 
	printf("tmp = %ld || &tmp = %p \n",tmp,&tmp);
 
        empiler(&tmp);
	printf("empiler &tmp ....\n");
 
	d = depiler();
	printf("depiler tmp .... = %ld\n",*d)		
 
	return 0;
}
pol_calcul.s
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
 
.data
.text
 
.global empiler
.type empiler, @function
empiler:
	movq %rbp, %r15		# sauvegarde pointeur base 
	movq %rsp, %rbp
	pushq %rdi
	movq %rbp, %rsp     		# restauration pointeur base
	movq %r15, %rbp
	ret
 
.global depiler
.type depiler, @function
depiler:
	movq %rbp, %r15            # sauvegarde pointeur base
	movq %rsp, %rbp
	movq %rdi, %rax
	movq %rbp, %rsp            # restauration pointeur base 
	movq %r15, %rbp
	ret
Voilà, je suis ouvert à toute proposition, aussi si vous avez de bonne références pour en apprendre plus.
D'avance merci