obj. Datei in C++ Projekt einbinden

N

napstix

Grünschnabel
Hallo alle zusammen,
Zunächst mal vorweg, ich habe zwar schon das eine oder andere kleine Programm realisiert, aber ich bin nicht der wahre Programmier-Experte.

Mein Problem ist nun folgendes:

Ich möchte in einem C++ Projekt (Borland C++ Ver. 5.0) unter MS-DOS Informationen von einer PCI-Karte im PC auslesen (z.B. die I/O-Adresse).
Dazu habe ich einen Beispielcode mit Inline-Assembler nach folgendem Schema gefunden:

for (slot_no=0;(slot_no<=0x00F8) && (io_adr==0);slot_no+=8)
{
__asm mov bx,word ptr (slot_no)
__asm mov ax,word ptr (0xb109)
__asm mov di,word ptr (0x0000)
__asm INT (0x1a)
__asm mov v_id,ecx // <<< die Stelle wird zum 1. Problem!

.... und so weiter (es folgen noch mehrere Zugriffe auf ecx).

Das Problem ist, dass der Borland-Compiler nur 286-er Maschinenbefehle kennt, und damit keine 32-Bit Registerzugriffe (z.B. ecx) kann.

Den Code zum Auslesen des PCI-BIOS gibts auch noch direkt als ASM-Datei, und vorkompiliert als OBJ-Datei.
Dazu ist auch noch ein Beispiel mit dem Aufruf der Funktion (INT_1A), etwa so:


extern unsigned long far pascal INT_1A( unsigned long reax,
unsigned long rebx,
unsigned long recx,
unsigned long redi);
// ------------------------------------------------------------------
unsigned long pci_rd_cfg (unsigned int einheit, unsigned int adresse)
{
unsigned long inhalt;

inhalt=INT_1A(0xb10aL,(long) einheit,0L , (long) adresse);
return (inhalt);
}
// -------------------------------------------------------------------
void pci_wr_cfg(unsigned int einheit, unsigned int adresse, unsigned long wert)
{
INT_1A(0xb10dL, (long) einheit, (long) wert, (long) adresse);
....
}


Nun meine Frage, wie kann ich in das Projekt die "INT_1A.OBJ" -Datei einbinden, damit der Compiler den Funktionsaufruf versteht?

Beste Grüße
Jörg
 
Hi Kyoko,
das ist ein echter Trost.
Ich hatte gehofft, dass es irgendwie funktioniert da der BCC Compiler generell ja 32-Bit Operationen kann,
nur der integrierte Assembler nicht. Deshalb war meine Idee, dass wenn ich dem BCC irgendwie den vorkompilierten
Code aufdrücken kann, die Sache zum laufen kommt.

Ich habe inzwischen Versuche mit 16-Bit Zugriffen auf die Register direkt aus C gemacht unter Verwendung
der Strukturen REGS aus der <dos.h>.

//-----------------------------------
union regs read_regs, write_regs;

write_regs.x.ax = ...
write_regs.x.bx = ...
write_regs.x.di = ...
int86 (0x1A, &write_regs, &read_regs)
//-----------------------------------

Die Anregung zu dieser Methode habe ich gestern noch zufällig in einem Buch gefunden(PC-Intern; Data Becker).

Meine momentane Lösung funktioniert allem Anschein nach hervorragend.
Nur gibt es hier auch Einschränkungen. Ich habe letzte Nacht die <dos.h> analysiert, und festgestellt,
dass Doppel-Word REGS auch nur für den Protected-Mode definiert sind.
Mit Protected Mode habe ich aber noch nie etwas gemacht, ich weiss nur dass es nicht ganz so easy ist.

Das Problem ist eben jetzt, dass es mit dieser Methode nur mit mehreren ineinander verschachtelten Schleifen geht,
weil ich wegen der Registerlänge getrennt nach Hersteller-ID und Karten-ID suchen muss, und dazu die Register
immer wieder neu laden muss.
Geschwindigkeitsmäßig ist das ganze eine Katastrophe, die Routine soll beim Programmstart fix durchlaufen, um
abzutesten, ob alle benötigten I/O-Karten installiert sind. Momentan ist es dafür aber nicht zu gebrauchen,
dauert viel zu lange.

Aber vielleicht fällt mir noch was anderes ein, ASM ist an der Stelle vermutlich doch viel schneller.

Beste Grüße
Jörg
 
Weist du,
wenn der Inline-ASM es nicht kann dann der Compiler auch nicht.
Der Compiler wandelt ja alles in ASM um.
Schreib doch deinen Code in C(++) und speichere den dann auch als obj-Datei.
Dann verwende VB um die beiden OBJ-Files dort einzubinden und Compiliere.
In VB ist das Einfügen voll easy.
 
@napstix Du musst halt ein Assembler haben der dir ein Object erstellen kann den du mit einem Linker mit C(++) Obj linken kannst. Musst nachschauen unter Projekteinstellungen (die Stelle wo man die libraries angibt, kenne nur VSC++) und dort das Objekt und den Pfad hinzufügen.

Schreib doch deinen Code in C(++) und speichere den dann auch als obj-Datei.Dann verwende VB um die beiden OBJ-Files dort einzubinden und Compiliere.
In VB ist das Einfügen voll easy.
Zum Vergrößern anklicken....
@Kyoko What the bloody hell are you talking about ? hast du überhaupt ne Ahnung worum es hier geht

Wenn er siecdurch schreiben nicht schnallt, dann auch durch einbinden nicht.
Zum Vergrößern anklicken....
Bullshit, wenn er das Objekt dazulinkt dann kann er es durchaus verstehen.
 
Kann denn der BCC nicht einfach einen Hex-Code aufgedrückt bekommen (für den Inline-Assembler) ?

Ich meine das irgendwo (Visual C++?) gesehen zu haben, dass man einen Assembler-Befehl auch direkt als Hex-Code (die Werte muss man latürnich dann wissen) einsetzen lassen kann. Der Compiler setzt dann diese Werte an der Stelle direkt ins Programm ein; dadurch muss der Inline-Assembler das auch nicht verstehen.
 
Probier mal das:
1. Compiliere die einzelnen Files: bcc32 -c Dateiname
2. Linke das ganze zusammen: bcc32 main-obj weitereObjs -o ExeName
Fertig! (Bei anderen Compilern gehts glaube ich genauso)
 
Bin ein totaler C++ Anfänger, programmiere damit aber meinen Roboter.
Wie kann ich den zu eine *.cc Datei die *.o Datei machen? Ich möchte einer Klasse eine Funktion hinzufügen.

P.S.: Hab Windows...
 
Erst mal Herzlich Wilkommen bei Tutorials.de :P
Was meinst du? wie du aus einer .cc Datei eine .o Datei machst?
Guck mal Ganz oben in der Thread-Ansicht von C/C++ unter Compiler etc., und suche dir da mal MinGW raus, das dürfte das richtige sein.
Skini

P.S.: Du must keinen 5 Jahre alten Thread ausgraben, rechts oben ist ein Button "Neues Thema"...
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück