XProfan

Français

Kurs: Kleines Assembler ABC.

cela ici soll aucun komplette Anleitung son, um Assembler trop erlernen.
mais es sollte einem Profan-User gestatten, erste Assemblerprogämmchen trop erstellen.

Zunächst einmal: Pour Assembler nécessaire on aucun grosse Anzahl de Befehlen, avec 10 Befehlen (en tout gibt es sur 90) ist on déjà bien bedient, alles autre ist unnütz, weil qui MASM32 Assembler High-Level-Syntax (.tandis que / .endw / .si / .endif usw.) soutenu. et en ist einem Profan-User déjà cela meiste bekannt.

dans Assembler gibt es Register, ce sont Speicherbereiche, qui 4 Byte (Long-Int) grand sommes. quelques Register dürfen facultativement aussi seulement 1 ou bien 2 Bytes grand son.
cet Register appeler eax, ebx, ecx, edx, edi et esi. ensuite gibt es encore ebp, cela vous mais erstmal ausser huit laisser devrait.
et il y a encore esp, c'est aussi erstmal tabou pour vous. Zudem benutzt Assembler esp comme Stackpointer.

cet Register peut aussi comme Integer ou bien Byte vorkommen.
comme Integer appeler vous ensuite ax, bx, cx, dx, di et si.

comme Byte, là gibt es einmal cela HiByte et cela LoByte, dans diesem Format appeler vous ensuite ah et al, bh et bl, ch et cl et encore dh et dl. Edi et esi peut seulement comme Long-Int ou bien Integer benutzt volonté.

Es dürfen toujours seulement deux Register avec qui selben Byte-Taille zusammen benutzt volonté !!!

qui devoir eines Registers:
un Register peux une numéro zwischenspeichern et qui Assembler rechnet chez einigen Befehlen avec den Werten einiger Register aktualisiert cet selbstständig. qui Register sommes alors zum Sauver et zum le calcul là.
Variablen gibt es naturellement aussi.

ici un paire Beipspiele:
Kompilieren Marque Séparation

Werte     dd 0,0,4,6,874,414425  ;6 Long-Ints
Zahlen    dw 45,263,4663         ;6 Integer
dw 364,67,3
Nochmehr  db 4,5,1,90,34         ;5 Bytes
Text      db Hallo,0           ;Und ein 6 bytes langer String (immer mit Nullbyte !!!)/pre>

venons wir zum ersten et wichtigsten Befehl: mov.
Mov steht pour Move et est verschiebe. il peut avec cela payons dans un Register Déplacer ou bien une Registerwert dans un d'autre Register kopieren. qui linke Wert ist cela but, qui rechte Wert ist qui source.
Kompilieren Marque Séparation

mov eax,4673052  ;die LongInt-Zahl 4673052 ins Register eax schreiben
mov ebx,eax      ;den Wert aus eax nach ebx schreiben, in ebx steht jetzt auch 4673052
mov ax,20457     ;die Integer-Zahl 20457 nach ax
mov ah,238       ;und das Byte 238 nach ah
mov eax,variable ;variablenwert nach eax
mov variable,eax ;und umgekehrt

Ajouter addiert deux Werte miteinander et écrit den neuen Wert dans cela linke Register:
Kompilieren Marque Séparation

mov eax,10       ;10 pour eax
add eax,20       ;20 addieren. qui Wert dans eax ist maintenant 30
mov ecx,5        ;5 pour ecx
add eax,ecx      ;ecx pour eax addieren. dans eax steht maintenant qui Wert 35

Sous subtrahiert deux Werte et écrit den neuen Wert dans cela linke Register:
Kompilieren Marque Séparation

mov eax,100      ;100 pour eax
sub eax,30       ;30 subtrahieren. eax maintenant 70
mov edx,10       ;10 pour edx
sub eax,edx      ;10 subtrahieren. eax ist maintenant 60

Mul multipliziert deux Werte et écrit den neuen Wert pour eax. chez einer Multiplikation dürfen seulement eax et edx verwendet volonté.
veux on vorzeichenbehaftete payons multiplizieren, ensuite doit anstatt dem mul cela imul verwendet volonté. mul ist dans qui Ausführung mais plus rapide..
Kompilieren Marque Séparation

mov eax,7        ;7 pour eax
mov edx,5        ;5 pour edx
mul edx          ;dans eax steht maintenant 35, dans edx steht 0

Div dividiert deux payons. à qui Division sommes trois Register daran beteiligt, eax, edx et un Register ihrer l'élection. edx doit zéro son !
Kompilieren Marque Séparation

mov eax,100      ;100 pour eax
mov edx,0        ;edx toujours effacer !
mov ebx,3        ;3 pour ebx
div ebx          ;eax geteilt par ebx. Ergebnis (ganze numéro) pour eax,
;qui Restwert allez pour edx

So maintenant peut wir Schonmal le calcul.

quelquefois désirer wir uns mais encore plus Register. qui gibts mais pas. mais nous pouvons den Stack comme Registerablage mißbrauchen.

avec push poser wir une variable ou bien un Register sur dem Stack ab.
Kompilieren Marque Séparation

push eax         ;eax sur den Stack poser
push ebx         ;ebx sur den Stack

avec pop peut wir la valeur wieder de Stack runternehmen. cela doit mais dans umgekehrter Reihenfolge passer.
Kompilieren Marque Séparation

