Hallo.
Ich möchte programme für mein eigenes os in c schreiben. Jetzt habe ich das problem wie übergebe ich parameter von c in assembler? Ich verwende den TC (Turbo C(++))
BSP:

kernel.c

Code :

1 2 3

extern "C" void setpixel(int p1,int p2,int p3); ... setpixel(4,8,16);

assembykernel.asm

Code :

1 2 3

global setpixel setpixel:  ?

Wie übertrage ich die parameter p1, p2 und p3 in assemmbler universalregister?

Vielen Dank im Voraus
LG
BassBox

Hi

die Parameter kannst du dir vom Stack holen.
Wie genau, hängt von der Aufrufkonvention ab (cdecl, stdcall...).
Die regelt auch, wohin der Returnwert gehört.

Welche dein Compiler verwendet, kann man einstellen (bzw. dort nachschauen)

Gruß

Danke! Kannst du mir die Typen erklären? Ich nimm dann den der am besten zu nutzen ist. Das coole am TC ist das der einen guten Inlineassembler hat so dass ich einfach C Befehle mit Assembler ohne externe Date definieren kann. Was ich auch noch gerne wissen wollte welchen linker ich nehmen sollte. Ich würde den TC + linker zu einem Paket zusammenschnüren und dann meinen Freunden geben die schon lange an meinem oder Programme für mein OS entwickeln wollen, da ich schon recht weit gekommen bin.
vielen Dank
LG
Euer BassBox

Bei Inline-Asm brauchst du dich normalerweise nicht um die Parameterübergabe kümmern, weil der Compiler das durch den C-Funktionskopf dazugeneriert.

Jedenfalls hat die engl. Wikipedia einen schönen Artikel dazu, und die wichtigsten Aufrufkonv. gibts auch in Deutsch: http://de.wikipedia.org/wiki/Aufrufkonvention

Für die verbreitesten (cdecl und stdcall) wäre das im Prinzip bei zB einer Funktion
int funk(int a, int b, int c)

cdecl: Ausserhalb der Funktion, wo sie aufgerufen wird:
1)Mit push die Parameter in den Stack schieben.
Hier liegt auch der auffälligste Unterschied zw. stdcall und cdecl: Die Reihenfolge.
cdecl braucht die Parameter "verkehrt":

Code :

1 2 3

push cwert push bwert push awert

Bei stdcall ist die Reihenfolge a,b,c.

2)Mit call die Funktion aufrufen

3) Die Parameter wieder aufräumen.
Bei 3 int (also 12 Byte) kann man das zB so machen:

Code :

1	add esp, 12

Der Rückgabewert kann jetzt auch aus eax abgeholt werden.

cdecl: In der Funktion:
Soll man generell nur eax, ecx und edx verwenden.
ebx ... ist reserviert.

1)Die Parameter muss man sich in Reihenfolge a,b,c mit pop vom Stack abholen.
2)Irgendwann eax setzen und returnen.

stdcall: Ausserhalb der Funktion, wo sie aufgerufen wird:
1)Mit push die Parameter in den Stack schieben.
Hier "normale" Reihenfolge

Code :

1 2 3

push awert push bwert push cwert

2)Mit call die Funktion aufrufen

3) Die Parameter NICHT wieder aufräumen.
Das muss hier die Funktion machen

Returnwert gleich wie bei cdecl.

stdcall: In der Funktion:
Ziemlich gleich wie bei cdecl.
1) Die Pop-Parameter sind aber in verkehrter Reihenfolge.
2) Statt "add esp, 12" außerhalb der Funktion bei cdecl gibt man den 12er hier beim Befehl ret mit.

Code :

1

ret 12

Gruß

vielen Dank! Wie läuft das dann über den Inlineassembler? Kann ich dann einach die Parameter dann als Vartiable ansprechen? Und wie mache ich dann da die Rückgabe? Welche linker hälst du eigentlich für sowas geeignet? Ich danke dir vielmals wenn ich mal wieder mit dem Pc und nicht mit tutsmobile online bin danke ich dir für die Hilfe !!

Lg
BassBox

Ps: Hast du ein eigenes Os? Wenn ja was kann es?

Zitat von BassBox

Wie läuft das dann über den Inlineassembler? Kann ich dann einach die Parameter dann als Vartiable ansprechen? Und wie mache ich dann da die Rückgabe?

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#include<stdio.h>   int _cdecl funk(int a,int b,int c) {     int xx;     _asm     {         mov eax, a         add eax, b         add eax, c         mov xx, eax     }     return xx; }   int main() {     int x;     x=funk(1,2,3);     printf("%d",x);     return 0; }

Geht einfach so. Ist zwar Visual-Studio-Syntax, sollte sich aber nicht großartig unterscheiden.

Zum _cdecl bei funk: So kann man auch unabhängig von den globalen Einstellungen die CallingConv. für einzelne Funktionen festlegen.
Ist aber hier nicht nötig (bzw. funktioniert mit stdcall genauso), weil die Parameterübergabe/Rückgabe ja vom Compiler übernommen wird.

Zitat von BassBox

Welche linker hälst du eigentlich für sowas geeignet?

Jeden...mein Zeug mach ich mit NASM bzw. inline mit Visual Studio, als Linker bei beiden den von Microsofts VS.

Zitat von BassBox

Ps: Hast du ein eigenes Os? Wenn ja was kann es?

Ja/nicht viel.
Hab es hauptsächlich zum Lernen bzw. Ausprobieren gemacht, und weniger damit es am Schluss funktioniert.
Dadurch ist es an allen Ecken eine Baustelle, die vorläufig aus Zeitmangel eingefroren ist.

Gruß

