[TASM/8086][Débutant] Récupération de valeurs mises dans la pile

**jojo_ol76** · 17/02/2008, 14h02

Bonjour,

je souhaite mettre les valeurs dans la pile à l'aide d'un microcontroleur 8086 TASm comme compilateur:

Code :

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

1
2
3
4
5
tableau1		db	1 dup (0,1,2,3,4,5,6,7,8,9)
 
tableau3		db	40 dup (?)
 
tableau2		dw	1,5,8,9,2

Je veux réaliser la sauvegarde de la pile au début puis une restitution à la fin de la procédure.

La procédure ne doit pas modifier les registres et réalise un calcul qui reçoit des paramètres :

n°1: les 5 valeurs du tableau2 (5mots)
n°2: taille des tableaux de donnée (1mot)
n°3: adresse du tableau1 (1mot)
n°4: adresse du tableau2 (1mot)

tableau3:
y0=(a0*x0+a1*x1+a2*x2+a3*x3+a4*x4)/somme(des valeurs du tableau3)
-------
yn-2=(a0*xn-2+a1*xn-1)/somme(des valeurs du tableau3)
yn-1=(a0*xn-1)/somme(des valeurs du tableau3)

A la fin du calcul, je veux vérifier les résultats dans le débugger que le tableau3

La seule chose c'est que je n'arrive pas à savoir comment procéder pour le calcul des y à l'aide de la pile et accéder aux valeurs du tableau1 et 2.

**Neitsa** · 17/02/2008, 16h46

Bonjour,

Envoyé par jojo_ol76

je souhaite mettre les valeurs dans la pile à l'aide d'un microcontroleur 8086 TASm comme compilateur:

tableau1 db 1 dup (0,1,2,3,4,5,6,7,8,9)

tableau3 db 40 dup (?)

tableau2 dw 1,5,8,9,2

Si tu veux pousser tes tableaux sur la pile il faudra le faire en début de procédure.

je veux réaliser la sauvegarde de la pile au début puis une restitution à la fin de la procédure.

Si tu veux restituer l'état de la pile en sortie de procédure, il faudra la sauvegarder quelque part, dans un tableau par exemple.

la procédure ne doit pas modifier les registres

C'est impossible. Si tu souhaites réaliser des calculs, il faudra à un moment ou à un autre utiliser des registres. Les instructions à double opérande mémoire sont rares dans le jeu x86 et cela ne concerne pas les instructions arithmétiques, d'où l'obligation d'utiliser un registre au minimum.

et réalise un calcul qui reçoit des paramètres:

n°1: les 5 valeurs du tableau2 (5mots)
n°2: taille des tableaux de donnée (1mot)
n°3: adresse du tableau1 (1mot)
n°4: adresse du tableau2 (1mot)

Pour ton paramètre n°1, tu passes l'adresse du tableau 2, n'est-ce pas ? Sinon cela fait 5 paramètres supplémentaire au lieu d'un seul.

Pour le param 2, tu comptes passer la taille des 3 tableau sur un seul mot ?

tableau3:
y0=(a0*x0+a1*x1+a2*x2+a3*x3+a4*x4)/somme(des valeurs du tableau3)
-------
yn-2=(a0*xn-2+a1*xn-1)/somme(des valeurs du tableau3)
yn-1=(a0*xn-1)/somme(des valeurs du tableau3)

J'avoue avoir du mal à comprendre à quoi correspondent les lettres... On en est réduit à deviner, une explication claire n'aurait pas été de trop.

Tentative :

y : Tableau 3
a : Tableau 1
x : Tableau 2
n : index de boucle

avec : yw où w = index dans le tableau ?

A la fin du calcul je veut vérifier les résultats dans le débugger que le tableau3

Pas compris la phrase...

**jojo_ol76** · 17/02/2008, 18h23

les y seront les valeurs du tableau3

les x sont les valeurs du tableau1

les a sont les valeurs du tableau2

les resultats donc les calculs de y devra etre observable dans le debuggeur.

le param 2: cé la taille du tableau 1 dsl pour l'explication rapide

la somme du tableau2 est égale à 16 dc je veut utiliser le décalage à droite de 4 bits pour effectuer la division

**Neitsa** · 18/02/2008, 11h17

Bonjour,

il y a toujours plusieurs choses que je ne comprends pas :

1) Pourquoi faire le calcul sur la pile ? à moins que ce soit un exercice, c'est se compliquer la vie pour rien.

2) Après correction :

n°1: les 5 valeurs du tableau2 (5mots)
n°2: taille du tableau1 (1mot)
n°3: adresse du tableau1 (1mot)
n°4: adresse du tableau2 (1mot)

- Pourquoi passer les valeurs du tableau2 dans les premiers paramètres alors que l'on passe l'adresse du même tableau en n°4 ?

- Que va-t-on mettre sur la pile exactement ? Les adresses des tableaux ? les valeurs des tableaux 1 ou 2 ou 3 ? les valeurs des trois tableaux ?

y0=(a0*x0+a1*x1+a2*x2+a3*x3+a4*x4) / somme(des valeurs du tableau3)

3) Au moment où l'on réalise cette opération, tableau3 est vide : tous les éléments sont à zéro, ou pire, ils sont indéfinis.
Du coup, la somme des valeurs du tableau3 vaut 0, donc : division par zéro ou division par n'importe quoi.

------------

Revoit la question de fond en comble en nous disant avec exactitude ce que tu dois faire, ou ce que tu cherches à faire.

Tant que ça n'est pas clair, on ne pourra même pas amorcer une ébauche de solution.

Aurais-tu un début de code montrant ce que tu cherches à faire ? Parfois un morceau de code vaut mieux qu'un long discours

**jojo_ol76** · 19/02/2008, 16h19

voici ce que j'ai corrigé

n°1: les 5 valeurs du tableau2 (5mots)
n°2: taille du tableau1 (1mot)
n°3: adresse du tableau1 (1mot)
n°4: adresse du tableau3 (1mot)

**jojo_ol76** · 19/02/2008, 16h31

récapitulatif de l'exo:

le tableau1 des valeurs à filtrer contient n octets: tableau1=(x0,x1,x2....,xn-1)

les coeff du filtre sont rangés dans un tableau2: tableau2=(a0,a1,a2,a3,a4)

le résultat du filtrage est stocké dans le tableau3=(y0,y1,....yn-1)

tableau3:
y0=(a0*x0+a1*x1+a2*x2+a3*x3+a4*x4)/somme(des valeurs du tableau3)
-------
yn-2=(a0*xn-2+a1*xn-1)/somme(des valeurs du tableau3)
yn-1=(a0*xn-1)/somme(des valeurs du tableau3)

La procédure ne doit pas modifier les registres et réalise un calcul qui reçoit des paramètres :

n°1: les 5 valeurs du tableau2 (5mots)
n°2: taille des tableau1 (1mot)
n°3: adresse du tableau1 (1mot)
n°4: adresse du tableau3 (1mot)

La procédure ne doit pas modifier les registres(sauvegarde dans la pile au début, restitution à la fin de la procédure)

voici un bout de programme:

Code :

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

1
2
3
4
5
tableau1 db 1 dup (0,1,2,3,4,5,6,7,8,9)
 
tableau3 db 40 dup (?)
 
tableau2 dw 1,4,6,4,1

la somme des coeff est = à 16, la division sera dc réalisée par un décalage à droite de 4 bits.

taille des tableaux: 40 octets

a la fin du calcul, je dois vérifié que tout les y calculés seront visible dans le débuggeur TASM.

**Neitsa** · 24/02/2008, 12h42

Envoyé par jojo_ol76

récapitulatif de l'exo:

La procédure ne doit pas modifier les registres [...]
La procédure ne doit pas modifier les registres(sauvegarde dans la pile au début, restitution à la fin de la procédure)

