Lowlevel
OffZone => Offtopic => Thema gestartet von: JG am 27. February 2005, 13:50
-
Hallo,
wenn ich in C wissen will, was in EAX steht, wie kann ich das machen? Und kann ich das in ne Variable kopieren?
-
Das geht in der Sprache C nicht. Um die Register kümmert sich der Compiler. Wenn du dennoch mit Registern arbeiten willst, musst du Inline-Assembler benutzen. Das unterscheidet sich von Compiler zu Compiler.
-
Ja, das mit inline-ASM is mir schon klar, ich meine, ob ich den Wert der in EAX steht in eine Variable speichern kann
-
warum sollte das nicht gehen? wie das geht kommt aber auf den compilen an den du benutzt...
-
Oh, iich hab mich falsch ausgedrückt....
Ich hab gemeint, ob ich den Wet, der in EAX steht in eine Variable schreiben kann, die von meinem C Programm gelesen werden kann. Oder würde dieser Code gehen:
void main(void)
{
int variable;
_asm{mov variable, eax};
printf ("%d,variable");
}
-
Oh, iich hab mich falsch ausgedrückt....
Ich hab gemeint, ob ich den Wet, der in EAX steht in eine Variable schreiben kann, die von meinem C Programm gelesen werden kann. Oder würde dieser Code gehen:
void main(void)
{
int variable;
_asm{mov variable, eax};
printf ("%d,variable");
}
erstens: es heißt int main()!
und zweitens: kommt auf den compiler an... bei gcc kannst den code schonmal vergessen
-
es heisst nicht zwingend int main()
Ich lege doch selbst die mainfunktion fest und damit auch den rückgabetyp.
Ich könnte die Funktion auch kuhliehfumdenteich() nennen ^^ ist doch egal. Ich muss nur den Aufruf der Funktion entsprechend anpassen.
-
dann eben
int main(void)
{
int variable;
_asm{mov variable, eax};
printf ("%d,variable");
}
Aber gehen tut der Code, oder?
-
dürfte auch nich gehn, printf hat ne falsche parameterliste ( ersetz das "%d,variable" mal mit "%d",variable )
-
Du kannst in inline-ASM nicht einfach C-Variablen nehmen!
Das _asm_("mov variable, eax"); kannst vergessen!
-
Hängt vom Compiler ab, würde ich mal sagen.
-
Warum willst du denn den Wert von EAX in eine Variable speichern?
Vielleicht sagst du mal was du "als ganzes" vor hast. Dann kann man dir dazu vielleicht auch ne Lösung sagen.
-
ich nehme mal an er will es zu testzwecken ausgeben.
wie in bochs mit dump_cpu....
Ich werde diese funktionen früher oder speter auch noch coden. aber vorerst brauche ich ne funktion die zahlen ausgeben kann ;)
-
Warum willst du denn den Wert von EAX in eine Variable speichern?
Vielleicht sagst du mal was du "als ganzes" vor hast. Dann kann man dir dazu vielleicht auch ne Lösung sagen.
Ich will mit deiner Funktion den Arbeitsspeicher berechnen und dann ausgeben...
-
Dann ruf die Funktion doch einfach von C auf aus.
Der Rückgabewert ist immer in EAX gespeichert.
-
Achso, so meinst du das:
unsigned long GetMemSize();
unsigned long GetMemSize()
{
_asm
{
_GetMemSize:
push ebp
mov ebp, esp
push eax
push edx
mov eax, 0 ;EAX ist Zähler für die MBs
mov edx, 0x1EFFFC ;EDX auf 3 Bytes vor die 2 MB Grenze setzen
.1:
inc eax
mov DWORD [edx], 0xAAAAAAAA ;0xAAAAAAAA an die Speicherstelle schreiben
mov ebx, [edx] ;Speicherstelle wieder lesen
add edx, 0x100000 ;Adresse um 1 MB erhöhen
cmp ebx, 0xAAAAAAAA ;Stimmt gelesener Wert mit dem geschriebenen überein?
je .1
pop edx
pop eax
mov esp, ebp
pop ebp
ret
}
}
oder wie?
-
Nein.
du deklarierst:
extern UINT GetMemSize();
und dann rufst du auf:
int main()
{
unsigned int Mem;
Mem = GetMemSize();
}
fertig.
Musst halt sehen das die ASM-Datei zu der C-Datei hinzugelinkt wird
-
Ich hab noch ne Frage, wie übergeb ich an eine Funktion eine Variable, also keine Funktion, die einen Rückgabewert hat, sondern ich übergeb z.b. var1 und var2
ich hoffe ihr versteht was ich will
-
So, etwas genauer:
ich will out auch unter C nutzen, also muss ich ja den Port und das Register ja an meine Funktion outp() übergeben. Nur meine Variable von C kann ich ja in ASM nicht lesen...
-
ca so:
unsigned char inb(unsigned int _port)
{
unsigned char result;
asm volatile ("inb %%dx, %%al" : "=a" (result) : "d" (_port) );
return result;
};
void outb(unsigned int _port, unsigned char _value)
{
asm volatile ("outb %%al, %%dx" : : "d" (_port), "a" (_value));
};
mit "=a (result)" wird eax in result geschrieben.
mit "d (_port)" wird edx mit _port gefüllt....etc
%%=bedeuted das es ein register ist...
und zuletzt musst du hinter die befehle die grösse schreiben.. outb für byte outw für word und outd für double...
-
Hallo,
1. asm volatile ("outb %%al, %%dx" : : "d" (_port), "a" (_value)) ich dachte man macht inline ASM so: _asm{...}
2. Warum "outb", heißt das nicht nur "out"?
3. Heißt das ganze nicht "out port, value"
4. Warum char?
Irgendwie versteh ich des net....
-
1. es giebt verschiedene wege asm einzubinden
2. out für den out befehl und "b" damit mit einem byte gearbeitet wird
3. im AT&T syntax (den ich verwende) muss man dass drehen
4. char ist ein zeichen sprich ein byte....
variablen typen
char = 8 bit = 1 byte
short = 16 bit = 2 byte
long = 32 bit = 4 byte
unsigned heist das das most sinified byte (keine ahnung wie man das schreibt) nicht gesetzt werden kann... das benutzt man um minus zahlen zu schreiben. wenn man unsigned variablen macht kann man höhere zahlen speichern, dafür nicht ins minus gehen...
;)
-
Wenn ich z.b. 0x00 senden will, dann ist das doch ein byte, oder?
Geht das?:
unsigned char inb(unsigned int);
void outb(unsigned int, unsigned char);
unsigned char secound;
void main(void)
{
outp(0x70, 0x00);
secound = inp(0x71);
}
unsigned char inb(unsigned int _port)
{
unsigned char result;
asm volatile ("inb %%dx, %%al" : "=a" (result) : "d" (_port) );
return result;
};
void outb(unsigned int _port, unsigned char _value)
{
asm volatile ("outb %%al, %%dx" : : "d" (_port), "a" (_value));
};
? Oder hab ich was falsch verstanden?
Edit: Warum nehm ich net gleich long, dann brauch ich keine 3 funktioonen?
-
jep sollte gehen!
-
Und siehe mal wegen meinem edit da oben ^^
-
Edit: Warum nehm ich net gleich long, dann brauch ich keine 3 funktioonen?
warum 3 funktionen für char, short und long? weil manche ports nur char, short oder long lesen und bei anderen datenbreiten fehler verursachen ...