Mein Os ist mein Hobby. Ich entwickle mit 5 Freunden an dem Ding und ich schreibe immer Treiber, das Hauptsystem und den Editor und den Rest teilen wir auf. Es ist echt super und ich hoffe das dadraus noch was wird. Es kann Dateien von einer FAT16 Platte und von einer FAT12 Diskette lesen, unterstützt die Dateiformate .COM .bmp .txt .bin

Das klingt ja schon ganz ordentlich...nur weiter so

sorry das ich die antwort nicht vertig schreiben konnte. Mein Akku war leer... Hier ist der Rest

das Os hat einen Maus Treiber und den ANSI Zeichensatz implementiert und noch ein paar System eigene recurcen.
Das Komplette os hat eine mit der Maus zu bedienende GUI, Ein Bild editor und ausgabeprogramm, einen Editor mit Drucker Funktionen (leider nur über den Paralelen Port), einen DOS Emulator welcher eine DOS 2.0 Umgebung emuliert un natürlich einen grafischen Filemanager. Also das ist denke ich mal nich schlecht.
Vielen Dank für deine Hilfe
BassBox

Nochne frage: Funktioniert das ganze auch bei C++ ?
(sorry für das doppelt posting aber ich kann die frage einfach nicht in die letzte antwort reinpacken)

Das mit den Aufrufkonventionen?
Ja, warum nicht?

Etwas wichtiges muss man aber beachten: Klasseninterne Methoden haben eine eigene CC:
thiscall
Der Grund: Die Methoden werden zuerst unabhängig vom tatsächlichen Objekt kompiliert und bekommen dann beim Aufruf einen Pointer auf das betroffene Objekt als zusätzlichen "Parameter" mit.

thiscall ist zu allem Überfluss auch noch je nach Compiler anders.

Bei Visual Studio, wenn die Funktion eine fixe Parameteranzahl hat:
Wie stdcall, die Objektadresse muss aber vor dem Aufruf in ECX rein.

Bei Visual Studio, wenn die Funktion variable Parameterlistenlängen hat:
Wie cdecl die Objektadresse muss auch hier vor dem Aufruf in ECX rein.

Bei gcc:
Wie cdecl, die Adresse wird aber wie ein normaler Parameter mit den anderen in den Stack geschoben.
Und zwar als letztes push (bzw. im C++-Quelltext wäre das der erste Parameter).

Gruß

und per Inlineassembler? Gleich wie mit c oder? Ich habe gehört das man um globale vartiablen setzten zu können irgendwas einstellen musst. Ich nutze übrigen auch in diesem Fall den Turbo C(++). Hat eigentlich jeder Hochsprachen Compiler einen Inline Assembler?
Könnte ich dann auch rein theorethisch in Java weier schreiben? Ich habe nach geguckt: der Inlineassembler vom TC heist BASM
vielen Dank für deine Hilfe
Lg
BassBox

Zitat von BassBox

und per Inlineassembler? Gleich wie mit c oder?

Ja.

Zitat von BassBox

Ich habe gehört das man um globale vartiablen setzten zu können irgendwas einstellen musst.

Keine Ahnung. Bei Visual Studio gehts jedenfalls ohne zusätzliche Einstellungen.

Zitat von BassBox

Hat eigentlich jeder Hochsprachen Compiler einen Inline Assembler?

Die mir bekannten C/C++-Compiler alle. Vielleicht schreibt es ja auch der Sprachstandard vor...
Aber jede Hochsprache generell? Nein.
zB Bei solchen Halb-Interpretersprachen wie C# und Java würde das überhaupt keinen Sinn machen.
Die haben ja eigene Exe-Formate, in denen keine direkten Prozessorbefehle vorkommen.
Wohin also mit dem übersetzten Assemblerteil?

Zitat von BassBox

Könnte ich dann auch rein theorethisch in Java weier schreiben?

Du könntest Inline-Asm in einer C-DLL machen und diese per JNI/JNA in Java verwenden.

Zitat von BassBox

Ich habe nach geguckt: der Inlineassembler vom TC Geist BASM

Das B steht wahrscheinlich für Borland.

Gruß

Danke! Gut ich habe noch eine Frage. Um mir die mühe und dem Umweg mit dem Linker zu ersparen kann ich das zeugs nich einfach ganz normal zu exe machen und das programm dann mit einem Jump oder Call starten? Ich weis nicht genau ob exe gleich funktioniert wie binary oder noch einen header hat.
Hast du Zufällig ahnung davon? Wäre nämlich besser das zeugs zu exe zu machen und dann zu starten als noch über umwege zu linken. Ich würde das starten nähmlich lieber dem OS überlassen (ist Praktischer und das programm wird unwesentlich kleiner).(hat leder nicht viel mit dem thema zu tun aber ich wills trotztdem wissen) Und Weist du ob die Dos interupts (realmode) auch unterwindows 32bit in der IDT eingetragen sind? Und ob es irgendwo im netzt eine tabelle mit den windows idt interrupts gibt? (ich versuche mein OS linux und Windows Kompartibel zu halten)
LG
BassBox

Zu Exe machen kannst du schon, aber auch ein ganz normales Hello-World-Programm unter Windows wird gelinkt.
Hier die "normalen" Parameter, die VS unter 32bit-XP bei mir für ein Konsolenprogramm nimmt:

Code :

1	kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:no /pdb:"Release/prog.pdb" /machine:I386 /out:"Release/prog.exe"

Also ziemlich viele Standardlibrarys von Windows mit drin.
Alle werden vielleicht nicht gebraucht, aber wenn du eine Standard-Exe von Windows starten können willst, musst du die Funktionen alle zur Verfügung stellen.

Und ja, eine Exe hat auch ihr eigenes Format. Wie das aufgebaut ist, kann man schnell im Internet finden.

Gruß