Char vergleichen

Hi,

ich verwende asm(".code16gcc\n");.
Wenn die print() so aussieht, wird dreimal b ausgegeben.
Code: 
[BITS 16]
global print

print:
	push ebp
	mov ebp, esp
	mov al, 'b'
	mov ah, 0x0E
	mov bl, 0x07
	int 0x10
	mov ebp, esp
	pop ebp
	o32 ret

(normalerweise steht [ebp+8] statt 'b' da).

Meine kernel.c sieht im Moment so aus:
C: 
asm(".code16gcc\n");
extern void print();
extern void restart();
extern char read();
void printString(char* szString);
void testfunc(char test);

int main() {
	char szWelcome[] = "Hello world, welcome to my OS. Please press a key to start.";
	printString(szWelcome);
	read();
	testfunc('a');
	read();
	char szRestart[] = "Press 'r' to restart your computer.";
	printString(szRestart);
	while(read() != 'r');
	restart();
	return 0;
}

void printString(char* szString) {
	short i=0;
	short x=0;
	while (x == 0) {
		print(szString[i]);
		i++;
		if (szString[i] == '\0') {
			x=1;
		}
	}
}

void testfunc(char test) {
    print(test);
    print(test);
    print(test);
}

So wird nur ein a ausgegeben. Mit Pixeln, die gezeichnet werden sollen ist es genauso.
 
Code: 
    mov ebp, esp
    pop ebp

Hast du da nicht was vertauscht?

Code: 
    mov esp, ebp
    pop ebp


Und ich kenn mich nicht Detailiert mit ASM aus, aber ESP und EBP sind doch die 32-Bit Namen...!?
Wieso steht oben von deinem ASM-Code noch das [BITS16]? Kann man das so mischen?
 
Zuletzt bearbeitet:
Ups. ebp und esp habe ich vertauscht. Hilft aber leider nichts. Ich weiß, dass ich 16 und 32 bit ziemlich wild mische, aber im Prinzip sollte das trotzdem funktioniert, weil GCC auch nicht wirklich 16 bit erzeugt. Ich versuche am Wochenende in den Protected Mode zu gehen, wonach die 16- und 32 bit Probleme erstmal beseitigt sein sollten.
 
So langsam versteh ich gar nichts mehr:
C: 
void testfunc(char test) {
    if (test == 'a') {
		print(test);
	}
	if (test == 'a') {
		print(test);
	}
	if (test == 'a') {
		print(test);
	}
}
gibt dreimal a aus. Das löst jetzt zwar mein Problem nicht, aber vielleicht hat ja jetzt einer eine Idee.

EDIT:
C: 
void testfunc(char test) {
	int x=0;
	if (test == 'a') {
		print(test);
	}
	if (test == 'a') {
		print(test);
	}
	if (x == 0) {
		print(test);
	}
}

Das hier gibt zweimal a aus...

EDIT2:
C: 
if (test != 'b') {
       print(test);
}
gibt a nicht aus. Das liegt aber schon am GCC, oder kann das an meinem Code liegen?
 
Zuletzt bearbeitet:
Hast es schonmal mit einem anderen Compiler versucht?
Dann wüsstest definitiv obs an dem liegt oder nicht (was ich eher nicht glaube...).
 
Nein, habe ich noch nicht. Ich wüsste aber auf Anhieb auch nicht mit welchem. Es muss halt ein 16 bit Crosscompiler sein. Da ist GCC eigentlich schon erste Wahl.
 