push eax
push ebx
push ecx
pop ecx
pop ebx
pop eax

Stellt euch den Stack comme un Stapel avec Briefen avant. si je trois Briefe daraufpacke, ensuite doit je qui beiden obersten wieder débarrasser, um à den ersten qui trois Briefe trop gelangen.

Jmp gleicht Profans Goto et wird pour Schleifen et Sprünge benutzt.
Kompilieren Marque Séparation

jmp hierhin
mov eax,0
mov ebx,0
hierhin:
mov ebx,0

Lea ist ähnlich comment mov. seulement übergibt lea pas la valeur einer Variablen ou bien eines Registers, mais den aiguille sur qui Variable/Register.
Kompilieren Marque Séparation

jmp plus               ;Datenbereich überspringen
data dd 333,444,555,666  ;ici 4 Longints
plus:
mov eax,data             ;dans eax steht maintenant 333. qui erste Wert aus data wird übergeben
lea edx,data             ;dans edx steht maintenant qui aiguille sur data
mov eax,[edx+0]          ;333 pour eax. cela +0 pourrait ici weggelassen volonté
mov ebx,[edx+4]          ;444 pour ebx
mov ecx,[edx+8]          ;555 pour ecx
mov esi,[edx+12]         ;666 pour esi
mov eax,222              ;222 pour eax
mov [edx+4],eax          ;222 pour données+4. qui 444 wird alors par 222 ausgetauscht.

Ups, qui eckigen Klammern bedeuten, cela pas qui Registerinhalt transfert wird, mais qui le contenu, sur den cela Register zeigt.

Invoke ist eigentlich ne...aucune richtiger Befehl, mais aussi déjà High-Level-Syntax. invoke startet une API ou bien une Dll-Funktion. Übergeben volonté alle nötigen paramètre.
Kompilieren Marque Séparation

invoke GetCurrentDirectory,255,addr speicherbereich

si qui API une Rückgabewert übergibt, steht il pour dem Aufruf im Register eax.
addr speicherbereich übergibt den aiguille sur une Variablenspeicher, ist mais seulement chez invoke gestattet.
Ebensogut hätte on écrivons peut:
Kompilieren Marque Séparation

lea edx,speicherbereich
invoke GetCurrentDirectory,255,edx

So, cela wären qui versprochenen 10 Befehle

mais comment peut wir maintenant Register et Variablen comparer et Bedingungen et Verzweigungen programmieren ?
entier simple, den reste peut wir avec High-Level-Syntax faire. Ähnlich comment dans Profan...

.tandis que et .endw ist cela Assemblergegenstück trop Profans Tandis que et Endwhile.
Kompilieren Marque Séparation

mov eax,0

.tandis que eax == 1

    mov eax,[edx]
    add edx,4

.endw

.pause et .continue gibt es aussi, genauso comment dans Profan.

Pour Bedingungen et Verzweigungen gibt es .si, .elsif, .d'autre et .endif.
et cela funktioniert so comment dans Profan
Kompilieren Marque Séparation

.si eax==0

    mov ebx,1

.elseif ecx==0

    mov edx,1

.d'autre

    mov ebx,2
    mov edx,2

.endif

cela == ist incidemment cela Gleichzeichen.Weitere Vergleichsoperatoren sommes:
Kompilieren Marque Séparation

== juste
!= Ungleich
>  Größer comme
>= Größer juste
<  Kleiner comme
<= Kleiner juste
!  Logisches NOT
&& Logisches AND
|| Logisches OU

devoir plusieurs Bedingungen abgefragt volonté, ensuite sommes chaque Bedingungen dans Klammen trop mettons, z.B. .si (eax==0) && (ebx>=0).

un Synonym pour Profans whileloop gibt es également.cela allez mittels einer .repeat / .until Boucle:
Kompilieren Marque Séparation

.repeat

    ;irgendein Sourcecode

.until ebx<1   ;Boucle wird pas sortir de, solange ebx kleiner ist comme 1.

une .repeat / .until Boucle peux également mittels .pause sortir de, et mittels .continue récente gestartet volonté.

So, ici endet unser Assembler Crashkurs.
je hab wirklich alles Unnötige weggelassen. et somit dem User qui Possibilité gegeben, de Grund sur anzufangen.
il y a encore viele viele Befehle plus, mais qui meisten sommes wirklich par konfortablen High-Level Befehle ersetzt worden.
un gute Auflistung aller Befehle gibt es ici: [...]

(aussi im Anhang zum Runterladen)

j'ai ici aussi puis verzichtet, irgendwelche Optimierungen vorzunehmen (xor eax,eax anstatt mov eax,0), seulement weil es un paire Taktzyklen plus rapide ist. Assembler ist wirklich so sauschnell et qui neuen Prozessoren travailler si bien, cela solche Optimierungen à peine encore quoi hermachen.

Es lohnt sich , cela komplette MASM32 paquet (Freeware) runterzuladen.

Moderation:

qui einfachste Possibilité Inline-Assembler dans seinen Programmen trop verwenden, ist dans nativen Funktionen: [...]

Beispiel:
Kompilieren Marque Séparation

 {$cleq}
cls

tandis que 1

    locate 1,1
    imprimer myTest(100)

Wend

waitinput
end

nproc myTest

    Paramètres a&
    mov eax,a&
    add eax,50
    return eax

endproc