Assembler Tutorial

[Empire]

Tach alle zu sammen,
Ich hab mir vor ein paar Monaten in den Kopf gesetzt Assembler zu lernen.
Ich hab stundenlang Google bemüht und einige Tutorials hab ich gefunden.
Die Theorie der ganzen Register und die Geschichte und was Assembler ist,
kann ich inzwischen auswendig, da das bei eigendlich allen recht gut und
ausführlich war.
Sobald es aber ums Programmieren selber ging konnte ich mit keinem wirklich
etwas anfangen. Ich kenn jetzt ein halbes duzend Befehle und was sie bewirken,
aber der Zusammenhang (mir fällt keine bessere Beschreibung ein) erschließt
sich mir nicht.
Kennt jemand ein Gutes Tutorial für Assembler?
Aber bitte ein deutsches. Mein Englisch ist gut genug um sich mit jemanden
zu verständigen aber um sowas zu lernen reicht es nicht.

Hoffe ihr könnt mir helfen, und danke schon mal

Empire

[Xin]

Kennt jemand ein Gutes Tutorial für Assembler?

Ich kenne keins. In meiner Linksammlung kommt folgendes vor:

http://www.assembler.my100megs.com/inhalt.htm
http://www.deinmeister.de/wasmtut.htm

Und das war's auch schon.

Ich habe so ziemlich alles an aktuellen Büchern, was es zum Thema Assembler gibt, da ich seit 10 Jahren nichts mehr in Assembler gemacht habe und mich aber mit Maschinencode auseinandersetzen darf. Ich kann also derzeit bestenfalls grundlegende Fragen beantworten.

Ich werde Dich nicht aufhalten, wenn Du diese Seite mit Inhalten füllen möchtet. ^^

[Empire]

Sorry damit kann ich nichts anfangen.
(Bin vermutlich zu blöd.) Sobald ich es kann,
werde ich die Seite mit vergnügen füllen.
Hat sonst noch jemand was?

Empire

[Xin]

Sorry damit kann ich nichts anfangen.
(Bin vermutlich zu blöd.) Sobald ich es kann,
werde ich die Seite mit vergnügen füllen.
Hat sonst noch jemand was?

Nicht so früh aufgeben. Zu blöd sind wir alle, bis wir solange rumexperimentiert haben, um es ans Laufen zu bekommen.

Ansonsten schau Dich bei den Billigbuchversendern um und hol Dir entsprechende Literatur für kleines Geld.

[Empire]

Alle Programmier Bücher die ich bisher gefunden habe kostet ca. 30€.
Das ist mir im moment zu viel.
Wenn du eine Idee hast wo ich sie billiger bekomme,
würde ich mich dort mal umsehen.

Empire

[Xin]

http://www.terrashop.de/Buch/Assembler- ... /77237798/
http://www.terrashop.de/E-Book/Assemble ... 82661756P/

Ansonsten schau Dich unter den gebrauchten Büchern z.B. bei EBay/Amazon um.

Ich muss die Konzepte von Assembler nicht mehr lernen, da ich bereits zwei Jahre Assembler programmiert habe. Für mich sind die Addison Wesley Bücher bisher am informativsten.

[cloidnerux]

Ich habe mal auf anhieb diese Tutorial gefunden:
http://andremueller.gmxhome.de/
Es Beschreibt den Prozessoraufbau und dann die Programmierung von Assembler unter windows.
Das solltest du dir dann auch nochmal ansehen:
http://assembler.hpfsc.de/

[Sunji]

Dann graben wir den Thread mal wieder aus ....

Assembler Tutorial (dt.) :
http://andremueller.gmxhome.de/toc.html

Assembler Crashkurs (dt.) :
http://www-ivs.cs.uni-magdeburg.de/bs/l ... bler.shtml

Ich habe mich für folgende Programmierumgebung entschieden : Nasm, ddd und Scite.
Alle Programme sind bei den gängigen Ubuntu Derivaten enthalten.

Code: Alles auswählen

sudo apt get-install nasm ddd scite

Scite hat ein kleines Problem bei der Darstellung von Assembler Code. Die Schriftart ist auf 8 eingestellt. Dies kann schnell geändert werden um es wieder "lesbar" zu machen.

Code: Alles auswählen

sudo nano /usr/share/scite/asm.properties

Innerhalb der Konfigurationsdatei die folgende Zeile suchen und die Schriftgröße auf 12 setzen.

Code: Alles auswählen

# Assembler Styles
style.asm.32=fore:#808080,font:Verdana,size:12