D'après ce que je comprends de l'exercice à présent, le calcul ne doit pas être spécifiquement réalisé sur la pile, mais on doit uniquement sauvegarder les registres au début de la procédure et les restituer à la fin, donc :

Utilisation des instructions PUSHA / POPA (ou PUSHAD / POPAD en 32 bits).

On aura donc cela (syntaxe masm):

Code asm :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Calcul PROC ...
 
PUSHAD ; sauvegarde de tous les registres sur la pile
 
 
; faire le calcul avec les tableaux, sauvegarder les résultats dans tableau3
 
 
POPAD ; restitution des registres sauvegardés par PUSHAD
 
ret
 
end Calcul

------------

tableau3:
y0=(a0*x0+a1*x1+a2*x2+a3*x3+a4*x4)/somme(des valeurs du tableau3)
-------
yn-2=(a0*xn-2+a1*xn-1)/somme(des valeurs du tableau3)
yn-1=(a0*xn-1)/somme(des valeurs du tableau3)

Tu n'as pas répondu à ma précédente question : La division par la somme du tableau3 est impossible, car au moment où l'on réalise la première opération, tableau3 (yx) n'a jamais eu aucune affectation

Soit tu va diviser par zéro, soit par une valeur aléatoire (suivant ce qui se trouve dans tableau3 à ce moment là).

C'est un comportement indéfini

------------------

Maintenant, reprenons ce passage :

n°1: les 5 valeurs du tableau2 (5mots)
n°2: taille des tableau1 (1mot)
n°3: adresse du tableau1 (1mot)
n°4: adresse du tableau3 (1mot)

Pour le paramètre n°1, passe-t-on l'adresse du tableau2 ou les 5 valeurs du tableau2 (comme c'est écrit précisément) ? Dans ce dernier cas de figure on aura plutôt :

Param 1 : tab2[0]
Param 2 : tab2[1]
Param 3 : tab2[2]
Param 4 : tab2[3]
Param 5 : tab2[4]
Param 6 : Taille tab1
Param 7 : Adresse tab1
Param 8 : Adresse tab3

Quelle façon est la bonne ? (il y a ambiguïté dans la description que tu donnes).

-----------------

la somme des coeff est = à 16, la division sera dc réalisée par un décalage à droite de 4 bits.

Ok, pas de problème. Effectivement dans la première description, les valeurs ne faisaient pas 16 au total.

-----------------

taille des tableaux: 40 octets

D'après cette description, un seul des tableau fait 40 octets :

tableau1 db 1 dup (0,1,2,3,4,5,6,7,8,9) ; 10 octets

tableau2 dw 1,4,6,4,1 ; 10 octets

tableau3 db 40 dup (?) ; 40 octets

-----------------

a la fin du calcul, je dois vérifié que tout les y calculés seront visible dans le débuggeur TASM.

Ok, il suffira de surveiller le tableau3, ça ne pose pas de problème outre mesure.

-----------------

Aurais-tu un semblant d'algorithme (ou pseudo-code), même très succinct, décrivant la manière dont tu va mettre en œuvre ton code en assembleur ?

Ou bien aurais-tu un début de code en assembleur autre que la déclaration des trois tableaux ?

**jojo_ol76** · 24/02/2008, 14h06

dsl pour ma tromperie sur l'exo:

c'est la somme de tableau2 qui est le diviseur

tableau3:
y0=(a0*x0+a1*x1+a2*x2+a3*x3+a4*x4)/somme(des valeurs du tableau2)
-------
yn-2=(a0*xn-2+a1*xn-1)/somme(des valeurs du tableau2)
yn-1=(a0*xn-1)/somme(des valeurs du tableau2)

pour ce que tu as dis c'est tout à fait ça qui faut faire:

Param 1 : tab2[0]
Param 2 : tab2[1]
Param 3 : tab2[2]
Param 4 : tab2[3]
Param 5 : tab2[4]
Param 6 : Taille tab1
Param 7 : Adresse tab1
Param 8 : Adresse tab3

