Thema: Kleiner Assembler Thread

[ChristianF]

Moin Moin,
da ich für diese Frage keinen passenden existierenden Thread gefunden habe, der halbwegs aktuell ist, erstelle ich mal wieder einen neuen.  Deswegen werde ich auch weitere Fragen dann hier stellen
 
Und zwar beschäftige ich mich einfach mal so etwas mehr mit Assembler, was heißt, ich habe meinen GRUB Assembler-Part, damit der Kernel überhaupt geladen wird, übernommen und bin dabei einen kleinen Kernel in reinem Assembler zu schreiben.
 
Das erste Hindernis hat aber leider nicht lange auf sich warten lassen. 
So sieht das momentan aus (klein und noch übersichtlich):

Code: [Auswählen]

[SECTION .text]
global kernel_main
kernel_main:
push dword string ; parameter 1 der String
call video_write_string

ret

[SECTION .data]
string db "Hello World, From AsmOS",10,0
Wie man sieht, schiebe ich den String "string" als Parameter auf den Stack und rufe die Funktion auf. Hier versuche ich dann wie folgt den übergebenen String auszugeben:

Code: [Auswählen]

video_write_string:
push ebp
;push edi
mov ebp, esp

mov esi, [ebp+8]
mov edi, 0xB8000
.printloop:
lodsb

test al, al
jz .printdone

stosb

mov al, 0x0F
stosb

jmp .printloop
.printdone:

mov esp, ebp
;pop edi
pop ebp
ret

Allerdings funktioniert dies nicht richtig. Der Ablauf ist, dass der string und danach einige kryptische Zeichen ausgegeben werden und dann anscheinend ein triple fault ausgelöst wird, da bochs neugestartet wird. Was habe ich hier falsch gemacht? 
 
Gruß Christian

[Jidder]

Code: [Auswählen]

[SECTION .text]
global kernel_main
kernel_main:
push dword string ; parameter 1 der String
call video_write_string

ret


Das ist ret ist falsch. Wo soll das denn hinspringen? Außerdem holst du den Zeiger auf den string nicht vom Stack. Deswegem springt das ret zum String.

[ChristianF]

Durch das ret soll er wieder in die Funktion zurückspringen, von wo sie aufgerufen wurde.
kernel_main wird von dem GRUB Assembler-Part aufgerufen:

Code: [Auswählen]

extern kernel_main
kernel_startup:
push eax ; first Parameter - multiboot magic number
push ebx ; second Parameter - multiboot structure address
call kernel_main
;add esp, 8 ; remove previous pushed parameters
jmp $
Oder ist diese Art vorzugehen nicht sinnvoll? Sollte ich eventuell besser direkt dorthin (kernel_main) springen, oder einfach das ret weglassen?
 

Außerdem holst du den Zeiger auf den string nicht vom Stack. Deswegem springt das ret zum String...

Das war der Fehler, so was blödes. Was auf den Stack geschoben wird muss natürlich auch wieder runter...
 
Ich denke mal, dass man alle in der Funktion verwendeten Register erst sichern und am Schluss wiederherstellen sollte. Zumindest musste ich das in der Schule machen, als es um die Microcontoller-Programmierung ging.

[Jidder]

Oder ist diese Art vorzugehen nicht sinnvoll?

Doch das ist in Ordnung. Ich dachte das sollte vielleicht zu GRUB zurückspringen oder so. Oder dass du dir darüber überhaupt gar keine Gedanken gemacht hast. Aber so passt das schon.
 

Ich denke mal, dass man alle in der Funktion verwendeten Register erst sichern und am Schluss wiederherstellen sollte. Zumindest musste ich das in der Schule machen, als es um die Microcontoller-Programmierung ging.

Naja, ich denke mal in der Schule solltest du halt nach Schema F programmieren, damit du (oder dein Lehrer) nicht dauernd Fehler suchen musst, die wegen veränderter Register auftreten.

