Gewusst wie: aufrufen von C-Funktionen von ARM-Assembly?

Ich bin das schreiben von code targeting ARM-Cortex-A-auf Android-Geräte (mit GNU assembler und compiler), und ich versuche, die Schnittstelle zwischen Montage und C. insbesondere bin ich daran interessiert, den Aufruf von Funktionen in C geschrieben, von der Montage. Ich versuchte viele Dinge, einschließlich der .extern Richtlinie Deklaration von C-Funktionen mit asm und __asm__ und so weiter, aber keiner von Ihnen arbeitete, so dass ich bin auf der Suche nach ein minimal-Beispiel zu tun. Eine Referenz zum Beispiel wäre genauso willkommen.

Ich war denken, aber C verwendet werden header-Dateien mit Funktionsdeklarationen für die Kommunikation zwischen verschiedenen Dateien. Wäre es nicht ein völlig anderes Bild?
Sucht der compiler bei der Deklaration der Funktion in der header-Datei zu kompilieren, der Aufruf. Sie müssen das gleiche zu tun, manuell.

InformationsquelleAutor Phonon | 2011-12-07

6

Bitte Lesen Sie die ARM-ARM und/oder wissen der Befehlssatz ist alle, die Sie normalerweise wollen würde, so etwas zu tun
```
asm:

bl cfun

c:
void cfun ( void )
{

}
```
Können Sie versuchen, diese selbst. für gnu und gcc als dies Prima funktioniert, sollte es auch gut funktionieren, wenn Sie verwenden klammerten sich um den c-code auf ein Objekt und gnu für assembler. Nicht sicher, was Sie verwenden.

Das problem mit der oben bl hat eine begrenzte Reichweite,
```
if ConditionPassed(cond) then
  if L == 1 then
    LR = address of the instruction after the branch instruction
    PC = PC + (SignExtend_30(signed_immed_24) << 2)
```
wissen, dass die bl-Befehl setzt den link registrieren, um die Anweisung nach der bl-Anweisung, dann, wenn Sie Lesen, über die program-counter-register:
```
For an ARM instruction, the value read is the address of the instruction
plus 8 bytes. Bits [1:0] of this
value are always zero, because ARM instructions are always word-aligned.
```
also wenn du deine asm so Aussehen:
```
mov lr,pc
ldr pc,=cfun
```
erhalten Sie
```
d6008034:   e1a0e00f    mov lr, pc
d6008038:   e51ff000    ldr pc, [pc, #-0]   ; d6008040 
...
d6008040:   d60084c4    strle   r8, [r0], -r4, asr #9
```
Der assembler reserviert einen Speicherbereich, in Reichweite der ldr pc, Anleitung (wenn möglich, andernfalls ein Fehler generiert), wo wird es die vollständige 32-bit Adresse für die Anleitung. der linker später füllen Sie diese Adresse mit der externen Adresse. so dass Sie erreichen können jede beliebige Adresse im Adressraum.

wenn Sie nicht wollen, zu spielen assembler Spiele gerne und möchten kontrollieren können, dann erstellen Sie den Standort, um die Adresse der Funktion, und laden Sie es in den pc selbst:
```
    mov lr,pc
    ldr pc,cfun_addr

...

cfun_addr:
    .word cfun
```
zusammengestellt:
```
d6008034:   e1a0e00f    mov lr, pc
d6008038:   e51ff000    ldr pc, [pc, #-0]   ; d6008040 <cfun_addr>
...

d6008040 <cfun_addr>:
d6008040:   d60084c4    strle   r8, [r0], -r4, asr #9
```
Schließlich, wenn Sie wollen, sich zu bewegen in den modernen ARM-Welt, wo ARM und Daumen gemischt wird oder werden kann (z.B. Nutzung von bx-lr anstelle von mov pc,lr), dann werden Sie wollen, um zu verwenden, bx
```
    add lr,pc,#4
    ldr r1,cfun_addr
    bx r1
...

cfun_addr:
    .word cfun
```
natürlich brauchen Sie ein weiteres register, das zu tun, und denken Sie daran, push-und pop Ihre link-register und die anderen register vor und nach dem Aufruf von C, wenn Sie wollen, um Sie zu bewahren.
- Wenn Sie nicht bereits wissen, die Aufrufkonventionen, um zu wissen, was Register sind verwendet für die übergabe von Parametern zum Beispiel, eines von zwei Dingen tun, einige schreiben von C-code die Funktion aufrufen und zerlegen, um zu sehen, was der compiler getan hat. die richtige Antwort ist, um die Aufruf-Konvention, die andere haben darauf hingewiesen, dass Sie zu.
- und Sie sind richtig, ich nur zeigte, wie ARM-Anweisungen, die eine Funktion aufrufen, nicht zu haben, Daumen Anweisungen Aufruf einer C-Funktion, die ich Bearbeiten können, die Antwort-und zeigen Ihnen, wie Sie das auch tun...Sie Sprachen von einer Rinde Ein, so dass ich nehme an, Sie laufen arm-Anweisungen nicht Daumen für den größten Teil der Einnahme von Vorteil, die Leistung, die Sie haben und nicht einige bus-eingeschränkte Sache.
- Und als Brett genannten verschiebbaren Objekten kann es mehr kompliziert ist, würden Sie brauchen, um machen cfun_addr global, und wen lädt die verschiebbare Objekt ändern muss cfun_addr, bevor Sie es verwenden.
- Respekt old_timer!
InformationsquelleAutor old_timer
1