pour la déclaration des tableaux dont voici les 40 octets:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
tableau1		db	1 dup (0,1,2,3,4,5,6,7,8,9,10,9,8,7,6,5,4,3,2,1, \
 
			0,1,2,3,4,5,6,7,8,9,10,9,8,7,6,5,4,3,2,1)
 
 
 
tableau3	db	40 dup (?)
 
 
 
tableau2	dw	1,4,6,4,1

voici un bout de mon programme :

tableau1 est tabx
tableau2 est taba
tableau3 est taby

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
name programme 
 
		.MODEL SMALL	; tout dans le même segment
 
		.386
 
;*************** segment de pile
 
		.STACK 100h
 
;*************** segment de données
 
		.DATA
 
 
 
commencement	db	"debut",13,10,"$"
 
terminaison 	db    	"fin",13,10,"$"
 
 
 
tabx		db	1 dup (0,1,2,3,4,5,6,7,8,9,10,9,8,7,6,5,4,3,2,1, \
 
			0,1,2,3,4,5,6,7,8,9,10,9,8,7,6,5,4,3,2,1)
 
 
 
taby		db	40 dup (?)
 
 
 
taba		dw	1,4,6,4,1
 
 
 
;*************** segment de données
 
		.CODE
 
 
 
DEBUT:		mov 	ax,@data
 
		mov 	ds,ax		
 
 
 
lea ax,commencement
 
call affich
 
PILE:
 
mov bx,taba[0]   ;bp=0
 
push bx
 
mov bx,taba[1] ;bp+2
 
push bx
 
mov bx,taba[2] ;bp+4
 
push bx
 
mov bx,taba[3] ;bp+6
 
push bx
 
mov bx,taba[4] ;bp+8
 
push bx
 
mov bx,size tabx
 
push bx ;bp+10
 
 
 
mov bx,offset tabx ;bp+12
 
push bx
 
mov bx,offset taby ;bp+14
 
push bx
 
 
 
mov bp,sp
 
;********************************************************
 
;*	fonction de fin de programme			*
 
;********************************************************
 
fin:		mov	ax,4c00h
 
		int	21h
 
;********************************************************
 
 
 
;********************************************************
 
;*	fonction d'affichage				*
 
;*	parametre d'entrée dans ax: adresse du texte 	*
 
;*	à afficher					*
 
;********************************************************
 
affich:			
 
		mov	dx,ax
 
		mov	ah,9
 
		int	21h
 
		ret
 
end debut

**jojo_ol76** · 24/02/2008, 14h11

algorithme simplifié:

-declaration des tableaux

-mise en pile des 8 paramètres (sauvegarde dans la pile)

-appel de la procédure effectuant les opération des y grâce à la pile en utilisant les offset et le décalage pour passer à la n ième valeur du tabx

-restitution à la fin de la procédure des valeurs calculé de y dans le débuggeur

**Neitsa** · 26/02/2008, 16h22

Bonjour,

