Discussion :

[zekicker]

Bonjour,

Débutant en ASM x86, je n'arrive pas à initialiser un tableau de 0 à 255. J'ai beau lire de la doc et faire les exemples mais avec un debugger j'ai un beau access violation. Pour tester je n'ai pas fait de boucle, je cherche juste à modifier la première valeur du tableau.Si quelqu'un peut me donner un coup de main. Merci

NB: J'utilise nasm avec visual studio comme debugger sur un windows 64bits
Voici mon bout de code:

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
global _init_table
 
%define ARRAY_SIZE 256
 
SECTION DATA USE32 CLASS=DATA:
array: times ARRAY_SIZE dw 0 ; reserved an array of 256 bytes
 
SECTION CODE USE32 CLASS=CODE:
 
_init_table:
	push ebp		; add ebp on the stack
	mov ebp, esp	; move esp in ebp
	sub esp, 4		; reserved a DWORD for j
	push ebx		; ebx must not be changed
 
        ; Inutile pour le moment
	mov dword[ebp - _init_table_PRM_j], 0 	; initialize j to '0'
 
	db 0xcc	; TO REMOVE WARNING
 
        ; Initialisation de la boucle
	mov eax, 10
	mov ebx, array ; Charge l'adresse de array dans ebx
	mov [ebx], word 10
 
	; Sortie de fonction
	pop ebx;
	mov esp, ebp	; move ebp in esp
	pop ebp			; pop ebp
	ret

[zekicker]

Je me suis rendu compte que ce type de déclaration correspondait à un extern en C.

J'ai modifié mon code et ça a l'air de marcher. Ça vous semble juste ?

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
global _init_table
 
%define ARRAY_SIZE 256
 
SECTION CODE USE32 CLASS=CODE:
 
_init_table_PRM_array	equ 512		; words array 2 bytes*256
 
_init_table:
	push ebp		; add ebp on the stack
	mov ebp, esp	; move esp in ebp
	sub esp, _init_table_PRM_array
 
	db 0xcc	; TO REMOVE WARNING
 
	lea ebx, [ebp - _init_table_PRM_array]	; ebp points to ebx
 
	; initialize the array from '0' to '255'
	mov cx, 0		; initialize i to '0'
	mov esi, 0		; data offset
 
.for_loop:
	cmp cx, ARRAY_SIZE
	jge .end_for
	mov [ebx+esi], cx
	inc cx
	add esi, byte 2
	jmp short .for_loop
 
.end_for:	
 
	mov esp, ebp	; move ebp in esp
	pop ebp			; pop ebp
	ret

[orfix]

Pourquoi n'utilises-tu pas l'instruction LOOP cela allégerait ton code :

Code :

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

1
2
3
4
5
.for_loop:
mov  [ebx+esi], cx
add  esi, byte 2
loop .for_loop,cx

EDIT : oups, ton tableau sera rempli de 256 à 1, mais cela peut se régler

[Forthman]

Je réponds à sa place

Car avec loop, cx est décrémenté.
Il faudrait donc initialiser cx avec la longueur de la chaine.
Et du coup, les valeurs stockées dans son tableau seraient décroissantes

a+ François

[orfix]

Je réponds à sa place

Car avec loop, cx est décrémenté.
Il faudrait donc initialiser cx avec la longueur de la chaine.
Et du coup, les valeurs stockées dans son tableau seraient décroissantes

a+ François

as-tu lu ceci :

EDIT : oups, ton tableau sera rempli de 256 à 1, mais cela peut se régler

[Rémi Coquet]

Plusieurs choses:

Ton cadre de pile est correct mais cela ne suffit pas:

ebx esi edi sont des registres protégés par convention. Toute routine, procédure… se doit de les retourner dans l'état initial lors de leur entrée.

(Désolé pour la syntaxe, je n'utilise pas le même outil que toi).

Code :

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

1
2
3
4
5
6
7
8
Push ebx,
       esi,
       edi
 
	...
Pop edi,
        esi,
        ebx

Une habitude qui peut t'aider dans pas mal de cas, c'est de mettre à 0 ses trois registres au point d'entrée de ton PE. Tu n'auras plus qu'à vérifier(au debugg) qu'aux retours aux appelants principaux ils sont toujours égaux à 0.

Tu pourrais initialiser ta table avec des bytes, des word ou des dword et dans ce cas utiliser les instructions de chaînes qui utilisent eax et edi: stos + taille serait une solution plus élégante:

Edi = Lp -> Table à initialiser (ou plus simplement ton adresse dans la pile, dans ce cas tu peux aussi utiliser le fait que les offsets de ta pile sont négatifs…)

Eax te sert de compteur (évite ecx loop qui est plus lent que sub ecx taille | jns L1<)

mov eax 0, edi LpTableTaille_0_255
; stosb byte / stosw word / stosd dword
L1: stosb | add al 1 | jnz L1<

Tu n'as qu'à protéger edi seulement

Le fait d'incrémenter eax dans son LSB permet de revenir à 0 après 255
Les flags étant actualisés par add, si al = 0 c'est que tu as terminé le travail

[Forthman]

as-tu lu ceci :

Bien non il l'a posté après ma réponse

a+ François