C-Code in Assemblerprojekt verwenden

Micha s. hat recht.
Du willst nicht C Code in einem Assembler Projekt einsetzen sondern 
maximal umgekehrt Assembler in einem C-Projekt benutzen, falls das 
überhaupt notwendig ist und nicht alles sowieso in C geschrieben wird.

es gibt auch für diverse prozessoren ein re-c - also programme die dir 
aus asm code wieder c code machen.
*SOLL JETZT ABER KEINE EMPFEHLUNG SEIN!!!*
ich halte von den teilen nichts, wenn du was lernen willst (und sowas 
ist eine sehr gute Übung) dann mach es selbst!

und wenn du probleme hast dann poste dein programm hier, hier wird dir 
sicher geholfen :))

> Noe, du kannst auch aus Assembler C-Funktionen aufrufen. Es mag nicht
> besonders elegant sein, aber moeglich ist es.

aslo ich persönlich fände es da schöner wenn du deinen c code übersetzen 
lässt und dir dann das asm listing anschaust und ggf rauskopierst.

um was für funktionen handelt es sich denn???
du kannst ja schliesslich auch nicht deinen arzt anrufen und sagen herr 
doktor mir fehlt was und erwarten das er dir richtig hilft :))

Mirko schrieb:

> Ich wollte mir die Arbeit ersparen, alles in C neu zu schreiben.
> Da ich den Assemblercode nicht selbst verfasst habe und dementsprechend
> beim "Übersetzen" viele Bugs entstehen werden.

Degegen gibts nur eines:
sauber analysieren, was in welchem Bereich des Codes gemacht wird und 
das dann in C nachbauen.
Das musst du aber sowieso machen, wenn du den Code (egal ob in C oder in 
Assembler) erweitern willst.

und du lernst dabei noch einiges was ja nie verkehrt sein kann :))

es gibt einige möglichkeiten C-code in assemblercode einzubinden und 
umgekehrt.
ich gehe mal davon aus, daß du assemblerquellcode vorliegen hast und du
ihn assemblieren und linken kannst.
eine möglichkeit ist, C Funktionen compilieren und dazulinken. die C 
Funktionen können assemblerfunktionen aufrufen, assembler code kann C 
Funktionen aufrufen. dabei ist auf die compilerabhängige form der 
parameterübergabe und der übergabe des rückgabewerts zu achten.

Mirko schrieb:
> Das Projekt läuft nicht mehr lang und wird auch nicht fortgesetzt.

Ist das absolut sicher? Wenn ja, dann ist die Frage ob es sich lohnt die 
Programmiersprache zu wechseln. "Das Projekt läuft nicht mehr lang" 
klingt eher nicht so danach, als ob man alles schön strukturiert in C 
neu codieren könnte.

der C teil deines projekts muß kenntnis haben zu den asm-funktionen und 
variablen (speicherplätzen) in asm, umgekehrt, muß der asm code wissen, 
wo sind die C Funktionen und wo stehen die variablen von C.
------------------------------------------------------------------------
wenn du den C teil und den asm Teil deines projekts einzeln compilierst 
und linkst, kannst du die beiden teile einzeln in deinen controller 
laden.

dem C projekt kannst du die adressen von asm funktionen und variablen 
über einen linkerscript übergeben oder hart einprogrammieren als 
(funktions)poiner auf adressen. die asm-adressen bekommst du aus dem map 
file.
-----------------------------------------------------------------------
einfacher ist es wie gesagt, C teil und asm teil gemeinsam zu 
kompilieren.
wie die adressen von C asm bekanntgemacht werden und umgekehrt hängt ein 
wenig von deiner entwicklungsumgebung ab.

U.R. Schmitt schrieb:

> Oder einfacher:
> Deine C Funktion schreiben.
> Kleines Hauptptogramm dazu in C schreiben
> Compilieren, das entstandene Assemblerlisting ist das perfekte Beispiel
> wie Du deine C Funktion korrekt aufrufst.

Ganz so einfach ist das nicht.
Im C-Code existieren Konventionen, die vom Compiler eingehalten werden, 
und die man erst mal unter Umständen sicherstellen muss, ehe man eine 
vom Compiler generierte Funktion aufrufen kann. Nur ein Beispiel von 
vielen: im GCC existiert die Konvention, dass im Register R0 (oder war 
es R1?) immer eine 0 enthalten ist.
Jetzt kann man aber kaum davon ausgehen, dass sich das bisherige 
Assembler Programm an derartige Konventionen hält, d.h. man muss die 
erst mal mühsam vor einem Funktionsaufruf herstellen.
Umgekehrt ist es oft einfacher: Geht man von der Prämisse aus, dass man 
es mit einem C Programm zu tun hat, welches durch Assembler gepimpt 
wurde, dann erhält man automatisch:
* den C Initialisierungsteil, der vor dem main() erst mal alles so
  einrichtet, wie es der Compiler voraussetzt und wovon er als
  Basisannahmen ausgeht
* wenn die Assemblerfunktionen ihre Arbeitsregister nach Funktions-
  eintritt pushen und vor dem Ausstig wieder popen zerstören sie auch
  in dieser Umgebung nichts.

Mirko schrieb:
> Das Programm besteht aus ca. 400kb Assemblercode - natürlich mit
> Kommentaren.

Das klingt nach riesen Spaghetticode.

Dann kann man versuchen, eine Hauptfunktion zu schreiben, die dann nur 
mit unterschiedlichen Parametern aufgerufen wird, die man in einem Array 
im Flash definiert.


Peter

Karl heinz Buchegger schrieb:
> ....existieren Konventionen, die vom Compiler eingehalten werden,
> und die man erst mal unter Umständen sicherstellen muss, ehe man eine
> vom Compiler generierte Funktion aufrufen kann.

So ist es.
Im Prinzip ist es keine grosse Geschichte, aus Assembler heraus 
C-Funktionen aufzurufen. Der springende Punkt ist, dass die aufgerufene 
C-Funktion
- die C-Laufzeitumgebung vorfindet
- der Prolog und Epilog des (C-)Funktionsaufrufs (aus dem AssemblerCode 
heraus)den Konventionen des  verwendeten C-Compilers entspricht 
(Stackframe, Registerpreservation, was auch immer..)

Ich würden folgendermassen vorgehen:
Kurzes C-Programm erstellen, in das das fragliche Assemblerprogramm als 
externes Modul oder Teilestücke davon eingebunden und aufgerufen werden. 
So würde ich mich an die C-Laufzeitumgebung herantasten.
Der Funktionsprolog bzw -Epilog sollte in der Compilerdokumentation 
beschrieben sein. Hilfsweise könnte man den vom Compiler generierten 
AssemblerCode untersuchen, der entsteht, wenn aus C eine 
selbstgeschriebene C-Funktion aufgerufen wird.

mfg

Assembler mit C zu mixen kann sehr schwer sein.

C-Funktionen vertrauen auf ner Menge Konventionen, die ein 
Assemblerprogrammierer nicht kennt und daher nicht eingehalten hat.

Assemblerprogrammierer benutzen meistens nicht den Linker, sondern 
plazieren Variablen absolut. Auch muß die Byteorder nicht mit der des 
Compilers übereinstimmen.
Wenn dann der Linker C-Variablen plazieren soll, kriegt er die Krise.

Assembler nach C Zeile für Zeile umzuschreiben, ist nicht praktikabel.
Am besten Du kennst Die Funktion des Assemblerprogramms und schreibst es 
in C komplett neu.


Peter

Oliver schrieb:
>> "Das Projekt läuft nicht mehr lang"
> gehört mit zu den grössten Irrtümern der Menschheit ;)

Es gab nie ein Jahr-2000-Problem :)