Dans un premier temps, si tu bloques toujours, essaye de faire la boucle générale (c-a-d sans les derniers cas où des membres de l'équation sont rejetés).

En (pseudo) C elle se résume à ceci :

Code C :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
char* Calcul (ushort  Tab2_1, ushort  Tab2_2, ushort  Tab2_3, ushort  Tab2_4, ushort  Tab2_5, size_t Tab1_Size, unsigned char * Tab1, unsigned char * Tab3)
{
    int i;
 
    for (i =0; i < Tab1_Size - 4; i++)
    {
        Tab3[i] = ( (Tab2_1 * Tab1[i]) + (Tab2_2 * Tab1[i+1]) + (Tab2_3 * Tab1[i+2]) + (Tab2_4 * Tab1[i+3]) + (Tab2_5 * Tab1[i+4]) ) / 16;
    }
 
    return Tab3;
}

En assembleur, c'est relativement simple, tu pousses (PUSH) tout avant d'appeler ta fonction de calcul, comme ça tu aura tout sur la pile.

Une fois dans la fonction de calcul (en 32 bits, désolé... y'a plus qu'a adapter pour le 16 bits) :

- commence par un PUSHAD pour tout sauvegarder.
- Utilise un registre comme index de boucle (ECX par exemple). C'est 'i' en dans le code C.
- Charge l'adresse d'un tableau (Tab1) dans ESI.
- Charge l'adresse d'un tableau (Tab3) dans EDI.

Ensuite, pour faire ça :

Code :

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

1
2
 
 (Tab2_1 * Tab1[i]) + (Tab2_2 * Tab1[i+1])

On peut faire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
mov eax, Tab2_1 ; EAX = Tab2_1
movzx ebx, byte ptr [esi + ecx]; EBX = Tab1[i]
imul eax, ebx ; eax = Tab2_1 * Tab1[i]
 
mov edx, eax ; sauvegarde résultat multiplication.
 
mov eax, Tab2_2 ; EAX = Tab2_2
movzx ebx, byte ptr [esi + ecx + 1]; EBX = Tab1[i+1]
imul eax, ebx ; eax = Tab2_2 * Tab1[i+1]
 
add edx, eax ; edx = (Tab2_1 * Tab1[i]) + (Tab2_2 * Tab1[i+1])
 
; et ainsi de suite

Pour la division, tu peux utiliser un simple SHR 4 (division par 16).

Pour la sauvegarde du résultat :

Code :

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

1
2
 
mov byte ptr [edi + ecx], dl ; Tab3[i] = résultat total

Voilà tu as déjà le cas général de l'équation. Pour les cas particuliers (à partir de n-4) il suffira de supprimer un terme de l'équation à chaque boucle.

**jojo_ol76** · 27/02/2008, 16h26

voici ce que j'ai fait mais cela ne fonctionne pas:

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
 name programme 
 
		.MODEL SMALL	; tout dans le même segment
 
		.386
 
;*************** segment de pile
 
		.STACK 100h
 
;*************** segment de données
 
		.DATA
 
 
 
commencement	db	"debut",13,10,"$"
 
terminaison 	db    	"fin",13,10,"$"
 
 
 
tabx		db	1 dup (0,1,2,3,4,5,6,7,8,9,10,9,8,7,6,5,4,3,2,1, \
 
			0,1,2,3,4,5,6,7,8,9,10,9,8,7,6,5,4,3,2,1)
 
 
 
taby		db	40 dup (?)
 
 
 
taba		dw	1,4,6,4,1
 
 
 
;*************** segment de données
 
		.CODE
 
 
 
DEBUT:		mov 	ax,@data
 
		mov 	ds,ax		
 
 
 
lea ax,commencement
 
call affich
 
PILE:
 
mov bx,taba[0]   ;bp=0
 
push bx
 
mov bx,taba[1] ;bp+2
 
push bx
 
mov bx,taba[2] ;bp+4
 
push bx
 
mov bx,taba[3] ;bp+6
 
push bx
 
mov bx,taba[4] ;bp+8
 
push bx
 
mov bx,size tabx
 
push bx ;bp+10
 
 
 
mov bx,offset tabx ;bp+12
 
push bx
 
mov ax,offset taby ;bp+14
 
push ax
 
call calcul
 
 
 
calcul:
 
mov cx,0
 
mov di,0
 
 
 
 
 
repet5:
 
mov ax,[bx] ;récup de valeur de x
 
imul ax,[bp] ; multiplication val de x avec val de a
 
add di,ax ; addition des termes
 
inc bp
 
inc bp  ; incrémentation de 2 fois sur la pile
 
inc bx
 
inc cx
 
cmp cx,5
 
jne repet5
 
 
 
 
 
;div cx,16
 
shr 4
 
mov si,cx
 
push si
 
mov bp,0
 
dec bx
 
dec bx
 
dec bx
 
dec bx       ; recup de x1
 
inc di
 
cmp di,36
 
jne calcul
 
inc bx
 
mov cx,0
 
yn4:
 
 
 
 
 
mov ax,[bx] ;récup de valeur de x
 
imul ax,[bp] ; multiplication val de x avec val de a
 
 
 
add cx,ax ; addition des termes
 
inc bp
 
inc bp  ; incrémentation de 2 fois sur la pile
 
inc bx
 
cmp cx,4
 
jne yn4
 
;div cx,16
 
mov si,cx
 
div si,16
 
push si
 
mov bp,0
 
dec bx
 
dec bx
 
dec bx   ; recup de xn-3
 
mov cx,0
 
 
 
 
 
yn3:
 
 
 
 
 
mov ax,[bx] ;récup de valeur de x
 
imul ax,[bp] ; multiplication val de x avec val de a
 
 
 
add cx,ax ; addition des termes
 
inc bp
 
inc bp  ; incrémentation de 2 fois sur la pile
 
inc bx
 
cmp cx,3
 
jne yn3
 
;div cx,16
 
shr 4
 
mov si,cx
 
push si
 
mov bp,0
 
dec bx
 
dec bx   ; recup de xn-2
 
mov cx,0
 
 
 
 
 
yn2:
 
 
 
 
 
mov ax,[bx] ;récup de valeur de x
 
imul ax,[bp] ; multiplication val de x avec val de a
 
 
 
add cx,ax ; addition des termes
 
inc bp
 
inc bp  ; incrémentation de 2 fois sur la pile
 
inc bx
 
cmp cx,2
 
jne yn2
 
;div cx,16
 
shr 4
 
mov si,cx
 
push si
 
mov bp,0
 
dec bx   ; recup de xn-1
 
 
 
yn1:
 
 
 
 
 
mov ax,[bx] ;récup de valeur de x
 
imul ax,[bp] ; multiplication val de x avec val de a
 
 
 
add cx,ax ; addition des termes
 
inc bp
 
inc bp  ; incrémentation de 2 fois sur la pile
 
inc bx
 
 
 
;div cx,16
 
shr 4
 
mov si,cx
 
push si
 
;mov bp,0
 
;dec bx,3   ; recup de xn-3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;*************** mise en pile, lecture sans destruction, destruction
 
;à faire
 
;call remplit
 
;suite1: call lecture
 
;suite2: call destruction
 
;suite3:
 
 
 
lea ax,terminaison
 
call affich
 
 
 
;********************************************************
 
;*	fonction de fin de programme			*
 
;********************************************************
 
fin:		mov	ax,4c00h
 
		int	21h
 
;********************************************************
 
 
 
;********************************************************
 
;*	fonction d'affichage				*
 
;*	parametre d'entrée dans ax: adresse du texte 	*
 
;*	à afficher					*
 
;********************************************************
 
affich:			
 
		mov	dx,ax
 
		mov	ah,9
 
		int	21h
 
		ret
 
 
 
		end 	DEBUT

**jojo_ol76** · 05/03/2008, 15h37

voilà ce que j'ai modifié mais j'obtiens aucun résultat:

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
 
;********************************************************
;*	programme permettant 		 		*
;*						*
;*	tasm /la /zi i	.asm				*
;*	tlink /v 	.obj				*
;*	td		.exe				*
;*	code et erreur dans 	.lst			*
;*							*
;********************************************************
;*	REMARQUE:					*
;********************************************************
;*					*
;********************************************************
 
	     name programme 
		.MODEL SMALL	; tout dans le même segment
		.386
;*************** segment de pile
		.STACK 100h
;*************** segment de données
		.DATA
 
commencement	db	"debut",13,10,"$"
terminaison 	db    	"fin",13,10,"$"
 
tabx		db	1 dup (0,1,2,3,4,5,6,7,8,9,10,9,8,7,6,5,4,3,2,1, \
			0,1,2,3,4,5,6,7,8,9,10,9,8,7,6,5,4,3,2,1)
 
taby		db	40 dup (?)
 
taba		dw	1,4,6,4,1
 
;*************** segment de données
		.CODE
 
DEBUT:		mov 	ax,@data
		mov 	ds,ax		
 
		lea ax,commencement
		call affich
PILE:
		mov bx,taba[0]   ;bp
		push bx
		mov bx,taba[1] ;bp+2
		push bx
		mov bx,taba[2] ;bp+4
		push bx
		mov bx,taba[3] ;bp+6
		push bx
		mov bx,taba[4] ;bp+8
		push bx
		mov bx,size tabx  ;bp+10
		push bx 
 
		mov bx,offset tabx ;bp+12
		push bx
		mov ax,offset taby ;bp+14
		push ax
		call calcul
 
calcul:
		mov cx,5
		mov si,0
 
repet5:
		mov ax,[bx] ;récup de valeur de x
		imul ax,[bp] ; multiplication val de x avec val de a
		add si,ax ; addition des termes
		inc bp
		inc bp  ; incrémentation de 2 fois sur la pile
		inc bx
		loop repet5
 
		div cx,16
		shr si,[4]
		mov ds,si
		push si
		sub bp,8
		dec bx
		dec bx
		dec bx
		dec bx       ; recup de x1
		inc di
		cmp di,36
		jne calcul
		inc bx
		mov si,0
		mov cx,4
 
yn4:
		mov ax,[bx] ;récup de valeur de x
		imul ax,[bp] ; multiplication val de x avec val de a
		add si,ax ; addition des termes
		inc bp
		inc bp  ; incrémentation de 2 fois sur la pile
		inc bx
		loop yn4
 
		;div cx,16
		shr si,[4]
		mov ds,si
		push si
		sub bp,8
		dec bx
		dec bx
		dec bx   ; recup de xn-3
		mov cx,3
		mov si,0
 
yn3:
		mov ax,[bx] ;récup de valeur de x
		imul ax,[bp] ; multiplication val de x avec val de a
		add si,ax ; addition des termes
		inc bp
		inc bp  ; incrémentation de 2 fois sur la pile
		inc bx
		loop yn3
 
		;div cx,16
		shr si,[4]
		mov ds,si
		push si
		sub bp,8
		dec bx
		dec bx   ; recup de xn-2
		mov cx,2
		mov si,0
 
yn2:
		mov ax,[bx] ;récup de valeur de x
		imul ax,[bp] ; multiplication val de x avec val de a
		add si,ax ; addition des termes
		inc bp
		inc bp  ; incrémentation de 2 fois sur la pile
		inc bx
		loop yn2
 
		;div cx,16
		shr si,[4]
		mov ds,si
		push si
		sub bp,8
		dec bx   ; recup de xn-1
 
yn1:
		mov ax,[bx] ;récup de valeur de x
		imul ax,[bp] ; multiplication val de x avec val de a
		add si,ax ; addition des termes
		inc bp
		inc bp  ; incrémentation de 2 fois sur la pile
		inc bx
 
		;div cx,16
		shr si,[4]
		mov ds,si
		push si
		;mov bp,0
		;dec bx,3   ; recup de xn-3
		;call lecture
		;lecture:
		;mov bp,sp  ;le dernier paramètre est adressé par SS:[BP + 2]
		;ret 80      ; nb de parametres *2
 
;*************** mise en pile, lecture sans destruction, destruction
;à faire
		;call remplit
;suite1: call lecture
;suite2: call destruction
;suite3:
 
		lea ax,terminaison
		call affich
 
;********************************************************
;*	fonction de fin de programme			*
;********************************************************
 
fin:		mov	ax,4c00h
		int	21h
 
;********************************************************
;********************************************************
;*	fonction d'affichage				*
;*	parametre d'entrée dans ax: adresse du texte 	*
;*	à afficher					*
;********************************************************
 
affich:			
		mov	dx,ax
		mov	ah,9
		int	21h
		ret
 
		end 	DEBUT