Aber ich finde Assemblerprogrammieren mit Aufrufkonventionen (dann noch die aus C -.-), Register sichern, Parameter auf dem Stack, etc langweilig ... da kannste gleich bei C bleiben. Da darfste dir auch ein paar Makros machen, und mit 8 globalen Variablen, die wie die Register benannt sind, arbeiten, wenn du willst, dass der Code aussieht wie Assembler. Ich glaube ich bau da mal ein Framework

[ChristianF]

Oder ist diese Art vorzugehen nicht sinnvoll?

Doch das ist in Ordnung. Ich dachte das sollte vielleicht zu GRUB zurückspringen oder so. Oder dass du dir darüber überhaupt gar keine Gedanken gemacht hast. Aber so passt das schon.
 

Ich denke mal, dass man alle in der Funktion verwendeten Register erst sichern und am Schluss wiederherstellen sollte. Zumindest musste ich das in der Schule machen, als es um die Microcontoller-Programmierung ging.

Naja, ich denke mal in der Schule solltest du halt nach Schema F programmieren, damit du (oder dein Lehrer) nicht dauernd Fehler suchen musst, die wegen veränderter Register auftreten.

Aber ich finde Assemblerprogrammieren mit Aufrufkonventionen (dann noch die aus C -.-), Register sichern, Parameter auf dem Stack, etc langweilig ... da kannste gleich bei C bleiben. Da darfste dir auch ein paar Makros machen, und mit 8 globalen Variablen, die wie die Register benannt sind, arbeiten, wenn du willst, dass der Code aussieht wie Assembler. Ich glaube ich bau da mal ein Framework

Ich bin ja noch am experimentieren. 
 
Wenn ich meine Funktion wie hier aufrufe mit "push word ..." muss ich ja am Ende esp immer um 4 (Rücksprungadresse) und die Anzahl der gepushten Parameter multipliziert mit 4 erhöhen, also hier dann das "add esp, 8". Oder habe ich da was falsch verstanden?

[Cjreek]

Hi,

Also wenn du im 32-Bit Modus bist und alle deine Parameter über den Stack übergibst, dann musst du am Ende deiner Funktion folgendes schreiben

Code: [Auswählen]

ret ParamCount*4 ; <-- 4 Byte(32 Bit) pro Parameter
also als Bsp:

Code: [Auswählen]

push 20
push 50
call addieren
jmp $

addieren:
     push ebp
     mov ebp, esp
     
     mov eax, [ebp+0x08]
     mov edx, [ebp+0x10] 

     add eax, edx

     pop ebp
     ret 8   ; = ret + add esp, 8
Lg
Cjreek

[ChristianF]

Gut zu wissen. 
 
Und wieder eine weitere Frage...
Muss ich in jeder Assembler-Datei die Sektionen angeben?
Quasi so:

Code: [Auswählen]

[SECTION .text]
global func
func:
    ; mach wass
    ret
[SECTION .data]
str db "Bla Fasel",0
Oder könnte man das auch weglassen?

[MNemo]

Wenn ich meine Funktion wie hier aufrufe mit "push dword ..." muss ich ja am Ende esp immer um 4 (Rücksprungadresse) und die Anzahl der gepushten Parameter multipliziert mit 4 erhöhen, also hier dann das "add esp, 8". Oder habe ich da was falsch verstanden?

Nein, die Rücksprungadresse wird schon vom ret vom Stack genommen.
Du musst dich nur um die Parameter kümmern die du vorher gepusht hast.

bei einem

Code: [Auswählen]

ret xmusst du aufpassen, denn nach der C-Aufrufkonventionen kümmert sich der Aufrufer um den Stack. Du kannst das also nicht verwenden, wenn du die Funktion von C aus aufrufen willst.

[Jidder]

Edit: zu langsam -.-

Dann beantworte ich halt die nächste Frage:

Und wieder eine weitere Frage...
Muss ich in jeder Assembler-Datei die Sektionen angeben?
Quasi so:

Code: [Auswählen]

[SECTION .text]
global func
func:
    ; mach wass
    ret
[SECTION .data]
str db "Bla Fasel",0
Oder könnte man das auch weglassen?

Nein, kannst du im Allgemeinen nicht weglassen. (Ausnahme wäre .text, weil das Standard ist.)

[ChristianF]

Gut gut.
Die sache mit den Aufruf-Konventionen muss ich mir mal genauer anschauen. Da ich allerdings nur in Assembler programmieren möchte, denke ich, dass ich das "ret x", also nicht die __cdecl-Konvention, nehmen kann.
Ich müsste allerdings erst nochmals schauen und genau abwägen, was ich letzten endes nutze.

[ChristianF]

So...
ich habe mal etwas weiter experimentiert und eine Funktion zustande gebracht, die den Bildschirm löscht. Diese funktioniert auch, da ich aber nicht so gut in Assembler bin, wollte ich einfach mal fragen, was überflüssig sein könnte, oder was ihr anders gemacht hättet.
 
Hier der Code:

Code: [Auswählen]

video_clear_screen:
push ebp
mov ebp, esp

; Register sichern
push edi
push ebx
push eax

; Adresse aus Variable holen (0xB8000)
mov edi, [video_address]
; Prüfwert berechnen
mov eax, 25
mov edx, 80
mul edx
mov FUNCTION_LOCALVAR_1, eax

mov ebx, 0
.loop_cls:
; Leerzeichen ausgeben, mit schwarzem
; hintergrund und weißer schrift
mov al, 0x20 ; blank
stosb
mov al, 0x0f ; Black background, white text
stosb

; Schleifen-Variable um 1 erhöhen
inc ebx
; Wurde das Ende erreicht?
cmp ebx, FUNCTION_LOCALVAR_1
; Nein? -> Wiederholen :D
jne .loop_cls

; Register wiederherstellen
pop eax
pop ebx
pop edi

mov esp, ebp
pop ebp
ret

 
Bei "FUNCTION_LOCALVAR_1" handelt es sich um ein Makro, das wie folgt aussieht: "%define FUNCTION_LOCALVAR_1 [ebp-4]".
Wenn ich nun eine solche Variable auf dem Stack benutze, muss ich die dann auch vorher reservieren und später wieder freigeben, oder kann ich das machen, wie es mir beliebt?

[Jidder]

Hi,

du musst für lokale Variablen auf dem Stack den Speicher reservieren, sonst werden diese beim nächsten Interrupt oder Funktionsaufruf überschrieben.

Bei dir ist an [ebp - 4] übrigens der gesicherte Wert von edi. Ich weiß nicht, ob du den überschreiben willst.

Ich hätte einfach sowas gemacht:

Code: [Auswählen]

; Leert den Bildschirm
; Diese Funktion verändert eax, ecx und edi. <-- sonstige Seiteneffekte
video_clear_screen:
    mov ecx, 80*25
    mov ax, 0x0f20
    mov edi, 0xb8000
    rep stosw
    ret
(ungetestet)

[ChristianF]

Der sollte natürlich nicht überschrieben werden...
 
Wenn ich deine Funktion richtig verstanden habe, ist rep zu vergleichen mit einer For-Schleife, die von 0 bis 80*25 hochzählt und jedes mal "stosw" ausführt.
Getestet wurde es eben von mir und es hat funktioniert... 

[MNemo]

Wenn ich deine Funktion richtig verstanden habe, ist rep zu vergleichen mit einer For-Schleife, die von 0 bis 80*25 hochzählt und jedes mal "stosw" ausführt.

Genauer gesagt zählt sie (r/e)cx bis 0 runter.

wenn du dennoch mal Locale variablen brauchst reservierst du dir den Speicher mit

Code: [Auswählen]

