|
关于这篇文档这篇文章是本人为方便各位业界同仁而翻译，方便大家开发底层代码使用，转载请注明出处，谢谢。要是你E文功底好，本人还是建议阅读E文版的。 对于基于ARM的RISC处理器，GNU C编译器提供了在C代码中内嵌汇编的功能。这种非常酷的特性提供了C代码没有的功能，比如手动优化软件关键部分的代码、使用相关的处理器指令。 这里设想了读者是熟练编写ARM汇编程序读者，因为该片文档不是ARM汇编手册。同样也不是C语言手册。 这篇文档假设使用的是GCC 4 的版本，但是对于早期的版本也有效。 GCC asm 声明让我们以一个简单的例子开始。就像C中的声明一样，下面的声明代码可能出现在你的代码中。 /* NOP 例子 */& i) ?1 m' o& k# \: n1 p, V
asm("mov r0,r0");
/ I6 c7 I3 w" ^9 \# ?% ~
- Y# P% M# L8 p/ Q |
该语句的作用是将r0移动到r0中。换句话讲他并不干任何事。典型的就是NOP指令，作用就是短时的延时。 请接着阅读和学习这篇文档，因为该声明并不像你想象的和其他的C语句一样。内嵌汇编使用汇编指令就像在纯汇编程序中使用的方法一样。可以在一个asm声明中写多个汇编指令。但是为了增加程序的可读性，最好将每一个汇编指令单独放一行。 asm(
9 d. L. i+ b# M! H% V"mov r0, r0\n\t"( d+ S' r7 {: X! c
"mov r0, r0\n\t"
2 t2 h/ X* v9 G/ _- g- S7 `"mov r0, r0\n\t"
! Y" y( Y+ c2 p: N; M4 x# ]"mov r0, r0"- g% t0 G" i+ I
);% W: t7 {3 ^. j6 e
7 n7 g( x6 d( x7 v& g% H: |
|
换行符和制表符的使用可以使得指令列表看起来变得美观。你第一次看起来可能有点怪异，但是当C编译器编译C语句的是候，它就是按照上面（换行和制表）生成汇编的。到目前为止，汇编指令和你写的纯汇编程序中的代码没什么区别。但是对比其它的C声明，asm的常量和寄存器的处理是不一样的。通用的内嵌汇编模版是这样的。 asm(code : output operand list : input operand list : clobber list); |
汇编和C语句这间的联系是通过上面asm声明中可选的output operand list和input operand list。Clobber list后面再讲。 下面是将C语言的一个整型变量传递给汇编，逻辑左移一位后在传递给C语言的另外一个整型变量。 /* Rotating bits example */
4 x6 g" V6 z3 Uasm("mov %[result], %[value], ror #1" : [result] "=r" (y) : [value] "r" (x));; d+ C: ~- y3 f& v/ a. p) a7 c
! O. C a& A" [0 L9 I7 \
|
每一个asm语句被冒号（:）分成了四个部分。 l 汇编指令放在第一部分中的“”中间。 "mov %[result], %[value], ror #1" |
l 接下来是冒号后的可选择的output operand list，每一个条目是由一对[]（方括号）和被他包括的符号名组成，它后面跟着限制性字符串，再后面是圆括号和它括着的C变量。这个例子中只有一个条目。 l 接着冒号后面是输入操作符列表，它的语法和输入操作列表一样 l 破坏符列表，在本例中没有使用 就像上面的NOP例子，asm声明的4个部分中，只要最尾部没有使用的部分都可以省略。但是有有一点要注意的是，上面的4个部分中只要后面的还要使用，前面的部分没有使用也不能省略，必须空但是保留冒号。下面的一个例子就是设置ARM Soc的CPSR寄存器，它有input但是没有output operand。 asm("msr cpsr,%[ps]" : : [ps]"r"(status)) |
即使汇编代码没有使用，代码部分也要保留空字符串。下面的例子使用了一个特别的破坏符，目的就是告诉编译器内存被修改过了。这里的破坏符在下面的优化部分在讲解。 为了增加代码的可读性，你可以使用换行，空格，还有C风格的注释。 asm("mov %[result], %[value], ror #1"
! J# d/ s1 G' u* P8 O1 U, G t3 I' E0 s+ e6 r# G5 P
: [result]"=r" (y) /* Rotation result. */% C7 D) p& o% S( z; v
: [value]"r" (x) /* Rotated value. */
9 f& a0 `+ `$ g : /* No clobbers */
; l/ t( N5 ]2 v& h); |
在代码部分%后面跟着的是后面两个部分方括号中的符号，它指的是相同符号操作列表中的一个条目。 %[result]表示第二部分的C变量y，%[value]表示三部分的C变量x； 符号操作符的名字使用了独立的命名空间。这就意味着它使用的是其他的符号表。简单一点就是说你不必关心使用的符号名在C代码中已经使用了。在早期的C代码中，循环移位的例子必须要这么写： asm("mov %0, %1, ror #1" : "=r" (result) : "r" (value)) |
在汇编代码中操作数的引用使用的是%后面跟一个数字，%1代表第一个操作数，%2代码第二个操作数，往后的类推。这个方法目前最新的编译器还是支持的。但是它不便于维护代码。试想一下，你写了大量的汇编指令的代码，要是你想插入一个操作数，那么你就不得不从新修改操作数编号。 优化C代码有两种情况决定了你必须使用汇编。1st，C限制了你更加贴近底层操作硬件，比如，C中没有直接修改程序状态寄存器（PSR）的声明。2nd就是要写出更加优化的代码。毫无疑问GNU C代码优化器做的很好，但是他的结果和我们手工写的汇编代码相差很远。 这一部分有一点很重要，也是被别人忽视最多的就是：我们在C代码中通过内嵌汇编指令添加的汇编代码，也是要被C编译器的优化器处理的。让我们下面做个试验来看看吧。 下面是代码实例。 bigtree@just:~/embedded/basic-C$ arm-linux-gcc -c test.c bigtree@just:~/embedded/basic-C$ arm-linux-objdump -D test.o 编译器选择r3作为循环移位使用。它也完全可以选择为每一个C变量分配寄存器。Load或者store一个值并不显式的进行。下面是其它编译器的编译结果。 E420A0E1 mov r2, r4, ror #1 @ y, x |
编译器为每一个操作数选择一个相应的寄存器，将操作过的值cache到r4中，然后传递该值到r2中。这个过程你能理解不？ 有的时候这个过程变得更加糟糕。有时候编译器甚至完全抛弃你嵌入的汇编代码。C编译器的这种行为，取决于代码优化器的策略和嵌入汇编所处的上下文。如果在内嵌汇编语句中不使用任何输出部分，那么C代码优化器很有可能将该内嵌语句完全删除。比如NOP例子，我们可以使用它作为延时操作，但是对于编译器认为这影响了程序的执行速速，认为它是没有任何意义的。 上面的解决方法还是有的。那就是使用volatile关键字。它的作用就是禁止优化器优化。将NOP例子修改过后如下： /* NOP example, revised */
# c% `7 p/ ?( q6 Sasm volatile("mov r0, r0");3 `* [4 |9 Y0 X
% T T% @& {- d) @) z
|
下面还有更多的烦恼等着我们。一个设计精细的优化器可能重新排列代码。看下面的代码： i++;
0 a; U6 F2 M* _! a5 `5 Y# sif (j == 1)
1 Q$ j$ _' t& A/ L6 a* t/ J( zx += 3;" T0 Z: y) c# a5 I, c. a8 |% R
i++; |
优化器肯定是要从新组织代码的，两个i++并没有对if的条件产生影响。更进一步的来讲，i的值增加2，仅仅使用一条ARM汇编指令。因而代码要重新组织如下： if (j == 1)# J+ T2 p# L8 i% J/ u
x += 3;; I# h& ?9 s+ E* P
i += 2; |
这样节省了一条ARM指令。结果是：这些操作并没有得到许可。 这些将对你的代码产生很到的影响，这将在下面介绍。下面的代码是c乘b，其中c和b中的一个或者两个可能会被中断处理程序修改。进入该代码前先禁止中断，执行完该代码后再开启中断。 asm volatile("mrs r12, cpsr\n\t"; f; Z# L; \. \! }0 y
"orr r12, r12, #0xC0\n\t" w P, O4 w% ] v3 _ F
"msr cpsr_c, r12\n\t" ::: "r12", "cc");
6 O) W4 Q, d' Xc *= b; /* This may fail. */
+ [! |5 {# [% P2 jasm volatile("mrs r12, cpsr\n"+ @6 D. o, r' M% x. p( K
"bic r12, r12, #0xC0\n"0 {; W1 T1 z, ]5 U8 `
"msr cpsr_c, r12" ::: "r12", "cc"); |
但是不幸的是针对上面的代码，优化器决定先执行乘法然后执行两个内嵌汇编，或相反。这样将会使得我们的代码变得毫无意义。 我们可以使用clobber list帮忙。上面例子中的clobber list如下： 上面的clobber list将会将向编译器传达如下信息，修改了r12和程序状态寄存器的标志位。Btw，直接指明使用的寄存器，将有可能阻止了最好的优化结果。通常你只要传递一个变量，然后让编译器自己选择适合的寄存器。另外寄存器名，cc（condition registor 状态寄存器标志位），memory都是在clobber list上有效的关键字。它用来向编译器指明，内嵌汇编指令改变了内存中的值。这将强迫编译器在执行汇编代码前存储所有缓存的值，然后在执行完汇编代码后重新加载该值。这将保留程序的执行顺序，因为在使用了带有memory clobber的asm声明后，所有变量的内容都是不可预测的。 asm volatile("mrs r12, cpsr\n\t"# G/ @4 \) i, Z! h4 p
"orr r12, r12, #0xC0\n\t"
7 i5 j( V9 G( Z "msr cpsr_c, r12\n\t" :: : "r12", "cc", "memory");* T. ~* A; Q4 X, O) I% ]4 `
c *= b; /* This is safe. *// I" }' o2 q+ D9 Y3 P# l; m M
asm volatile("mrs r12, cpsr\n" u. m# W& G& H" j5 `, k
"bic r12, r12, #0xC0\n"0 |& d8 G4 K! S; N0 `, {
"msr cpsr_c, r12" ::: "r12", "cc", "memory");
" |7 g* f! w: T' H9 v( i$ k1 k% f- {) K4 e- ?# N7 ^
|
使所有的缓存的值都无效，只是局部最优（suboptimal）。你可以有选择性的添加dummy operand 来人工添加依赖。 asm volatile("mrs r12, cpsr\n\t"
7 J' _5 u( {% N4 h: g9 a2 R "orr r12, r12, #0xC0\n\t"
# n! w( X' q! f0 |3 d "msr cpsr_c, r12\n\t" : "=X" (b) :: "r12", "cc");
; u, P, g: d9 s0 B Oc *= b; /* This is safe. */, V+ H# T/ n. Y) I2 D5 u. z
asm volatile("mrs r12 |
上面的第一个asm试图修改变量先b，第二个asm试图修改c。这将保留三个语句的执行顺序，而不要使缓存的变量无效。 理解优化器对内嵌汇编的影响很重要。如果你读到这里还是云里雾里，最好是在看下个主题之前再把这段文章读几遍^_^。 Input and output operands前面我们学到，每一个input和output operand，由被方括号[]中的符号名，限制字符串，圆括号中的C表达式构成。 这些限制性字符串有哪些，为什么我们需要他们？你应该知道每一条汇编指令只接受特定类型的操作数。例如：跳转指令期望的跳转目标地址。不是所有的内存地址都是有效的。因为最后的opcode只接受24位偏移。但矛盾的是跳转指令和数据交换指令都希望寄存器中存储的是32位的目标地址。在所有的例子中，C传给operand的可能是函数指针。所以面对传给内嵌汇编的常量、指针、变量，编译器必须要知道怎样组织到汇编代码中。 对于ARM核的处理器，GCC 4 提供了一下的限制。 Constraint | Usage in ARM state | Usage in Thumb state | f | Floating point registers f0 .. f7 | Not available | h | Not available | Registers r8..r15 | G | Immediate floating point constant | Not available | H | Same a G, but negated | Not available | I | Immediate value in data processing instructions
, h3 q/ i Q p5 @6 s8 @- re.g. ORR R0, R0, #operand | Constant in the range 0 .. 255
8 D1 r- E+ {0 ?9 u* m7 Fe.g. SWI operand | J | Indexing constants -4095 .. 4095
7 p+ E! z! F) Z1 pe.g. LDR R1, [PC, #operand] | Constant in the range -255 .. -1: v( A* z+ m8 x5 ]
e.g. SUB R0, R0, #operand | K | Same as I, but inverted | Same as I, but shifted | L | Same as I, but negated | Constant in the range -7 .. 7
: V/ e5 B, m/ Ae.g. SUB R0, R1, #operand | l | Same as r | Registers r0..r7
8 g" L" C/ U. \6 }0 |' ^$ Ge.g. PUSH operand | M | Constant in the range of 0 .. 32 or a power of 2; t5 z! r2 r4 Z- R c
e.g. MOV R2, R1, ROR #operand | Constant that is a multiple of 4 in the range of 0 .. 1020
) Z! ]7 R$ D; q* S: @' @e.g. ADD R0, SP, #operand | m | Any valid memory address | N | Not available | Constant in the range of 0 .. 31
' R4 k( z' e1 E3 ye.g. LSL R0, R1, #operand | O | Not available | Constant that is a multiple of 4 in the range of -508 .. 5089 i: N7 _ l1 \4 H; W' J
e.g. ADD SP, #operand | r | General register r0 .. r159 r2 t5 H0 F9 u" F& j+ Z# [$ D$ w8 y
e.g. SUB operand1, operand2, operand3 | Not available | w | Vector floating point registers s0 .. s31 | Not available | X | Any operand |
限制字符可能要单个modifier指示。要是没有modifier指示的默认为read-only operand。 Modifier | Specifies | = | Write-only operand, usually used for all output operands | + | Read-write operand, must be listed as an output operand | & | A register that should be used for output only |
Output operands必须为write-only，相应C表达式的值必须是左值。Input operands必须为read-only。C编译器是没有能力做这个检查。 比较严格的规则是：不要试图向input operand写。但是如果你想要使用相同的operand作为input和output。限制性modifier（+）可以达到效果。例子如下： asm("mov %[value], %[value], ror #1" : [value] "+r" (y)) |
+ O& |4 S4 o+ G& [( {% E
和上面例子不一样的是，最后的结果存储在input variable中。 可能modifier + 不支持早期的编译器版本。庆幸的是这里提供了其他解决办法，该方法在最新的编译器中依然有效。对于input operators有可能使用单一的数字n在限制字符串中。使用数字n可以告诉编译器使用的第n个operand，operand都是以0开始计数。下面是例子： asm("mov %0, %0, ror #1" : "=r" (value) : "0" (value)) |
; U3 M5 J c* F$ ^
限制性字符串“0”告诉编译器，使用和第一个output operand使用同样input register。 请注意，在相反的情况下不会自动实现。如果我没告诉编译器那样做，编译器也有可能为input和output选择相同的寄存器。第一个例子中就为input和output选择了r3。 在多数情况下这没有什么，但是如果在input使用前output已经被修改过了，这将是致命的。在input和output使用不同寄存器的情况下，你必须使用&modifier来限制output operand。下面是代码示例： asm volatile("ldr %0, [%1]" "\n\t"+ a' s+ S& Y) }, T5 ~
"str %2, [%1, #4]" "\n\t" ! x- Q F5 [9 L
: "=&r" (rdv) ( l$ A3 S* u' d" N, ^. `% ?
: "r" (&table), "r" (wdv)
/ S, @7 p( s/ o& q# m# g : "memory");
T: c& \2 \( I6 ^! o
- y8 R+ i: ]: q: t; D3 G7 ~# J |
( |" M% y$ b9 K1 y; |
在以张表中读取一个值然后在写到该表的另一个位置。 其他内嵌汇编作为预处理宏要是经常使用使用部分汇编，最好的方法是将它以宏的形式定义在头文件中。使用该头文件在严格的ANSI模式下会出现警告。为了避免该类问题，可以使用__asm__代替asm，__volatile__代替volatile。这可以等同于别名。下面就是个例程： #define BYTESWAP(val) \ ( }+ q, I: X6 P' y- @/ w& X) V+ V7 r
__asm__ __volatile__ ( \4 u9 R1 C" @5 `* Y" w; L
"eor r3, %1, %1, ror #16\n\t" \
$ |4 D4 X4 X( x# I2 o# l "bic r3, r3, #0x00FF0000\n\t" \. [4 D9 F6 K% S$ \) [
"mov %0, %1, ror #8\n\t" \4 W7 L! v! t0 p8 o& Y/ k& t
"eor %0, %0, r3, lsr #8" \- z7 r# |) x4 w/ c
: "=r" (val) \
% K: U* g3 d* C9 g/ k( u! F : "0"(val) \: p" G6 }* b; @' s/ Y
: "r3", "cc" \
1 b' T2 e i3 {% [ ); |
C 桩函数宏定义包含的是相同的代码。这在大型routine中是不可以接受的。这种情况下最好定义个桩函数。 unsigned long ByteSwap(unsigned long val)
2 l; Z h# S$ ]# o, d) \{
! I, D, j: z. _( p' q4 S" z! Oasm volatile (
/ l0 u6 w* T# l6 n! a' t "eor r3, %1, %1, ror #16\n\t"" {! F! J0 K- o" v
"bic r3, r3, #0x00FF0000\n\t"9 ?$ v2 a+ C! E" {5 \7 g
"mov %0, %1, ror #8\n\t"
$ F3 _. P) N" G1 l+ z( o v0 c k "eor %0, %0, r3, lsr #8". P* f! r$ Y% {6 y! [" S e- M8 P: W
: "=r" (val)
8 M: [, O' H0 B1 y& C : "0"(val)! e; Z3 ^/ W2 Y( A% w1 s2 I$ E
: "r3"
2 M0 G8 O! a/ T n4 a- T8 j);
5 g9 {# x. i: t$ w! m9 l0 q: P- b5 a$ ]return val;
3 B% ` c) a' z) ]} |
替换C变量的符号名默认的情况下，GCC使用同函数或者变量相同的符号名。你可以使用asm声明，为汇编代码指定一个不同的符号名 unsigned long value asm("clock") = 3686400 |
: Y2 H3 i0 \5 A0 I
这个声明告诉编译器使用了符号名clock代替了具体的值。 替换C函数的符号名为了改变函数名，你需要一个原型声明，因为编译器不接受在函数定义中出现asm关键字。 extern long Calc(void) asm ("CALCULATE") |
% y/ k+ u# ]' R# L3 Z调用函数calc()将会创建调用函数CALCULATE的汇编指令。 强制使用特定的寄存器局部变量可能存储在一个寄存器中。你可以利用内嵌汇编为该变量指定一个特定的寄存器。 void Count(void) {3 v/ ?5 V5 F* @" i1 m1 t) o3 e
register unsigned char counter asm("r3");3 O9 [' _; L8 ?
0 C6 _$ x6 u. y1 s" r' e5 j) o7 s... some code...( q9 X* o" O: s5 J, a9 n
asm volatile("eor r3, r3, r3");( l" T H1 ~$ g- s
... more code...4 R/ b' ?7 V! u* c2 P: P
}* H9 U1 [/ {3 u
{. D, H1 j3 } v |
6 H" o; h% R$ h: A% Q0 A7 `9 P6 \; A
汇编指令“eor r3, r3, r3”，会将r3清零。Waring：该例子在到多数情况下是有问题的，因为这将和优化器相冲突。因为GCC不会预留其它寄存器。要是优化器认为该变量在以后一段时间没有使用，那么该寄存器将会被再次使用。但是编译器并没有能力去检查是否和编译器预先定义的寄存器有冲突。如果你用这种方式指定了太多的寄存器，编译器将会在代码生成的时候耗尽寄存器的。 临时使用寄存器如果你使用了寄存器，而你没有在input或output operand传递，那么你就必须向编译器指明这些。下面的例子中使用r3作为scratch 寄存器，通过在clobber list中写r3，来让编译器得知使用该寄存器。由于ands指令跟新了状态寄存器的标志位，使用cc在clobber list中指明。 asm volatile(: \5 T9 c8 M* M$ P
"ands r3, %1, #3" "\n\t"
" Y% S' }- |1 q% {7 b+ g "eor %0, %0, r3" "\n\t"- ^8 |9 @3 ], z, z. ]
"addne %0, #4" & M: o) v' @( }! g
: "=r" (len) 5 V5 N/ I+ B* n) p- f* w
: "0" (len)
! M- n- m9 w" `2 ] : "cc", "r3"
' U! f% E0 Z3 O );( W( U# f! O3 S! S
+ ~8 ^0 R: ]3 `* g
|
最好的方法是使用桩函数并且使用局部临时变量。 寄存器的用途比较好的方法是分析编译后的汇编列表，并且学习C 编译器生成的代码。下面的列表是编译器将ARM核寄存器的典型用途，知道这些将有助于理解代码。 Register | Alt. Name | Usage | r0 | a1 | First function argument9 g! |3 v8 B# t! x) X% Q" p: c6 @
Integer function result0 Q" d- T+ }. Z1 s' C
Scratch register | r1 | a2 | Second function argument
! |. t7 _, w' N# \Scratch register | r2 | a3 | Third function argument, ~, ?5 v, k* z% P( r2 Q# j/ q2 {
Scratch register | r3 | a4 | Fourth function argument
* J- q0 a B$ nScratch register | r4 | v1 | Register variable | r5 | v2 | Register variable | r6 | v3 | Register variable | r7 | v4 | Register variable | r8 | v5 | Register variable | r9 | v6
2 }) B3 o- R; Qrfp | Register variable
7 f+ p$ ]: }2 j9 B- c' h1 bReal frame pointer | r10 | sl | Stack limit | r11 | fp | Argument pointer | r12 | ip | Temporary workspace | r13 | sp | Stack pointer | r14 | lr | Link register, K0 B+ F, C5 x* [. V' z$ s* g* P
Workspace | r15 | pc | Program counter 0 ]' ` z1 |, k F
9 C8 `- P" n$ M- z$ R, X2 R
|
) T/ `0 A8 ^7 _; N3 {
|
|一淘宝店|手机版|商店|电子DIY套件|一乐电子
( 粤ICP备09076165号 )
粤公网安备 44522102000183号
发表于 2016-12-18 16:13
发表于 2016-12-20 18:55
楼主