Discussion :

[Bargaroth]

Bonjour, je me mets depuis peu de temps à l'assembleur et je suis tombé sur un très bon tutoriel sur l'écriture d'un secteur de boot (ici)

Je pensais avoir pas trop mal pigé le truc jusqu'à ce que j'essaye de modifier le code.
En fait, je m'apprête à passer en mode protégé et voila ce que je fais :

Code :

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

1
2
3
4
5
6
7
8
9
        mov bx, gdtend
	mov ax, gdt
	sub bx, ax
	mov word [gdtptr], bx
 
	mov word [gdtptr+2], ds
	mov word [gdtptr+4], gdt
 
	lgdt [gdtptr]

Il se trouve qu'à l'execution, ça ne fonctionne pas alors que ce code fonctionne :

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
        mov ax, gdt
	mov bx, gdtend
	sub bx, ax
	mov word [gdtptr], bx;
 
	xor eax, eax
	mov ax, ds
	shl eax, 4
	xor ebx, ebx
	mov ebx, gdt
	add eax, ebx
	mov dword [gdtptr+2], eaxx
 
 
	lgdt [gdtptr]mov ax, gdt
	mov bx, gdtend
	sub bx, ax
	mov word [gdtptr], bx;on met la limite (16 bits)
 
	;on doit maintenant linéariser l'adresse de la gdt
	xor eax, eax
	mov ax, ds
	shl eax, 4
	xor ebx, ebx
	mov ebx, gdt
	add eax, ebx
	mov dword [gdtptr+2], eax
 
	;On va effectuer le passage
	cli
 
	lgdt [gdtptr]

Intuitivement, je pensais qu'entre faire l'addition dans les registres de XXXX0000 + YYYY et placer un dword a une adresse revenait au même que mettre xxxx à une adresse [add] et YYYY a [add+2] ?

Si quelqu'un a la gentilesse de me mettre sur la voie ?

Merci d'avance

[Neitsa]

Bonjour,

il faut tenir compte de l'endianness des processeurs x86 qui est en little endian.

Exemple:

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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
.data
szEqual BYTE "equal",0
szNotEqual BYTE "*not* equal",0
 
.data?
mem1 DWORD ?
mem2 DWORD ?
 
.code
start:
	; set mem1
	mov eax, 0DEAD0000h
	mov ebx, 0BEEFh
	add eax, ebx
	mov mem1, eax
 
	;set mem2
	mov eax, 0DEADh
	mov word ptr [mem2], ax
	mov ebx, 0BEEFh
	mov word ptr [mem2+2], bx
 
	; compare
	lea esi, mem1
	mov eax, [mem2]
	cmp [esi], eax
	jnz @@NotEqual
		invoke MessageBox, NULL, addr szEqual, NULL, MB_OK
		jmp @@end	
	@@NotEqual:
		invoke MessageBox, NULL, addr szNotEqual, NULL, MB_OK
	@@end:
	ret
end start

Dans l'exemple ci-dessus, intuitivement, on pense comparer 2 valeurs égales, mais ça n'est pas le cas.

Dans l'exemple, on compare (cf. "cmp"):
- mem1 ([esi]) : 0xDEADBEEF
- mem2 (eax) : 0xBEEFDEAD

Dump mémoire de mem1:

Code :

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

1
2
3
4
 
CPU Dump
Address    Hex dump
00403030  EF BE AD DE

Dump mémoire de mem2:

Code :

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

1
2
3
4
 
CPU Dump
Address     Hex dump
00403034   AD DE EF BE

Pour que ce soit correct, il faut soit inverser les deux registres sources pour mem2:

Code :

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

1
2
3
4
5
6
 
	;set mem2
	mov eax, 0DEADh
	mov ebx, 0BEEFh
	mov word ptr [mem2], bx ; (et pas 'ax')
	mov word ptr [mem2+2], ax ;(et pas 'bx')

Soit inverser les offsets:

Code :

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

1
2
3
4
5
6
 
	;set mem2
	mov eax, 0DEADh
	mov word ptr [mem2+2], ax ; (et pas +0)
	mov ebx, 0BEEFh
	mov word ptr [mem2], bx ; (et pas +2)

Dans les deux cas ci-dessus, la comparaison du contenu de mem1 et mem2 est égale.