Müssen Sie die Spezifikationen für die armeabi-v7a bei der Beschreibung des call-stack, Register (aufgerufene vs. Anrufer), etc. Dann schauen Sie bei der Montage die Ausgabe von kompilierten C-code für syntax, etc. Die Dinge werden komplizierter, wenn Sie versuchen, um call-Funktionen in shared libraries oder verschiebbare Objekte.

InformationsquelleAutor Brett Hale
1

Minimal runnable armv7 Beispiel

Diese Frage kommt "was ist die ARM-Aufrufkonvention (AAPCS)". Ein Beispiel a.S:
```
/* Make the glibc symbols visible. */
.extern exit, puts
.data
    msg: .asciz "hello world"
.text
.global main
main:
    /* r0 is the first argument. */
    ldr r0, =msg
    bl puts
    mov r0, #0
    bl exit
```
Dann auf Ubuntu 16.04:
```
sudo apt-get install gcc-arm-linux-gnueabihf qemu-user-static
# Using GCC here instead of as + ld without arguments is needed
# because GCC knows where the C standard library is.
arm-linux-gnueabihf-gcc -o a.out a.S
qemu-arm-static -L /usr/arm-linux-gnueabihf a.out
```
Ausgabe:
```
hello world
```
Ist der einfachste Fehler zu machen in komplexeren Beispielen ist zu vergessen, dass der stack muss 8 byte ausgerichtet. E. g., Sie wollen:
```
push {ip, lr}
```
statt:
```
push {lr}
```
Beispiel auf GitHub mit der vorformulierten verallgemeinert: https://github.com/cirosantilli/arm-assembly-cheat/blob/82e915e1dfaebb80683a4fd7bba57b0aa99fda7f/c_from_arm.S
- Die OP war nicht gefragt, wie die Ausgabe Hallo Welt. Er wollte genannt C Funktion.
- nicht puts eine C-Funktion? 🙂
InformationsquelleAutor Ciro Santilli 新疆改造中心996ICU六四事件
-3

Wie Brett sagt, alles, was Sie wirklich tun müssen, ist, die richtigen Werte in den richtigen Registern, und branch-with-link zu der Funktion Adresse. Sie müssen sich bewusst sein, was registrieren Sie sich die kompilierte Funktion überschrieben wird, und welche Register es wiederherstellen, bevor es zurück -- das steht in der ABI-Dokumentation unter infocentre.arm.com. Sie müssen auch sicherstellen, dass die stack-register festgelegt ist, was der compiler erwartet, und vielleicht anderen Registern zu (für PIC-Modus?)

Aber wissen Sie wirklich brauchen, schreiben Sie den code in assembler-Dateien?

Wenn Sie mit dem GCC "asm" - Funktion, dann können Sie einbetten von assembler-Fragmente (solange Sie möchten) in die reguläre C-Funktionen, und fallen zurück in C, wenn es bequemer ist.

Gibt es Fälle, wo mit C gubbins um nicht tun, aber wenn Sie anrufen können C-Funktionen, die ich vermute, Sie sind nicht in diese.

Kommen, warum Sie benötigen, assembler an alle .... C ist im Grunde high-level assembler überhaupt?
- Wow, das war unbeliebt ... aber keiner sagt warum?
InformationsquelleAutor ams

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.