[NASM] Initialisation d'un tableau

Version imprimable

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:

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

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:

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

25/02/2009, 23h42
orfix
Pourquoi n'utilises-tu pas l'instruction LOOP cela allégerait ton code :
Code:

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 :P
26/02/2009, 06h16
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 :roll:

a+ François
26/02/2009, 21h08
orfix

Citation:

Envoyé par 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 :roll:

a+ François

as-tu lu ceci :

Citation:

Envoyé par ssmario2

EDIT : oups, ton tableau sera rempli de 256 à 1, mais cela peut se régler
07/03/2009, 14h17
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:

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
08/03/2009, 18h41
Forthman

Citation:

Envoyé par ssmario2

as-tu lu ceci :

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

a+ François