push ebp
mov ebp, esp
sup esp, <x-Bytes>oder mit dem Äquivalent dazu 'enter <x-Bytes>, 0', was aber aus mir unbekannten Gründen so eigentlich nie verwendet wird, anders als
'leave', dem Äquivalent zu 'mov esp, ebp; pop ebp'.


@PorkChicken: Wenn schon ohne Calling Convention, dann fehlt in deiner Funktionsbeschreibung:

Code: [Auswählen]

; setzt DF = 0 vorraus

PS: ChristianF, du setzt hoffentlich nicht wegen der "Geschwindigkeitsvorteile" auf asm.

[ChristianF]

Nein, ich möchte keine Geschwindigkeitsvorteile erzielen.
Ich möchte einfach nur etwas mehr Assembler programmieren, anstatt die ganze Zeit über C.
 
Wegen des "setzt DF = 0 vorraus", heißt das, ich muss vor jedem Aufruf der Funktion prüfen, ob df in FLAGS ungleich 0 ist und es dann auf 0 setzen? Das finde ich an und für sich nicht schön, es sei denn, das "Direction Flag" kann nur von Hand gesetzt werden...

[MNemo]

Wegen des "setzt DF = 0 vorraus", heißt das, ich muss vor jedem Aufruf der Funktion prüfen, ob df in FLAGS ungleich 0 ist und es dann auf 0 setzen? Das finde ich an und für sich nicht schön, es sei denn, das "Direction Flag" kann nur von Hand gesetzt werden...

Nein, nein… das Flag lässt sich nur von Hand ändern, entweder mit STD bzw. CLD oder über das FLAG-Register. Aber sobald du irgend wo ein STD verwendest wird dein Bildschirm plötzlich nicht mehr sauber.

Deshalb finde ich Konventionen, dir z.B. sagen das DF vor dem Start, und nach dem ende einer Funktion 0 sein muss, gar nicht schlecht.

[Jidder]

Normalerweise muss man auch nicht am Direction Flag rumfummeln. Auf vorwärts stellen und gut is ^^

[ChristianF]

Gut...
 
Wie das eben so ist, habe ich noch eine kleine Frage...
Folgendes Konstrukt funktioniert einwandfrei:

Code: [Auswählen]

push byte 0x25
call video_write_char

Nun durchlaufe ich allerdings in der Funktion zum Ausgeben eines Strings diesen und lade ihn mit lodsb nach al. Folglich habe ich mir folgendes gedacht:

Code: [Auswählen]

push byte al
call video_write_char
Allerdings funktioniert dies nicht, da mir der Fehler "error: invalid combination of opcode and operands" entgegengeworfen wird. Also habe ich ax und auch mal eax auf den Stack geschoben und dann die Funktion aufgerufen:

Code: [Auswählen]

push ax ; oder auch 'push eax'
call video_write_char
Allerdings wird so immer nur der letzte Buchstabe ausgegeben. Was mache ich da Falsch? Wenn in "al" ein Leerzeichen ist, wäre es das gleiche, wie folgender Aufruf:

Code: [Auswählen]

push byte 0x20
call video_write_char

Wieso funktioniert das nicht, bzw. nur teilweise, wenn ich ax oder eax auf den Stack schiebe?

[MNemo]

Mit den zwei Zeilen kann ich dir nicht sagen wo dein Fehler ist.

Funktioniert denn mit:

Code: [Auswählen]

push byte 0x25
call video_write_charDie Ausgabe mit eines '%', viel mehr sollte sich nicht tun?

Und das tut, dann auch noch mit push eax, (bei eax = 0x25); daran liegt der Fehler nicht.

[Cjreek]

Hi,

Ich habe das Gefühl dass du alle Zeichen auf die gleiche Stelle schreibst.

Zeig mal deine Funktion um Strings auszugeben. Ich glaube du schreibst alle Chars "übereinander" wodurch nur der letzte sichtbar ist.

Lg
Cjreek