Compiler und Compilierte Dateien

[Cerberus (Gast)]

Sorry für diese Betreff, aber ich bin mir gerade nicht sicher, wie man 
das ausdrücken sollte.
Zum Problem. Ich habe ein Programm für einen uC dass eine ungemein 
komplizierte Formal enthält. Die Formel ist unter Kontrolle, würde aber 
bei 64 statt 32 Bit pseudo double genauere Ergebnisse liefern. Nun habe 
ich ein schweineteures IAR-Studio, komme damit aber überhaupt nicht 
klar. Der Versuch das mit WIN-AVR problemlos zu compilieren Programm zu 
compilieren bricht mit 1000den Fehlern ab. Ich habe nicht mal 
ansatzweise Lust mich mit diesem Mist auseinanderzusetzen.
Da die Berechnung nur 6 Eingangswerte geliefert bekommt und daraus eine 
Hand voll Ausgangswerte errechnet, gäbe er die theoretische Möglichkeit 
die Berechnung als einzelne Funktion zu schreiben.
Kann ich die Unterfunktion der Berechnung separat mit dem IAR-Compiler 
mit 64bit double compilieren und das Ergebnis dann dem zu compilierenden 
Code von WIN-AVR anhängen, so dass ich an dem Geraffel rundherum 
weiterbasteln kann, und wenn ja, wie geht das?

[holger (Gast)]

>Ich habe nicht mal ansatzweise Lust mich mit diesem Mist
>auseinanderzusetzen.

Dann werd doch einfach Pizza Bäcker ;)

[Rufus Τ. F. (rufus)]

> Kann ich die Unterfunktion der Berechnung separat mit dem
> IAR-Compiler mit 64bit double compilieren und das Ergebnis
> dann dem zu compilierenden Code von WIN-AVR anhängen,

Nein. Geht nicht.

[Johann L. (gjlayde)]

Cerberus wrote:

> Kann ich die Unterfunktion der Berechnung separat mit dem IAR-Compiler
> mit 64bit double compilieren und das Ergebnis dann dem zu compilierenden
> Code von WIN-AVR anhängen, so dass ich an dem Geraffel rundherum
> weiterbasteln kann, und wenn ja, wie geht das?

1) Du erstellt ein Objekt mit dem IAR-Compiler
2) Du bringst dieses Object ins Format elf32-avr
3) Du schreibst Interfaces (eigenes asm/inline asm Modul), um von 
avr-gcc aus die Funktionen mit IAR-ABI nutzen zu können.
4) Über die Interfaces greifst Du auf die Funktionen zu.
5) Du linkst gegen die Interfaces und die nach elf32-avr konvertierten 
Objekte.

[yalu (Gast)]

> Ich habe nicht mal ansatzweise Lust mich mit diesem Mist
> auseinanderzusetzen.

Dann würde ich's einfach bleiben lassen ;-)

Falls du doch einen letzten Rest an Lust verspüren solltest:

Wenn sich der Wertebereiche der in der Formel vorkommenden Variablen
nicht über mehrere Größenordnungen erstrecken, kann evtl.
64-Bit-Festkommaarithmetik weiterhelfen. Das geht auch mit dem GCC, da
64-Bit-Integers verfügbar sind.

Oder du setzt dich eben doch mit den 1000den von Fehlermeldungen
auseinander. Oft ist es so, dass die Korrektur eines einzelnen Fehlers
gleich zig oder Folgefehler wegfegt, so dass die Anpassungen relativ
schnell gemacht sind.

Dass man IAR- und GCC-Binärcode auf einfache Art und Weise miteinander
mischen kann, glaube ich auch nicht. Da gibt es zu viele potenzielle
Unterschiede, angefangen vom Objektformat bis hin zur Registernutzung.
Nur wenn du dich gut mit beiden Compilern auskennst, kannst du es so
machen, wie Johann L. geschrieben hat. Aber da hast du wahrscheinlich
schneller die 1000 Fehlermeldungen beseitigt.

[Peter D. (peda)]

Cerberus wrote:
> klar. Der Versuch das mit WIN-AVR problemlos zu compilieren Programm zu
> compilieren bricht mit 1000den Fehlern ab. Ich habe nicht mal
> ansatzweise Lust mich mit diesem Mist auseinanderzusetzen.

Das ist kein Mist, sondern oft eine ziemlich exakte Aussage, wo den 
Compiler der Schuh drückt. Er will Dir helfen, nur mußt Du die Hilfe 
annehmen.

Einfach mal durchlesen und nen scharfen Blick auf die angegebene Zeile 
und deren Umgebung im angegebenen File werfen.

Man bearbeitet auch immer nur die erste Fehlermeldung und compiliert 
dann neu.


Peter