Version vom 1. März 2006, 16:27 Uhr

An diesem Artikel arbeitet gerade Mitglied SprinterSB.

Am besten momentan noch keine gravierenden Ergänzungen / Änderungen vornehmen.

Dieser Hinweis verschwindet wenn der Autor soweit ist. Sollte dieser Hinweis länger als drei Tage auf einer Seite sein, bitte beim Autor SprinterSB per PM / Mail oder Forum nachfragen ob er vergessen wurde.

In C versteht man unter Inline Assembler die Möglichkeit, direkt Assembler-Befehle in den Code einzufügen bzw. die eingefügten Assembler-Befehle selbst.

Neben den einzufügenden Befehlen muss beschrieben werden, welche Nebeneffekte die Befehle auf die Maschine haben und wo/wie Parameter übergeben werden, bzw. wie die Zuordnung von Variablen zu den Registern ist.

Obgleich das dazu verwendete Schlüsselwort __asm zum ANSI-C-Standard gehört, ist dies in jedem C-Compiler anders implementiert. Das gilt insbesondere für die Schnittstellenbeschreibung Variablen/Register. Dieser Artikel bezieht sich auf Inline Assembler von avr-gcc.

Begriffe

Assembler-Template: Das Template (Schablone) ist ein statischer, konstanter String im Sinne von C. Es enthält die Assembler-Befehle sowie Platzhalter, in deren Stelle später die Operanden treten
Constraint: Die Constraints (Nebenbedingungen) beschreiben Einschränkungen an die zu verwendeten Register. Dies ist notwendig, da nicht alle Maschinenbefehle auf alle Register anwendbar sind
Clobber-List: Das ist eine Liste von Registern, deren Inhalt durch den Inline-Assembler zerstört wird

Syntax und Semantik

Das Schlüsselwort, um eine Inline-Assembler Sequenz einzuleiten, ist __asm (ANSI). Oft ist auch asm oder __asm__ verwendbar. Um zu kennzeichnen, daß die Sequenz keinesfalls wegoptimiert werden darf – etwa dann, wenn der Assembler keine Wirkung auf C-Variablen hat – wird dem asm ein volatile bzw. __volatile nachgestellt. Danach folgen in runden Klammern die durch : getrennten Abschnitte des Inline-Assemblers:

asm volatile (asm-template : output-operand-list : input-operand-list : clobber-list);

Abschnitte, die leer sind, können auch weggelassen werden, wenn dahinter kein weiterer Abschnitt folgt:

asm volatile (asm-template);

Oder, wenn weder Input- noch Output-Operanden gebraucht werden, aber Register oder Speicher verändert werden:

asm volatile (asm-template ::: clobber-list);

Assembler-Template

Im Template stehen die durch Zeilenumbrüche getrennten Assembler-Befehle. Das Template kann zudem %-Ausdrücke als Platzhalter enthalten, welche durch die Operanden ersetzt werden. Dabei bezieht sich %0 auf den ersten Operanden, %1 auf den zweiten Operanden, etc. Die Operanden selbst werden im zweiten und dritten Abschnitt des Templates als Liste angegeben.

Ein Platzhalter kann zusätzlich einen einbuchstabigen Modifier enthalten, um ein Register in einem speziellen Format darzustellen. Wird z.B. ein 16-Bit-Wert in den Registern r31:r30 gehalten, dann wären folgende Ersetzungen denkbar (als erstes Argument):

%0 → r30

%A0 → r30

%B0 → r31

%a0 → y

Im einfachsten Falle enthält das Templater nur einen Befehl:

"nop"

oder sogar garkeinen Befehl und lediglich einen Kommentar:

"; ein Kommentar"