Der Debug Code von NASM wird nicht direkt von gdb bzw. dem Frontend DDD verstanden. Deshalb müssen wir bei der Kompilierung folgendermaßen vorgehen :

Nehmen wir ein "sinnloses" Programm : exit.asm

Code: Alles auswählen

section .data

section .text
        global _start
_start:
        mov eax,1       ; Systemcall for Exit
        mov ebx,0       ; Exit Code (NULL)
        int 80h         ; Call the kernel

Dieses Programm beendet sich ordentlich - mehr nicht. Das ist aber im Moment ausreichend.

Um dieses Programm zu kompilieren geben wir folgenden Zeilen in die Konsole ein :

Code: Alles auswählen

nasm -f elf -F dwarf exit.asm
ld -o exit exit.o

Wenn alles ordnungsgemäß funktioniert hat - sprich keine Ausgabe während der beiden Kommandos erfolgt ist, haben wir die ausführbare Datei 'exit' in unserem Ordner.
Das Programm einfach mal aufrufen und sich den Statuscode der Rückgabe mit

Code: Alles auswählen

echo $?

anzeigen lassen. In unserem Fall sollte eine 0 (Null) als Antwort kommen.

Nun wollen wir DDD benutzen, den Debugger. Dazu auf der Konsole folgendes eingeben :

Code: Alles auswählen

ddd ./exit

Der Debugger öffnet sich und wir haben den Quellcode von oben direkt in der Anzeige. Nun kann der Debugger wie üblich mit Breakpoints usw. bedient werden.
Setzen wir einen Breakpoint in Zeile 8 - int 80h und starten das Programm. In der Menuleiste Status -> Register aufrufen. Hier können wir die aktuellen Register samt den gespeicherten Werten zum Zeitpunkt der Ausführung sehen.

Weitere Infos zu ddd http://www.gnu.org/s/ddd/

Ich denke mal im groben sollte nun dem Programmieren in Assembler nichts mehr im Wege stehen.

Wo soll ich den nun anfangen oder besser gefragt, was kann ich nun Programmieren?
Die ersten Schritte könnten sys_calls sein. Eine nette Tabelle gibt es unter http://bluemaster.iu.hio.no/edu/dark/li ... calls.html.

Viel Spaß ...
Sunji

[Sunji]

Ich hatte erst vor hier ein eigenes Wiki zu eröffnen, aber mir fehlt die Zeit um mich nun auch noch in dokuWiki einzuarbeiten und vieles in Assembler kann von dem C Tutorial abgeleitet werden (Stack, Variablen etc.). Sprich es wäre viel doppelte Arbeit.

Dennoch möchte ich an dieser Stelle ein paar Code Schnipsel übergeben, welche ich gestern für das Wiki Angefertigt habe. Der Quellcode ist gut dokumentiert und es sollte dem interessierten Leser gleich klar sein, worum es geht :

Ausgehend vom obigen Post, setzte ich die Programme : nasm, ddd und scite vorraus - sprich Linux Umgebung

Assembler Debuggen:
Die folgenden 3 Listings dienen dazu dem Interessierten mehr über Debugging und was da eigentlich während des Programmablaufs passiert zu veranschaulichen : [Register]
(Formatierung des Quellcodes ist leider verschoben, da die Tabulatoren nicht richtig interpretiert werden)

So sieht der Debugger mit folgendem Listing aus : http://s1.directupload.net/file/d/2700/4wwh8csa_png.htm

Datei: example_001a.asm

Code: Alles auswählen

; Projekt : Debuggen
;
; Beschreibung : Kleines Tool zum Testen von Debug Informationen
;		 Es werden ein paar Dezimalwerte in die Register
;		 geschrieben.

; Register : eax, ebx, ecx, edx 	 (32 bit)

; Uebersetzen :
; nasm -f elf -F dwarf example_001a.asm
; ld -o example_001a example_001a.o

; Debuggen :
; ddd ./example_001a

section .data

section .text
	global _start
_start:
	mov eax, 255	; 255 Dez. nach eax schreiben
	mov ebx, 127	; 127 Dez. nach ebx schreiben
	mov ecx, 3	; 3   Dez. nach ecx schreiben
	add ebx, ecx	; Addiere: ebx = ebx + ecx
	mov edx, eax	; Kopiere den Wert von eax nach edx
	sub edx, ecx	; Subtrahiere: edx = edx - ecx;


	; Programmende: return (0) 
	mov eax,1	; Systemcall fuer Exit
	mov ebx,0	; Exit Code (NULL)
	int 80h		; Kernel zum Ausfuehren aufrufen

