Inline-Assembler in avr-gcc - Versionsgeschichte

SprinterSB: /* Quellen */ linkfix

2014-10-25T11:38:34Z

‎Quellen: linkfix

SprinterSB: /* Fallstricke */

2014-09-13T11:09:54Z

‎Fallstricke

SprinterSB_alt: /* Beispiel: Multiplikation aus Atmels Application Note */ Entfernt da kein Mehrwert. Zudem erzeugt der Compiler diesen Code auch ohne Inline Assembler (sogar besser)

2012-12-09T12:57:55Z

‎Beispiel: Multiplikation aus Atmels Application Note: Entfernt da kein Mehrwert. Zudem erzeugt der Compiler diesen Code auch ohne Inline Assembler (sogar besser)

SprinterSB_alt: /* Syntax und Semantik */ asm goto

2012-12-09T12:55:08Z

‎Syntax und Semantik: asm goto

SprinterSB_alt: /* Assembler-Template */ %-Syntax

2012-12-04T18:19:10Z

‎Assembler-Template: %-Syntax

SprinterSB_alt: /* Quellen */ avr-gcc im GCC wiki

2012-10-29T22:46:57Z

‎Quellen: avr-gcc im GCC wiki

SprinterSB_alt: /* Assembler-Template */ %r

2012-10-29T21:42:26Z

‎Assembler-Template: %r

SprinterSB_alt: /* Bits zählen */ -volatile

2012-10-18T21:54:41Z

‎Bits zählen: -volatile

SprinterSB_alt: /* swap Bytes */ Kein volatile, entferne eor-Beispiel

2012-10-18T21:36:16Z

‎swap Bytes: Kein volatile, entferne eor-Beispiel

SprinterSB_alt: /* swap Nibbles */

2012-10-18T21:33:39Z

‎swap Nibbles

@@ Zeile 776: / Zeile 776: @@
 ;GCC-Quellen:
-* [http://gcc.gnu.org/viewcvs/trunk/gcc/config/avr/avr.md?content-type=text%2Fplain&view=co ./gcc/config/avr/avr.md]
+* [http://gcc.gnu.org/viewcvs/gcc/trunk/gcc/config/avr/avr.md?content-type=text%2Fplain&view=co ./gcc/config/avr/avr.md]
-* [http://gcc.gnu.org/viewcvs/trunk/gcc/config/avr/constraints.md?content-type=text%2Fplain&view=co ./gcc/config/avr/constraints.md]
+* [http://gcc.gnu.org/viewcvs/gcc/trunk/gcc/config/avr/constraints.md?content-type=text%2Fplain&view=co ./gcc/config/avr/constraints.md]
 =Siehe auch=

@@ Zeile 758: / Zeile 758: @@
 * Um die Sonderzeichen <tt>"%~"</tt> und <tt>"%="</tt> benutzen zu können, muss bei parameterlosen Inline Assembler dem Template ein Doppelpunkt folgen:
 :<pre>asm volatile ("%~call some_function" :);</pre>
 =Quellen=

← Nächstältere Version		Version vom 9. Dezember 2012, 12:57 Uhr
Zeile 600:		Zeile 600:
	Alternativ können wir wie bei [[#swap Nibbles\|swap Nibbles]] eine lokale Variable verwenden, und alles als (inline-)Funktion machen.		Alternativ können wir wie bei [[#swap Nibbles\|swap Nibbles]] eine lokale Variable verwenden, und alles als (inline-)Funktion machen.

−	~~== Beispiel: Multiplikation aus Atmels Application Note ==~~

−	~~Das ist die ursprüngliche Routine mul16x16_32 aus Atmels Application Note ''AVR201: Using the AVR Hardware Multiplier'':~~
−
−	~~<pre>~~
−	;***************************************************************************
−	;*
−	~~;* FUNCTION~~
−	~~;* mul16x16_32~~
−	~~;* DECRIPTION~~
−	~~;* Unsigned multiply of two 16bits numbers with 32bits result.~~
−	~~;* USAGE~~
−	~~;* r19:r18:r17:r16 = r23:r22 * r21:r20~~
−	~~;* STATISTICS~~
−	~~;* Cycles : 17 + ret~~
−	~~;* Words : 13 + ret~~
−	~~;* Register usage: r0 to r2 and r16 to r23 (11 registers)~~
−	~~;* NOTE~~
−	~~;* Full orthogonality i.e. any register pair can be used as long as~~
−	~~;* the 32bit result and the two operands does not share register pairs.~~
−	~~;* The routine is non-destructive to the operands.~~
−	;*
−	;***************************************************************************
−
−	~~.global mul16x16_32~~
−	~~mul16x16_32:~~
−	~~clr r2~~
−	~~mul r23, r21 ; ah * bh~~
−	~~movw r19:r18, r1:r0~~
−	~~mul r22, r20 ; al * bl~~
−	~~movw r17:r16, r1:r0~~
−	~~mul r23, r20 ; ah * bl~~
−	~~add r17, r0~~
−	~~adc r18, r1~~
−	~~adc r19, r2~~
−	~~mul r21, r22 ; bh * al~~
−	~~add r17, r0~~
−	~~adc r18, r1~~
−	~~adc r19, r2~~
−	~~ret~~
−	~~</pre>~~
−
−	Es folgt eine "Übersetzung" dieser Routine für avr-gcc. Der Vorteil besteht darin, dass der Compiler die Registerzuordnung an den umliegenden C-Code anpassen kann. Daher müssen keine Register umkopiert werden. Die o.g. Bedingung, daß keiner der Input-Operanden den Output-Operand überlappen darf, wird erreicht durch das early-clobber <tt>&</tt> des Outputs. avr-gcc legt alle Variablen, die größer als 8 Bits sind, beginnend in einer geraden Registernummer ab; Diese Bedingung ist also automatisch erfüllt.
−
−	~~Register R1 (<tt>__zero_reg__</tt>) enthält bei avr-gcc immer den Wert 0; daher muss dieser Wert nach dem Inline-Assembler wieder in diesem Register stehen.~~
−
−	~~<pre>~~
−	~~#include <stdint.h>~~
−
−	~~static inline uint32_t~~
−	~~mul_unsigned_16x16_32 (uint16_t operand_1, uint16_t operand_2)~~
−	{
−	~~uint32_t result;~~
−
−	~~#if __AVR_HAVE_MUL__~~
−
−	~~// Kein "asm volatile" so dass der Compiler dies wegoptimieren kann~~
−	~~// wenn das Ergebnis nicht verwendet wird.~~
−	~~// Code basierend auf mul16x16_32 Routine aus Atmels Application Note~~
−	~~// "AVR201: Using the AVR Hardware Multiplier".~~
−
−	~~asm ("mul %B[op_1], %B[op_2] ; high(op_1) * high(op_2) \n\t"~~
−	~~"movw %C[result], r0 \n\t"~~
−
−	~~"mul %A[op_1], %A[op_2] ; low(op_1) * low(op_2) \n\t"~~
−	~~"movw %A[result], r0 ; 16-bit move: r0 -> rD \n\t"~~
−
−	~~"mul %B[op_1], %A[op_2] ; high(op_1) * low(op_2) \n\t"~~
−	~~"add %B[result], r0 \n\t"~~
−	~~"adc %C[result], r1 \n\t"~~
−	~~"clr __zero_reg__ \n\t"~~
−	~~"adc %D[result], __zero_reg__ \n\t"~~
−
−	~~"mul %B[op_2], %A[op_1] ; high(op_2) * low(op_1) \n\t"~~
−	~~"add %B[result], r0 \n\t"~~
−	~~"adc %C[result], r1 \n\t"~~
−	~~"clr __zero_reg__ \n\t"~~
−	~~"adc %D[result], __zero_reg__"~~
−
−	~~: [result] "=&r" (result) // output operand~~
−	~~: [op_1] "r" (operand_1), [op_2] "r" (operand_2) // input operands~~
−	);
−
−	~~#else~~
−
−	~~// Kein Hardware-Multiplier verfuegbar.~~
−	~~result = (uint32_t) operand_1 * operand_2;~~
−
−	~~#endif // __AVR_HAVE_MUL__~~
−
−	~~return result;~~
−	}
−	~~</pre>~~
−
−	;Anmerkung: Ab Version 4.7 kann avr-gcc die entsprechende Optimierung selbst ausführen, d.h. die Input-Operanden werden nicht zu 32-Bit Variablen erweitert. Der entsprechende C-Code ist dann wie folgt, und man braucht keinen Inline-Assembler mehr zu bemühen:
−	~~:{\|~~
−	\|-
−	~~\|<pre>~~
−	~~static inline uint32_t~~
−	~~mul_unsigned_16x16_32 (uint16_t operand_1, uint16_t operand_2)~~
−	{
−	~~return (uint32_t) operand_1 * operand_2;~~
−	}
−	~~</pre>~~
−	\|}

	== Zugriff auf SFRs ==		== Zugriff auf SFRs ==

@@ Zeile 31: / Zeile 31: @@
 Aus Compiler-Sicht werden die Assembler-Befehle im Template parallel, also ''gleichzeitig'' ausgeführt! Dies ist zu bedenken, wenn Register sowohl als Input als auch als Output verwendet werden.
 }}
 == Assembler-Template ==
@@ Zeile 421: / Zeile 424: @@
 und stellt es dadurch wieder her.
 }}
 =Vordefinierte Bezeichner und Makros=

@@ Zeile 34: / Zeile 34: @@
 == Assembler-Template ==
-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 Komma-getrennte Liste angegeben.
+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.
-Ein Platzhalter kann zusätzlich einen einbuchstabigen Modifier enthalten, um ein Register in einem speziellen Format darzustellen. Wird z.B. ein Wert ab Register <tt>r28</tt> (dem Y-Register) gehalten, dann wären folgende Ersetzungen denkbar (als erstes Argument):
+Ein Platzhalter kann zusätzlich einen einbuchstabigen Modifier enthalten, um den Operanden in printf-ähnlicher Manier in einem speziellen Format darzustellen. Wird z.B. ein Wert ab Register <tt>r28</tt> (dem Y-Register) gehalten, dann wären folgende Ersetzungen denkbar (als erstes Argument):
 :<tt>%0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&rarr;&nbsp;&nbsp;r28</tt>
@@ Zeile 49: / Zeile 53: @@
 Im einfachsten Falle enthält das Templater nur einen Befehl:
   "nop"
-oder sogar garkeinen Befehl und lediglich einen Kommentar:
+oder sogar garkeinen Befehl oder lediglich einen Kommentar:
   "; ein Kommentar"

@@ Zeile 811: / Zeile 811: @@
 * AVR-LibC: [http://nongnu.org/avr-libc/user-manual/inline_asm.html ''Inline Assembler Cookbook'']
 * GCC: [http://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html ''Assembler Instructions with C Expression Operands'']
 * GCC: [http://gcc.gnu.org/onlinedocs/gcc/Constraints.html ''Constraints for <tt>asm</tt> Operands'']

@@ Zeile 73: / Zeile 73: @@
 |-  valign="top"
 |<tt>%i''n''</tt> || Ab 4.7. Ausgabe einer RAM-Adresse als I/0-Adresse. Beispiel: <tt>0x30</tt> wird auf Xmega-Controllern als <tt>0x30</tt> ausgegeben und auf nicht-Xmega als <tt>0x10</tt>.
 |align="center"| '''X'''
 |- valign="top"

@@ Zeile 765: / Zeile 765: @@
     unsigned char count;
-    asm volatile (
+    asm (
        "clr %0"                "\n"
        "0:"                    "\n\t"

@@ Zeile 505: / Zeile 505: @@
 Werden Zahlen zwischen verschiedenen Plattformen übertragen, kann es sein, daß diese unterschiedlich dargestellt werden: Das low-Byte kann in sich im unteren Byte befinden (AVR), es kann aber auch im oberen Byte sein. Ist das so, dann müssen die Werte beim Senden/Empfang umgewandelt werden, indem die Bytes getauscht werden. Liegt der 16-Bit-Wert in <tt>x_in</tt> und soll der konvertierte Wert nach <tt>x_out</tt> gespeichert werden, dann könnte man auf die Idee kommen, so etwas zu schreiben:
 <pre>
-    asm volatile (
+    asm (
        "mov %A0, %B1"   "\n\t"
        "mov %B0, %A1"
@@ Zeile 525: / Zeile 525: @@
 Mit den beiden Bytes geht es aber nicht. Wir müssen daher kennzeichnen, daß sich <tt>x_out</tt> in einem Register befindet, das ''nur'' als Output dient, was durch das <tt>&</tt> in der Output-Constraint erreicht wird:
 <pre>
-    asm volatile (
+    asm (
        "mov %A0, %B1"   "\n\t"
        "mov %B0, %A1"
@@ Zeile 538: / Zeile 538: @@
 </pre>
-Alternativ können wir wie bei [[#swap Nibbles|swap Nibbles]] eine lokale Variable verwenden, und alles als (inline-)Funktion machen. In dem folgenden Beispiel wird ein etwas anderer Code zum Tauschen verwendet:
+Alternativ können wir wie bei [[#swap Nibbles|swap Nibbles]] eine lokale Variable verwenden, und alles als (inline-)Funktion machen.
-<pre>
-static inline unsigned short swap_16 (unsigned short x_in)
-−
-   asm volatile (
-      "eor %A0, %B0"   "\n\t"
-      "eor %B0, %A0"   "\n\t"
-      "eor %A0, %B0"
-         : "=r" (x_in)
-         : "0"  (x_in)
-   );
-−
-   return x_in;
-−
-</pre>
-Die <tt>eor</tt>-Sequenz tauscht die Inhalte von <tt>r24</tt> und <tt>r25</tt>. Sie ist genauso schnell und knapp wie ein "Dreiecks-Tausch", kommt aber ohne Hilfsregister aus. Nachrechnen, es stimmt!
-<pre>
-       	eor	r24, r25
-       	eor	r25, r24
-       	eor	r24, r25
-</pre>
 == Beispiel: Multiplikation aus Atmels Application Note ==

@@ Zeile 484: / Zeile 484: @@
      ...
-Dazu verwenden wir eine lokale Variable <tt>__x__</tt>, in die der ursprüngliche Wert <tt>x</tt> gesichert wird:
+Dazu verwenden wir eine lokale Variable <tt>_x_</tt>, in die der ursprüngliche Wert <tt>x</tt> gesichert wird:
 <pre>
 #define swap(x)                                            \