**Tabelle: asm-Platzhalter und ihre Modifier, Sonderzeichen**
Platzhalter	wird ersetzt durch
`%n`	Wird ersezt durch Argument `n` mit `n` = 0...9
`%An`	das erste (untere) Register des Arguments `n` (Bits 0...7)
`%Bn`	das zweite Register des Arguments `n` (Bits 8...15)
`%Cn`	das dritte Register des Arguments `n` (Bits 16...23)
`%Dn`	das vierte Register des Arguments `n` (Bits 24...31)
`%an`	Ausgabe des Arguments als Adress-Register, also als `x`, `y` bzw. `z`. Erlaubt zusammen mit Constraint `b`, `e`, `x`, `y`, `z`
`%~`	wird auf AVR mit Flash bis max. 8kByte durch ein `r` ersetzt, ansonsten bleibt es leer. Zum Aufbau von Sprungbefehlen, etwa "`%~call foo`"
`%=`	eine für dieses asm-Template und die Übersetzungseinheit eindeutige Zahl. Zum Aufbau lokaler Sprungmarken.
Sequenz	wird ersetzt durch Sonderzeichen
`%%`	das `%`-Zeichen selbst
`\n`	ein Zeilenumbruch zum Trennen mehrerer asm-Befehle/Zeilen
`\t`	ein TAB, zur Übersichtlichkeit im erzeugten asm
`\"`	ein `"` wird eingefügt
`\\`	das `\`-Zeichen selbst
Kommentar	Beschreibung
`; Text`	einzeiliger Kommentar bis zum Ende des Templates bzw. nächsten Zeilenumbruch
`/* Text */`	mehrzeiliger Kommentar wie in C

Operanden und Constraints

**Tabelle: Constraint Modifier**
Modifier	Bedeutung
`=`	der Operand ist Output-Operand
`&`	diesen Operanden nicht als Input-Operanden verwenden, sondern nur als Output-Operand

**Tabelle: Constraints und ihre Bedeutung**
Contraint	Register	Wertebereich	Contraint	Konstante	Wertebereich
`a`	einfache obere Register	`r16`...`r23`	`G`	Floatingpoint-Konstante	`0.0`
`b`	Pointer-Register	`y`, `z`	`i`	Konstante
`d`	obere Register	`r16`...`r31`	`I`	positive 6-Bit-Konstante	0...63
`e`	Pointer-Register	`x`, `y`, `z`	`J`	negative 6-Bit Konstante	`-`63...0
`l`	untere Register	`r0`...`r15`	`M`	8-Bit Konstante	0...255
`q`	Stack-Pointer	`SPH:SPL`
`r`	ein Register	`r0`...`r31`
`t`	Scratch-Register	`r0`
`w`	obere Register-Paare	`r24`, `r26`, `r28`, `r30`
`x`	Pointer-Register X	`x` (`r27:r26`)
`y`	Pointer-Register Y	`y` (`r29:r28`)
`z`	Pointer-Register Z	`z` (`r31:r30`)

**Tabelle: Übersicht AVR-Instruktionen und passende Constraints**
Mnemonic	Constraint	Mnemonic	Constraint	Mnemonic	Constraint	Mnemonic	Constraint
`adc`	`r,r`	`add`	`r,r`	`adiw`	`w,I`	`and`	`r,r`
`andi`	`d,M`	`asr`	`r`	`bclr`	`I`	`bld`	`r,I`
`brbc`	`I,label`	`brbs`	`I,label`	`bset`	`I`	`bst`	`r,I`
`cbi`	`I,I`	`cbr`	`d,I`	`com`	`r`	`cp`	`r,r`
`cpc`	`r,r`	`cpi`	`d,M`	`cpse`	`r,r`	`dec`	`r`
`elpm`	`t,z`	`eor`	`r,r`	`in`	`r,I`	`inc`	`r`
`ld`	`r,e`	`ldd`	`r,b`	`ldi`	`d,M`	`lds`	`r,label`
`lpm`	`t,z`	`lsl`	`r`	`lsr`	`r`	`mov`	`r,r`
`movw`	`r,r`	`mul`	`r,r`	`neg`	`r`	`or`	`r,r`
`ori`	`d,M`	`out`	`I,r`	`pop`	`r`	`push`	`r`
`rol`	`r`	`ror`	`r`	`sbc`	`r,r`	`sbci`	`d,M`
`sbi`	`I,I`	`sbic`	`I,I`	`sbiw`	`w,I`	`sbr`	`d,M`
`sbrc`	`r,I`	`sbrs`	`r,I`	`ser`	`d`	`st`	`e,r`
`std`	`b,r`	`sts`	`label,r`	`sub`	`r,r`	`subi`	`d,M`
`swap`	`r`

Clobbers

Vordefinierte Bezeichner und Makros

**Tabelle: vordefinierte Bezeichner/Makros**
Bezeichner	Bedeutung
`__SP_L__`	unteres Byte des Stack-Pointers, für `in` bzw. `out`
`__SP_H__`	oberes Byte des Stack-Pointers, für `in` bzw. `out`
`__SREG__`	Status-Register, für `in` bzw. `out`
`__tmp_reg__`	ein Register zur temporären Verwendung (`r0`)
`__zero_reg__`	ein Register, das 0 enthält (`r1`)
`lo8(const)`	die unteren 8 Bit der Konstanten `const`
`hi8(const)`	Bits 8...15 der Konstanten `const`
`hlo8(const)`	Bits 16...23 der Konstanten `const`
`hhi8(const)`	Bits 24...31 der Konstanten `const`

Beispiele

Quellen

Doku zur avr-libc
Doku zu avr-gcc
Quellen von gcc

Siehe auch

@@ Zeile 26: / Zeile 26: @@
 Im Template stehen die durch Zeilenumbrüche getrennten Assembler-Befehle. Das Template kann zudem <tt>%</tt>-Ausdrücke als Platzhalter enthalten, welche durch die Operanden ersetzt werden. Dabei bezieht sich <tt>%0</tt> auf den ersten Operanden, <tt>%1</tt> auf den zweiten Operanden, etc. Die Operanden selbst werden im zweiten und dritten Abschnitt des Templates als Liste angegeben.
-Ein Platzhalten kann zusätzlich einen einbuchstabigen Modifier enthalten, um ein Register in einem speziellen Format darzustellen. Wird z.B. ein 16-Bit-Wert in den Registern <tt>r31:r30</tt> gehalten, dann wären folgende Ersetzungen denkbar (als erstes Argument):
+Ein Platzhalter kann zusätzlich einen einbuchstabigen Modifier enthalten, um ein Register in einem speziellen Format darzustellen. Wird z.B. ein 16-Bit-Wert in den Registern <tt>r31:r30</tt> gehalten, dann wären folgende Ersetzungen denkbar (als erstes Argument):
 <center>
@@ Zeile 37: / Zeile 37: @@
 <tt>%a0&nbsp;&nbsp;&nbsp;&nbsp;&rarr;&nbsp;&nbsp;y&nbsp;&nbsp;</tt>
 </center>
+Im einfachsten Falle enthält das Templater nur einen Befehl:
+ "nop"
+oder sogar garkeinen Befehl und lediglich einen Kommentar:
+ "; ein Kommentar"
 <center>
@@ Zeile 81: / Zeile 86: @@
 ==Operanden und Constraints==
+<center>
+{| {{Blauetabelle}}
+|+ '''Tabelle: Constraint Modifier'''
+|- {{Hintergrund1}}
+!Modifier || Bedeutung
+|-
+|<tt>=</tt> || der Operand ist Output-Operand
+|-
+|<tt>&</tt> || diesen Operanden ''nicht'' als Input-Operanden verwenden,<br/>sondern nur als Output-Operand
+|}
+</center>
 <center>
@@ Zeile 103: / Zeile 120: @@
 |-
 |<tt>l</tt>||untere Register ||<tt>r0</tt>...<tt>r15</tt>
-|<tt>K</tt>||Konstante ||2
+|<tt>M</tt>||8-Bit Konstante ||0...255
 |-
 |<tt>q</tt>||Stack-Pointer ||<tt>SPH:SPL</tt>
-|<tt>L</tt>||Konstante ||0
+|colspan="3" rowspan="7"|&nbsp;
 |-
 |<tt>r</tt>||ein Register ||<tt>r0</tt>...<tt>r31</tt>
-|<tt>M</tt>||8-Bit Konstante ||0...255
 |-
 |<tt>t</tt>||Scratch-Register ||<tt>r0</tt>
-|<tt>N</tt>||Konstante ||<tt>-</tt>1
 |-
-|<tt>w</tt>||Obere Register-Paare ||<tt>r24</tt>, <tt>r26</tt>, <tt>r28</tt>, <tt>r30</tt>
+|<tt>w</tt>||obere Register-Paare ||<tt>r24</tt>, <tt>r26</tt>, <tt>r28</tt>, <tt>r30</tt>
-|<tt>O</tt>||Konstante ||8, 16, 24
 |-
 |<tt>x</tt>||Pointer-Register X ||<tt>x</tt> (<tt>r27:r26</tt>)
-|<tt>P</tt>||Konstante ||1
 |-
 |<tt>y</tt>||Pointer-Register Y ||<tt>y</tt> (<tt>r29:r28</tt>)
-|colspan="3"|&nbsp;
 |-
 |<tt>z</tt>||Pointer-Register Z ||<tt>z</tt> (<tt>r31:r30</tt>)
-|colspan="3"|&nbsp;
 |}
 </center>
@@ Zeile 135: / Zeile 146: @@
 !Mnemonic || Constraint ||rowspan="15"|&nbsp;
 !Mnemonic || Constraint ||rowspan="15"|&nbsp;
-!Mnemonic || Constraint ||rowspan="15"|&nbsp;
+!Mnemonic || Constraint
 |-
 | <tt>adc</tt>||<tt>r,r</tt>
@@ Zeile 208: / Zeile 219: @@
 |-
 | <tt>swap</tt>||<tt>r</tt>
-|colspan="9"|&nbsp;
+|colspan="8"|&nbsp;
 |}
 </center>

Inline-Assembler in avr-gcc: Unterschied zwischen den Versionen

Ansichten

Version vom 1. März 2006, 16:27 Uhr

Inhaltsverzeichnis

Begriffe

Syntax und Semantik

Assembler-Template

Operanden und Constraints

Clobbers

Vordefinierte Bezeichner und Makros

Beispiele

Quellen

Siehe auch

Navigationsmenü

Hauptthemen

Navigation

Suche

Werkzeuge

Meine Werkzeuge