Listing 2 veranschaulicht die Benutzung des Stacks an einem sehr einfachen Beispiels.

Datei: example_001b.asm

Code: Alles auswählen

; Projekt : Debuggen
;
; Beschreibung : Kleines Tool zum Testen von Debug Informationen
;		 Es wird ein Dezimalwert auf den Stack gelegt und 
;		 wieder abgerufen.

; Register : eax, ebx, ecx		 (32 bit)
; Stack	   : esp			 (32 bit)

; Uebersetzen :
; nasm -f elf -F dwarf example_001b.asm
; ld -o example_001b example_001b.o

; Debuggen :
; ddd ./example_001b

section .data

section .text
	global _start
_start:
	mov eax, 100	; 100 Dez. nach eax schreiben
	mov ebx, 25	;  25 Dez. nach ebx schreiben
	push eax	; eax auf den Stack legen (100)
	sub eax, ebx	; Subtrahiere: eax = eax - ebx (75)
	mov ecx,eax	; Kopiere eax nach ecx
	pop eax		; Den letzen Stackwert abrufen und
			; nach eax schreiben (100)
	sub eax, ecx	; Subtrahiere: eax = eax - ecx (25)
	
			; Programmende: return (0) 
	mov eax,1	; Systemcall fuer Exit
	mov ebx,0	; Exit Code (NULL)
	int 80h		; Kernel zum Ausfuehren aufrufen

Im folgenden Listing wird gezeigt, wie man durch indirekte Adressierung an Informationen auf dem Stack gelangt, ohne sie vorher abzurufen (pop).

Datei: example_001c.asm

Code: Alles auswählen

; Projekt : Debuggen
;
; Beschreibung : Kleines Tool zum Testen von Debug Informationen
;		 Es wird mit Hilfe des Stacks die Direkte Adressierung
;		 erklaert.

; Register : eax, ebx, ecx		 (32 bit)
; Stack	   : esp			 (32 bit)

; Uebersetzen :
; nasm -f elf -F dwarf example_001c.asm
; ld -o example_001c example_001c.o

; Debuggen :
; ddd ./example_001c

section .data

section .text
	global _start
_start:
	mov eax, 100	; 100 Dez. nach eax schreiben
	mov ebx, 50	;  50 Dez. nach ebx schreiben
	push eax	; Den Wert von eax auf den Stack legen
	push ebx	; Den Wert von ebx auf den Stack legen
	mov ecx,200	; 200 Dez. nach ecx schreiben
	sub ecx,[esp]	; Subtrahiere: ecx = ecx - letzen Stackeintrag[50] (150)
	sub ecx,[4+esp] ; Subtrahiere: ecx = ecx - vorletzten Stackeintrag[100] (50)
			; Der Stack ist 4 Byte (32bit) breit. Wenn wir
			; also [4+esp] schreiben, zeigt der Zeiger auf
			; das vorletzte Element. In diesem Beispiel also
			; auf den Wert 100.
	
	add ecx, 25	; Addiere 25 zu ecx (75)
	mov [4+esp],ecx ; Schreibe ecx (75) in den vorletzten Stackeintrag
			; Damit ueberschreiben wir den Anfangswert von 100
			; Im Stack sind nun [esp] 50 und [4+esp] 75 gespeichert.

	mov eax, 0	; Der Übersicht halber löschen wir die 3 Register	
	mov ebx, 0	; um im Debugger das Ergebnis besser zu sehen.
	mov ecx, 0
	pop eax		; Hole letzten Stack Eintrag
	pop ebx		; Hole letzten Stack Eintrag ( da wir ebend mit pop eax
			; den letzten Eintrag geholt haben ist der vorletzte nun
			; der letzte)
			
			
			
			; Programmende: return (0) 
	mov eax,1	; Systemcall fuer Exit
	mov ebx,0	; Exit Code (NULL)
	int 80h		; Kernel zum Ausfuehren aufrufen

Das folgende Listing dient der Veranschaulichung von Macros innerhalb von Assembler. Macros können benutzt werden um den Quellcode lesbarer und besser Wartbar zu machen.
Hierbei sollte man beachten, das die Macros während des Kompilierungsprozesses inline übersetzt werden. Es sind also keine Funktionen. Wichtig bei der Benutzung von Registern die evtl. durch das Macro überschrieben werden können, obwohl es im Quellcode erstmal nicht den Anschein hat.

Datei: example_002a.asm

Code: Alles auswählen

; Projekt : Macros und I/O Operationen
;
; Beschreibung : Ein einfaches Beispiel wie Macros benutzt um die
;		 Lesbarkeit des Quellcodes zu erhalten.
;		 Ein einfaches 'Hello, World' Programm

