Char vergleichen

Ich glaube so langsam, das es am GCC liegt, der 32Bit-Code erzeugt. Zu mindest wird das Thema hier http://forum.osdev.org/viewtopic.php?f=13&t=14157&start=0 behandelt.

Ich denke, du fährst besser, wenn du gleich in den Protected-Mode wechselst und 32-Bit-Code verwendest. So schwer ist das auch nicht, GrUB als Bootloader nimmt dir da einiges ab.

Edit: Hier gibts noch eine Erklärung, wie man mit GCC 16Bit-Code erzeugt: http://forum.lowlevel.eu/index.php?topic=1288.0

Meine Vermutung ist, das dein Code das derzeit nicht ist. Was gibt objdump auf das .o-File deines C-Codes aus?
 
Zuletzt bearbeitet:
Hm. Ich bin mir sicher, dass es am GCC liegt. Der 16-bit Trick funktioniert leider auch nicht, es funktioniert nichts mehr; ich kann keine Funktion aufrufen. Ich versuche jetzt mal in den PM zu wechseln.
 
Wow! Inzwischen funktionert der Trick!
Meine Funktion sieht so aus:
C: 
int printString(char* szString) {
	int i=0;
	int finished=0;

	while (finished != 1)
	{
		if (szString[i] != '\0') {
			print(szString[i]);
			i++;
		}
		else {
			finished=1;
		}
	}
	return 0;
}
und ich rufe sie so auf:
C: 
char szString[] = "Hallo Welt!";
printString(szString);
Leider stoppt die Funktion jetzt nie und es wird ewig Hallo Welt! ausgegeben... Ich verstehe leider nicht, warum. Ich hoffe mir kann jemand helfen. :)

EDIT:
printString("Hallo Welt!") funktioniert nicht, weil der String nicht übergegeben wird.

EDIT2:
Ich benutze zurzeit asm(".code16gcc\n");.
Wenn ich asm(".code16\n"); stattdessen schreibe, werden mit 11 leere Zeichen ausgegeben. Ich fürchte hinter dem Problem steckt doch noch ein bisschen mehr.
 
Zuletzt bearbeitet:
Leider stimmt das nicht. Ich kann ganz normal Buchstaben ausgeben (mit mov al, 'X'). Deshalb kann es kaum am 10er Interrupt liegen. Hast du noch andere Ideen?

EDIT:
Ich glaube, ich spinne:
C: 
int printString(char* szString) {
	int i=0;
	while (i != 2)
	{
		print(szString[i]);
		i=i+1;
	}
	return 0;
}
Dieser Code gibt ewig HaHaHaHa usw. aus.
Ich versteh's nicht. Vielleicht will der Computer mich ja auslachen. :D
 
Zuletzt bearbeitet:
Wie gesagt, ich bin kein ASM-Profi, ich klau mir auch die Sachen aus dem Netz zusammen ;-)

Was mir allerdings noch aufgefallen ist: Der Datentyp int ist in der Regel 32bit groß. Versuch mal statt dessen short.

Hast du mal das Objekt-File deines C-Sources disassembliert? Wenn da irgendwelche 32bit-Register vorkommen, ist das natürlich ungünstig.

Edit: Kannst du mal den Code zeigen, der "printString" aufruft? Also alles, was so da drum rum ist.
 
Zuletzt bearbeitet:
:D short oder int ändert nichts. Ich hab das ganze disassembliert, und es werden 32bit Register verwendet. Hier ist der gesamte Sourcecode:
C: 
asm(".code16gcc\n");
extern void print();
extern void restart();
extern char read();
int printString(char* szString);

int main() {
	char szString[] = "Hallo Welt!";
	printString(szString);
	while(read() != 'r');
	restart();
	return 0;
}

int printString(char* szString) {
	short i=0;
	while (i != 2)
	{
		print(szString[i]);
		i=i+1;
	}
	return 0;
}
Wie gesagt, ich verstehe nicht, warum das Programm nicht aus der Funktion zurückkehrt.

EDIT:
Das ist übrigens das disassemblierte:
Code: 
00000210  6653              push ebx
00000212  6683EC14          sub esp,byte +0x14
00000216  67668B5C241C      mov ebx,[dword esp+0x1c]
0000021C  67660FBE03        movsx eax,byte [ebx]
00000221  6650              push eax
00000223  E87A00            call word 0x2a0
00000226  67660FBE4301      movsx eax,byte [ebx+0x1]
0000022C  6766890424        mov [dword esp],eax
00000231  E86C00            call word 0x2a0
00000234  66B800000000      mov eax,0x0
0000023A  6683C418          add esp,byte +0x18
0000023E  665B              pop ebx
00000240  C3                ret
00000241  67668D4C2404      lea ecx,[dword esp+0x4]
00000247  6683E4F0          and esp,byte -0x10
0000024B  6766FF71FC        push dword [ecx-0x4]
00000250  6655              push ebp
00000252  6689E5            mov ebp,esp
00000255  6651              push ecx
00000257  6683EC20          sub esp,byte +0x20
0000025B  6766C745EC48616C  mov dword [ebp-0x14],0x6c6c6148
         -6C
00000264  6766C745F06F2057  mov dword [ebp-0x10],0x6557206f
         -65
0000026D  6766C745F46C7421  mov dword [ebp-0xc],0x21746c
         -00
00000276  67668D45EC        lea eax,[ebp-0x14]
0000027B  6650              push eax
0000027D  E890FF            call word 0x210
00000280  6683C410          add esp,byte +0x10
00000284  E82900            call word 0x2b0
00000287  3C72              cmp al,0x72
00000289  75F9              jnz 0x284
0000028B  E83200            call word 0x2c0
0000028E  66B800000000      mov eax,0x0
00000294  67668B4DFC        mov ecx,[ebp-0x4]
00000299  C9                leave
0000029A  67668D61FC        lea esp,[ecx-0x4]
 
Zuletzt bearbeitet:
Für Compiler/Linker, bin ich dieser Seite gefolgt: http://www.lowlevel.eu/wiki/Crosscompiler_für_Windows.
Ich benutze eine Batch zum Erstellen.
So sieht sie aus:
Code: 
nasm\NASM.exe -f bin -o bootloader.bin bootloader.asm
nasm\NASM.exe -f bin -o padding.bin padding.asm
nasm\NASM.exe -f elf -o kernelA.elf kernel.asm
nasm\NASM.exe -f elf -o functions/read.elf functions/read.asm
nasm\NASM.exe -f elf -o functions/restart.elf functions/restart.asm
nasm\NASM.exe -f elf -o functions/print.elf functions/print.asm
compiler_linker\bin\i586-elf-gcc.exe -Wall -O -fstrength-reduce -fomit-frame-pointer -finline-functions -nostdinc -fno-builtin -I./include -c -o kernelB.elf kernel.c
compiler_linker\bin\i586-elf-ld.exe -T link.ld -o kernel.bin kernelA.elf kernelB.elf functions/print.elf functions/read.elf functions/restart.elf
copy bootloader.bin+kernel.bin+padding.bin OS.img
mkisofs\mkisofs.exe -b OS.img -o OS.iso OS.img
PAUSE
 
Ich komme dem Problem auf die Schliche.
Wenn ich das print() weglasse funktionierts (mit der .code16gcc Variante). Aber erklären kann ich mir das immer noch nicht.
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück