Ist es möglich, etwas in einer Dereferenz in der Montage zu dereferenzieren?

Question

Betrachten Sie die folgende Prozedur, die ein DWord-Array mit Werten füllt und 2 Parameter eingibt: Bei EBP + 08h ist die Größe des Arrays und bei EBP + 0Ch der Versatz des angegebenen Arrays. (Das heißt OFFSET myarray):

MyProc PROC 
PUSH EBP 
MOV EBP, ESP 
SUB ESP, 04h 
PUSH EDI 
PUSH ESI 
PUSH EBX 
MOV EBX, [EBP + 08h] ;move the size of the array into EBX 
MOV [EBP - 04h], 00h ;EBP - 04h will be the counter (or the index.) 
MOV ESI, [EBP + 0Ch] ;move the offset of the array into ESI 
MOV EDI, 01h 
INC EBX 
@@: 


MOV [ESI + 04h * [EBP - 04h]], EDI ;How can I actually move EDI into 
;the dword found at address ESI + 4 * the value found at address EBP - 4? 


INC [EBP - 04h] ;increment the counter and the value to be stored. 
INC EDI 
CMP [EBP - 04h], EBX 
JNE @B 
POP EBX 
POP ESI 
POP EDI 
MOV ESP, EBP 
POP EBP 
RET 
MyProc ENDP 

Wo ich versuche EDI in [ESI + 04h * [EBP - 04h]] zu bewegen, ist ein Beispiel dafür, was ich zu tun versuchen, da die dword an der Adresse EBP - 4 der Index des Arrays ist.
Gibt es eine Möglichkeit, EDI tatsächlich in das DWord bei Adresse ESI + 4 * the dword at address EBP - 4 zu verschieben? Oder schaue ich das falsch an?

Answer 1

MOV [ESI + 04h * [EBP - 04h]], EDI ;How can I actually move EDI into 
     ;the dword found at address ESI + 4 * the value found at address EBP - 4? 
INC [EBP - 04h] ;increment the counter and the value to be stored. 

Der Wert bei [EBP-4] wird ein Inkrementieren Index in Ihrem dword Array halten. Ich sehe zwei Lösungen für dieses kleine Problem:

1. Sie halten eine lokale Variable und die problematische Anweisung in 2 Schritten schreiben:

   mov eax, [ebp-4] 
   mov [esi+eax*4], edi 
   inc [ebp-4] 
   

2. Sie die lokale Variable überhaupt nicht verwenden, und halten den Index in einem Register:

   mov [esi+eax*4], edi 
   inc eax 
   

---

ist ein Fehler zu berücksichtigen:

INC EBX 

Diese inc geben Ihnen 1 Iteration zu viele!

---

Vorausgesetzt, dass Sie das Array mit steigenden Werten füllen wollen, die genau um 1 größer ist als der Index des Elements (a [0] = 1, a [1] = 2, a [2] = 3 , ...) können Sie eine viel bessere Routine durch vorge Erhöhen des Index und Kompensation für diese Aktion durch Subtraktion 4 von der Adresse schreiben:

MyProc PROC 
PUSH EBP 
MOV EBP, ESP 
PUSH ESI 

xor eax, eax   ;EAX will be the counter (or the index.) 
mov esi, [ebp + 12] ;move the offset of the array into ESI 
@@: 
inc eax    ;increment the counter and the value to be stored. 
mov [esi + eax * 4 - 4], eax 
cmp eax, [ebp + 8] ;Compare index to size of the array 
jb @B 

POP ESI 
MOV ESP, EBP 
POP EBP 
RET 
MyProc ENDP 

weniger Register verwendet auch weniger Register bedeutet, zu erhalten!

Answer 2

Es erfordert zwei Anweisungen:

MOV EAX, [EBP - 04h] 
MOV [ESI + 4*EAX], EDI 

Sie werden auch Spar betrachten könnte/Wiederherstellung EAX in der Präambel und Epilog der Funktion. In den meisten Umgebungen muss EAX nicht beibehalten werden.

Answer 3

Sie machen dieses Verfahren übermäßig kompliziert. Alles, was Sie tun müssen, ist die folgende:

push ebp 
mov ebp, esp 

xor eax, eax   ; Fill buffer with nulls 
mov ecx, [ebp+8]  ; Number of dwords to fill 
push edi 
mov edi, [ebp+12] 
rep stosd 
pop edi 

leave 
ret 8     ; Pop arguments passed by caller 

meisten ABI betrachten EAX, ECX & EDX flüchtig, aber wenn man sie bewahren müssen, mit allen Mitteln.