; Uebersetzen :
; nasm -f elf -F dwarf example_002a.asm
; ld -o example_002a example_002a.o

; Debuggen :
; ddd ./example_002a

section .data

	MSG_STR		db	'Hallo Welt! ', 10	; Wir hängen dem String noch ein LF (dez. 10) an.
	MSG_SIZE 	equ $ - MSG_STR

section .bss

	%macro write 2		; Definiert ein Macro mit zwei Parametern [write (%1,%2)]
	  mov	eax, 4		; sys_write
	  mov   ebx, 1		; STDOUT
	  mov   ecx, %1		; const char *
	  mov   edx, %2		; size_t
	  int   80h		; Execute
	%endmacro

section .text

	global _start

_start:
	write MSG_STR, MSG_SIZE		; Rufe das Macro write auf (printf)
					; Schau dir den Code im Debugger an. Das
					; Macro wird hier eingefügt, da es sich NICHT
					; um eine Funktion handelt!
					
_exit:
			; Programmende: return (0) 
	mov eax,1	; Systemcall fuer Exit
	mov ebx,0	; Exit Code (NULL)
	int 80h		; Kernel zum Ausfuehren aufrufen

Und zu guter Letzt: Nun wird es interactiv ....

Datei: example_002b.asm

Code: Alles auswählen

; Projekt : Macros und I/O Operationen
;
; Beschreibung : Ein einfaches Beispiel wie Macros benutzt um die
;		 Lesbarkeit des Quellcodes zu erhalten.
;		 Das Programm fragt den Benutzer nach seinem Namen und
;		 gibt danach eine nette Begrüßung aus.

; Uebersetzen :
; nasm -f elf -F dwarf example_002b.asm
; ld -o example_002b example_002b.o

; Debuggen :
; ddd ./example_002b

section .data

	MSG_STR		db	'Wie lautet dein Name : '
	MSG_SIZE 	equ $ - MSG_STR

	GREET_STR	db	'Willkommen, '
	GREET_SIZE	equ $ - GREET_STR

section .bss
	buff	resb 25		; Reserviere 25 Byte Speicher

	%macro write 2		; Definiert ein Macro mit zwei Parametern [write (%1,%2)]
	  mov	eax, 4		; sys_write
	  mov   ebx, 1		; STDOUT
	  mov   ecx, %1		; const char *
	  mov   edx, %2		; size_t
	  int   80h		; Execute
	%endmacro

	%macro read 2		; Definiert ein Macro mit zwei Parametern [read (%1, %2)]
	  mov	eax, 3		; sys_read
	  mov	ebx, 0		; STDIN
	  mov	ecx, %1		; char *
	  mov	edx, %2		; size_t
	  int	80h
	%endmacro

section .text

	global _start

_start:
	write MSG_STR, MSG_SIZE		; Rufe das Macro write auf (printf)
	read  buff, 25			; Rufe das Macro read auf (cin)
	push  eax			; Die Länge der Eingabe wird von read in eax zurückgegeben			
					; die wir auf den Stack sichern

	write GREET_STR, GREET_SIZE	; Rufe das Macro write auf (printf)

	pop  edx			; Hole die Länge des Strings wieder vom Stack
					; und schreibe sie direkt in edx.
					; (Warum nicht wieder nach eax? - Schau Dir den Code
					;  im Debugger an ...)
	
	write buff, edx			; Rufe nun das Macro write auf (printf)

_exit:
			; Programmende: return (0) 
	mov eax,1	; Systemcall fuer Exit
	mov ebx,0	; Exit Code (NULL)
	int 80h		; Kernel zum Ausfuehren aufrufen

Beim Letzten Listing: Versucht mal mehr als 25 Zeichen einzugeben und schaut was passiert. Frag dich, Warum ist das so? Wie kann ich das Problem lösen ?

Alle Programme wurden getestet und sind lauffähig. Ich wünsche dem Interessierten viel Spaß bei seinen ersten Schritten in Assembler.

Gruß Sunji

[Xin]

Hier im Forum geht das unter und verschwindet dann in alten Threads. Um sowas auffindbar zu halten, haben wir ja das Wiki.

Ich habe das mal im Wiki verlinkt und werde das beizeiten dann in ein Assembler-Tutorial einarbeiten.
Du kannst also gerne hier weiter reinposten, ich lese das und probiere das durch und übertrage es dann das ins Wiki.
Aber ich werde zuerst das C-Tutorial fertig machen.