Vielleicht hilft ja disassemblieren:
Code: 
00000200  8CC8              mov ax,cs
00000202  8ED8              mov ds,ax
00000204  8ED0              mov ss,ax
00000206  B8F0FF            mov ax,0xfff0
00000209  89C4              mov sp,ax
0000020B  E89500            call word 0x2a3
0000020E  0000              add [bx+si],al
00000210  6653              push ebx
00000212  6683EC08          sub esp,byte +0x8
00000216  678A5C2410        mov bl,[dword esp+0x10]
0000021B  80FB62            cmp bl,0x62
0000021E  742A              jz 0x24a
00000220  6683EC0C          sub esp,byte +0xc
00000224  660FBEC3          movsx eax,bl
00000228  6650              push eax
0000022A  66E820010000      call dword 0x350
00000230  6683C410          add esp,byte +0x10
00000234  80FB61            cmp bl,0x61
00000237  7511              jnz 0x24a
00000239  6683EC0C          sub esp,byte +0xc
0000023D  666A61            push dword 0x61
00000240  66E80A010000      call dword 0x350
00000246  6683C410          add esp,byte +0x10
0000024A  6683EC0C          sub esp,byte +0xc
0000024E  660FBEDB          movsx ebx,bl
00000252  6653              push ebx
00000254  66E8F6000000      call dword 0x350
0000025A  6683C418          add esp,byte +0x18
0000025E  665B              pop ebx
00000260  66C3              o32 ret
00000262  6657              push edi
00000264  6656              push esi
00000266  6653              push ebx
00000268  67668B7C2410      mov edi,[dword esp+0x10]
0000026E  66BE00000000      mov esi,0x0
00000274  6683EC0C          sub esp,byte +0xc
00000278  660FBFDE          movsx ebx,si
0000027C  67660FBE041F      movsx eax,byte [dword edi+ebx]
00000282  6650              push eax
00000284  66E8C6000000      call dword 0x350
0000028A  6646              inc esi
0000028C  660FBFDE          movsx ebx,si
00000290  6683C410          add esp,byte +0x10
00000294  67803C1F00        cmp byte [dword edi+ebx],0x0
00000299  75D9              jnz 0x274
0000029B  665B              pop ebx
0000029D  665E              pop esi
0000029F  665F              pop edi
000002A1  66C3              o32 ret
000002A3  67668D4C2404      lea ecx,[dword esp+0x4]
000002A9  6683E4F0          and esp,byte -0x10
000002AD  6766FF71FC        push dword [ecx-0x4]
000002B2  6655              push ebp
000002B4  6689E5            mov ebp,esp
000002B7  6657              push edi
000002B9  6656              push esi
000002BB  6651              push ecx
000002BD  6683EC78          sub esp,byte +0x78
000002C1  67668D7DAC        lea edi,[ebp-0x54]
000002C6  66BE00201000      mov esi,0x102000
000002CC  66B90F000000      mov ecx,0xf
000002D2  66F3A5            rep movsd
000002D5  67668D45AC        lea eax,[ebp-0x54]
000002DA  6650              push eax
000002DC  66E880FFFFFF      call dword 0x262
000002E2  66E888000000      call dword 0x370
000002E8  6766C70424610000  mov dword [dword esp],0x61
         -00
000002F1  66E819FFFFFF      call dword 0x210
000002F7  66E873000000      call dword 0x370
000002FD  67668D7D88        lea edi,[ebp-0x78]
00000302  66BE3C201000      mov esi,0x10203c
00000308  66B909000000      mov ecx,0x9
0000030E  66F3A5            rep movsd
00000311  67668D4588        lea eax,[ebp-0x78]
00000316  6766890424        mov [dword esp],eax
0000031B  66E841FFFFFF      call dword 0x262
00000321  6683C410          add esp,byte +0x10
00000325  66E845000000      call dword 0x370
0000032B  3C72              cmp al,0x72
0000032D  75F6              jnz 0x325
0000032F  66E8AB000000      call dword 0x3e0
00000335  66B800000000      mov eax,0x0
0000033B  67668D65F4        lea esp,[ebp-0xc]
00000340  6659              pop ecx
00000342  665E              pop esi
00000344  665F              pop edi
00000346  665D              pop ebp
00000348  67668D61FC        lea esp,[ecx-0x4]
0000034D  66C3              o32 ret
0000034F  006655            add [bp+0x55],ah
00000352  6689E5            mov ebp,esp
00000355  678A4508          mov al,[ebp+0x8]
00000359  B40E              mov ah,0xe
0000035B  B307              mov bl,0x7
0000035D  CD10              int 0x10
0000035F  6689ED            mov ebp,ebp
00000362  665D              pop ebp
00000364  66C3              o32 ret
00000366  0000              add [bx+si],al
00000368  0000              add [bx+si],al
0000036A  0000              add [bx+si],al
0000036C  0000              add [bx+si],al
0000036E  0000              add [bx+si],al
00000370  B400              mov ah,0x0
00000372  CD16              int 0x16
00000374  B400              mov ah,0x0
00000376  C3                ret
00000377  0000              add [bx+si],al
00000379  0000              add [bx+si],al
0000037B  0000              add [bx+si],al
0000037D  0000              add [bx+si],al
0000037F  006655            add [bp+0x55],ah
00000382  6689E5            mov ebp,esp
00000385  BB0700            mov bx,0x7
00000388  678B4D08          mov cx,[ebp+0x8]
0000038C  678B550C          mov dx,[ebp+0xc]
00000390  678A4510          mov al,[ebp+0x10]
00000394  B40C              mov ah,0xc
00000396  CD10              int 0x10
00000398  665D              pop ebp
0000039A  66C3              o32 ret
0000039C  0000              add [bx+si],al
0000039E  0000              add [bx+si],al
000003A0  B400              mov ah,0x0
000003A2  B012              mov al,0x12
000003A4  CD10              int 0x10
000003A6  66C3              o32 ret
000003A8  0000              add [bx+si],al
000003AA  0000              add [bx+si],al
000003AC  0000              add [bx+si],al
000003AE  0000              add [bx+si],al
000003B0  B90000            mov cx,0x0
000003B3  6655              push ebp
000003B5  6689E5            mov ebp,esp
000003B8  678B5D08          mov bx,[ebp+0x8]
000003BC  83F91E            cmp cx,byte +0x1e
000003BF  7413              jz 0x3d4
000003C1  89D0              mov ax,dx
000003C3  52                push dx
000003C4  F7F3              div bx
000003C6  5A                pop dx
000003C7  01D0              add ax,dx
000003C9  B302              mov bl,0x2
000003CB  52                push dx
000003CC  F6F3              div bl
000003CE  5A                pop dx
000003CF  89C2              mov dx,ax
000003D1  41                inc cx
000003D2  EBE8              jmp short 0x3bc
000003D4  665D              pop ebp
000003D6  C3                ret

Hier nochmal alle relevanten Dateien im Überblick:
kernel.asm:
Code: 
[Bits 16]
[extern main]
[global start]

start:
	mov ax, cs
    mov ds, ax
    mov ss, ax 
    mov ax, 0xFFF0
    mov sp, ax 
    call main

kernel.c
C: 
asm(".code16gcc\n");
extern void print();
extern void restart();
extern char read();
void printString(char* szString);
void testfunc(char test);

int main() {
	char szWelcome[] = "Hello world, welcome to my OS. Please press a key to start.";
	printString(szWelcome);
	read();
	testfunc('a');
	read();
	char szRestart[] = "Press 'r' to restart your computer.";
	printString(szRestart);
	while(read() != 'r');
	restart();
	return 0;
}

void printString(char* szString) {
	short i=0;
	short x=0;
	while (x == 0) {
		print(szString[i]);
		i++;
		if (szString[i] == '\0') {
			x=1;
		}
	}
}

void testfunc(char test) {
	int x=0;
	if (test != 'b') {
		print(test);
	}
	if (test == 'a') {
		print(test);
	}
	if (x == 0) {
		print(test);
	}
}

read.asm
Code: 
[BITS 16]
global read

read:
	mov ah, 0x0
	int 0x16
	mov ah, 0
	ret

print.asm
Code: 
[BITS 16]
global print

print:
	push ebp
	mov ebp, esp
	mov al, [ebp+8]
	mov ah, 0x0E
	mov bl, 0x07
	int 0x10
	mov esp, ebp
	pop ebp
	o32 ret

restart.asm
Code: 
[BITS 16]
global restart

restart:
	db 0Eah
	dw 0000h
	dw 0FFFFh

Ich linke das dann so:
Code: 
i586-elf-ld.exe -T link.ld -o kernel.bin kernelA.elf kernelB.elf functions/print.elf functions/read.elf functions/restart.elf

Danke an alle, die helfen! :)
Ich hoffe, es liegt irgendwie an meinem Code. Ich werde morgen noch ein paar Versuche anstellen.
 
Zuletzt bearbeitet:
So, es wird immer komischer:
C: 
void testfunc(char test, char test2, char test3, char test4) {
	print(test);
	print(test2);
	print(test3);
	print(test4);
}
lässt alles völlig abstürzen. Das hängt wohl wieder mit dem Linker zusammen (genügend Sektoren habe ich geladen).
Das
C: 
void testfunc(char test, char test2, char test3) {
	print(test);
	print(test2);
	print(test3);
}
gibt zweimal a aus, obwohl ich drei übergebe.
Ich habe das Gefühl, irgendetwas komplett falsch zu machen. Vielleicht ist es das 16- und 32 bit Mischen, aber es dauert wohl doch noch ein bisschen mit dem Protected Mode. Kann mir jemand helfen?
 
Ehrliche Meinung? Die Zeit, die du damit verschwendest, herauszufinden, woran dein Code scheitert, legst du besser darin an, einen PM-Kernel zu bauen. Evtl. ist hier auch keiner so tief in der Materie drin, um die ganzen Vorgänge zu überblicken. Ich schäme mich dir vorzuschlagen, mal beim Low-Level-Forum nachzufragen, aber vielleicht kann man dir dort weiterhelfen.

Ich befürchte aber fast, dass es so, wie du dir vorstellst nicht umzusetzen ist. Du wirst vermutlich immer wieder auf die gleichen Probleme stoßen. IMHO handelt es sich um ein Problem mit dem Stack, was aus dem Mischen des 16-/32bit-Codes resultiert. Ich bin aber kein Profi was das angeht und kann komplett daneben liegen.

Mit einem PM-Kernel wirst du jedenfalls mit komplett anderen Problemen zu kämpfen haben. Möglicherweise kann man dir dabei aber eher helfen als beim aktuellen Problem :)

EDIT: Mit welchem Emu arbeitest du aktuell? Hast du schon mal einen Debugger an den Emu gehängt? Mit Bochs geht das ganz gut, mit Qemu soll es auch prima zubewerstelligen sein. Wäre zumindest mal interessant zu wissen, an welchen Punkt es genau knallt.
 
Zuletzt bearbeitet:
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück