第3章、嵌入式Linux C语言高级用法

Transcription

1 在上在本中, 读者将会学习嵌入式 Linux C 语言的高级用法, 这些在使用嵌入式 Linux C 开发的应用程序中是比较常见的 另外, 本也会讲解一些有关嵌入式 Linux C 程序可移植性问题 C 语言与汇编语言之间的混合编程 本主要内容 q 预处理 q C 语言中的内存分配 q 程序的可移植性考虑 嵌入式 Linux C 语言高级用法 q C 和汇编的接口

2 预处理 在本书的 2 中, 已介绍过编译过程中的预处理阶段 所谓预处理是指在进行编 译的一遍扫描 ( 词法扫描和语法分析 ) 之前所做的工作 预处理是 C 语言的一个重要 功能, 它由预处理程序负责完成 当编译一个程序时, 系统将自动调用预处理程序对程 序中以 # 号开头的预处理部分进行处理, 处理完毕后就可以进入源程序的编译阶段 C 语言提供了多种预处理功能, 如宏定义 文件包含 条件编译等 合理地使用预 处理功能编写的程序既便于阅读 修改 移植和调试, 也有利于模块化程序设计 本节 介绍最常用的几种预处理功能.1.1 预定义 在 C 语言源程序中允许用一个标识符来表示一串符号, 称为宏, 被定义为宏的标识 符称为宏名 在编译预处理时, 对程序中所有出现的宏名, 都用宏定义中的符号串去替 换, 这称为宏替换或宏展开 1. 预定义符号 在 C 语言中, 有一些预处理定义的符号串, 它们的值或者是字符串常量, 或者是十 进制数字常量, 通常在调试程序时用于输出源程序的各项信息, 如表.1 所示归纳了这 些预定义符号 表.1 预定义符号表 符号示例含义 FILE /home/david/hello.c 正在预编译的源文件名 LINE 5 文件当前行的行号 FUNCTION main 当前所在的函数名 DATE Mar 预编译文件的日期 TIME 2:04:12 预编译文件的时间 STDC 1 如果编译器遵循 ANSI C, 则值为 1 这些预定义符号通常可以在程序出错处理时应用 下面的程序显示了这些预定义符 号的基本用法 : int main() printf("the file is %s\n", FILE ); printf("the line is %d\n", LINE ); printf("the function is %s\n", FUNCTION ); printf("the date is %s\n", DATE ); 2

3 嵌入式 Linux C 语言高级用法 printf("the time is %s\n", TIME ); 要注意的是, 这些预定义符号中 LINE 和 STDC 是整数常量, 其他都是字符串常量, 该程序的输出结果如下所示 : The file is /home/david/hello.c The line is 5 The function is main The date is Mar The time is 2:08:42 2. 宏定义 以上是 C 语言中自带的预定义符号, 除此之外, 用户自己也可以编写宏定义 宏定 义是由源程序中的宏定义 #define 语句完成的 ; 而宏替换是由预处理程序自动完成的 在 C 语言中, 宏分为带参数和不带参数两种, 下面分别讲解这两种宏的定义和使用 1) 无参宏定义 无参宏的宏名 ( 也就是标识符 ) 后不带参数, 其定义的一般形式为 : #define 标识符字符串 # 表示这是一条预处理命令, 凡是以 # 开头的均为预处理命令 define 为宏定义命令 标识符为所定义的宏名 字符串可以是常数 表达式 格式串等 在前面介绍过的符号常量的定义就是一种无参宏定义 此外, 用户还可对程序中反 复使用的表达式进行宏定义, 例如 : #define M (y + ) 这样就定义了 M 的表达式为 (y + ), 在此后编写程序时, 所有的 (y + ) 都可由 M 代 替 而对源程序进行编译时, 将先由预处理程序进行宏代换, 即用 (y + ) 表达式去替换 所有的宏名 M, 然后再进行编译 : #define M (y + ) void main() int s, y; printf("input a number: "); scanf("%d", &y); s = 5 * M; printf("s = %d\n", s); 在上例程序中首先进行宏定义, 定义 M 表达式 (y + ), 在 s = 5 * M 中进行了宏 调用, 在预处理时经宏展开后该语句变为 : s = 5 *(y + ) 1

4 这里要注意的是, 在宏定义中表达式 (y + ) 两边的括号不能少, 否则该语句展开后 就成为如下形示 : s = 5 * y + 这样显然是错误的, 通常把这种现象叫做宏的副作用 对于宏定义还要说明以下几点 (1) 宏定义用宏名来表示一串符号, 在宏展开时又以该符号串取代宏名, 这只是一 种简单的替换, 符号串中可以包含任何字符, 可以是常数, 也可以是表达式, 预处理程 序对它不做任何检查 如有错误, 只能在编译已被宏展开后的源程序时发现 (2) 宏定义不是声明或语句, 在行末不必加分号, 如加上分号则连分号也一起替换 () 宏定义的作用域包括从宏定义命名起到源程序结束, 如要终止其作用域, 可使 用 #undef 命令来取消宏作用域, 例如 : #define PI func1() #undef PI func2() /* 表示 PI 只在 func1() 函数中有效, 在 func2() 函数中无效 */ (4) 宏名在源程序中若用引号括起来, 则预处理程序不对其进行宏替换 : #define OK 100 main() printf("ok"); 上例中定义宏名 OK 表示 100, 但在 printf 语句中 OK 被引号括起来, 因此不做宏替换 (5) 宏定义允许嵌套 在宏定义的符号串中可以使用已经定义的宏名, 在宏展开时 由预处理程序层层替换 (6) 习惯上宏名用大写字母表示, 以便与变量区别, 但也允许用小写字母表示 (7) 对输出格式做宏定义, 可以减少编写麻烦, 例如 : #define P printf #define D "%d\n" #define F "%f\n" void main() int a = 5, c = 8, e = 11; float b =.8, d = 9.7, f = 21.08; P(D F, a, b); P(D F, c, d); P(D F, e, f); 4

5 嵌入式 Linux C 语言高级用法 2) 带参宏定义 C 语言允许宏带有参数, 在宏定义中的参数称为形式参数, 在宏调用中的参数称为实际参数 对带参数的宏, 在调用中不仅要宏展开, 而且要用实参去替换形参 带参宏定义的一般形式为 : #define 宏名 ( 形参表 ) 字符串 在字符串中含有各个形参 带参宏调用的一般形式为 : 宏名 ( 实参表 ); 例如 : #define M(y) y + /* 宏定义 */ 若想调用以上宏, 可以采用如下方法 : K = M(5); /* 宏调用 */ 在宏调用时, 用实参 5 代替宏定义中的形参 y, 经预处理宏展开后的语句为 : K = 5 + 以下这段程序就是常见的比较两个数大小的宏表示 : #define MAX(a,b) (a > b)?a:b /* 宏定义 */ void main() int x = 10, y = 20, max; max = MAX(x, y); /* 宏调用 */ printf("max = %d\n", max); 上例程序的一行进行带参宏定义, 用宏名 MAX 表示条件表达式 (a > b)?a:b, 形参 a b 均出现在条件表达式中 在程序中 max = MAX(x, y); 为宏调用, 实参 x y 将替换形参 a b 宏展开后该语句为 max = (x > y)?x:y;, 用于计算 x y 中的大数 由于宏定义非常容易出错, 因此, 对于带参的宏定义有以下问题需要特别说明 (1) 在带参宏定义中, 宏名和形参表之间不能有空格出现 例如 : #define MAX(a, b) (a > b)?a:b 写为 : #define MAX (a, b) (a > b)?a:b 这将被认为是无参宏定义, 宏名 MAX 代表字符串 (a, b) (a > b)?a:b 宏展开时, 宏 调用语句 max = MAX(x, y); 将变为 max = (a, b) (a > b)?a:b(x, y);, 这显然是错误的 (2) 在带参宏定义中, 形式参数不分配内存单元, 因此不必做类型定义 这与函数 中的情况有所不同 在函数中, 形参和实参是两个不同的量, 各有自己的作用域, 调用 时要把实参值赋予形参, 进行值传递 而在带参宏中, 只是符号替换, 不存在值传递的 问题 1 5

6 () 在宏定义中的形参是标识符, 而宏调用中的实参可以是表达式, 例如 : #define SQ(y) (y)*(y) /* 宏定义 */ sq = SQ(a+1); /* 宏调用 */ 上例中一行为宏定义, 形参为 y; 而在宏调用中实参为 a+1, 是一个表达式, 在宏 展开时, 用 a + 1 替换 y, 再用 (y) * (y) 替换 SQ, 得到如下语句 : sq=(a+1)*(a+1); 这与函数的调用是不同的, 函数调用时要把实参表达式的值求出来再赋予形参, 而 宏代换中对实参表达式不进行计算直接照原样替换 (4) 在宏定义中, 字符串内的形参通常要用括号括起来以免出错 在上例中的宏定义中 (y) * (y) 表达式的 y 都用括号括起来, 因此结果是正确的 如果 去掉括号, 把程序改为以下形式 : #define SQ(y) y * y /* 宏定义无括号 */ sq = SQ(a + 1); /* 宏调用 */ 这是由于替换只做简单的符号替换而不做其他处理造成的, 在宏替换之后将得到以 下语句 : sq = a + 1 * a + 1; 这显然与题意相违背, 因此参数两边的括号是不能少的 其实, 宏定义即使在参数两边加括号还是不够的, 例如 : #define SQ(y) (y) * (y) /* 宏定义有括号 */ sq = 160 / SQ(a + 1); /* 宏调用依然出错 */ 读者可以分析一下宏调用语句, 在宏替换之后变为 : sq = 160 / (a + 1) * (a + 1); 由于 / 和 * 运算符优先级及结合性相同, 所以先计算 160 / (a + 1), 再将结果 与 (a + 1) 相乘, 所以程序运行的结果依然是错误的 那么, 究竟怎样进行宏定义才是正 确的呢? 下面是正确的宏定义 : #define SQ(y) ((y) * (y)) /* 正确的宏定义 */ sq = 160 / SQ(a + 1); /* 宏调用结果正确 */ 以上讨论说明, 对于宏定义不仅应在参数两侧加括号, 还应在整个符号串外加括号 带参宏和带参函数很相似, 但有本质上的不同 除上面已谈到的各点外, 把同一表 达式用函数处理与用宏处理的结果有可能是不同的 例如有以下两段程序, 一个程序是采用调用函数的方式来实现的 : /* 程序 1, 函数调用 */ int SQ(int y) /* 函数定义 */ Return (y * y); 6

7 嵌入式 Linux C 语言高级用法 void main() int i = 1; while (i <= 5) printf("%d ", SQ(i++)); /* 函数调用 */ 二个程序是采用宏定义的方式来实现的 : /* 程序 2, 宏定义 */ #define SQ(y) ((y)*(y)) /* 宏定义 */ void main() int i = 1; while (i <= 5) printf("%d ", SQ(i++)); /* 宏调用 */ 可以看到, 不管是形参 实参还是具体的表达是都是一样的, 但运行的结果却截然 不同函数调用的运行结果为 : 而宏调用的运行结果却是 : 这是为什么呢? 请读者先自己思考, 再看下面的分析 在一个程序中, 函数调用是把实参 i 的值传给形参 y 后自增 1, 然后输出函数值, 因而要循环 5 次, 输出 1~5 的平方值 在二个程序中, 宏调用时实参和形参只做会换, 因此 SQ(i++) 被替换为 ((i++) * (i++)) 在一次循环时, 由于在其计算过程中 i 值一直为 1, 两相乘的结果为 1, 然后 i 值两次自增 1, 变为 在二次循环时,i 值已有初值为, 同理相乘的结果为 9, 然后 i 再两次自增 1 变为 5 进入 次循环, 由于 i 值已为 5, 所以这将是最后一次循环 相乘的结果为 25 i 值再两次自增 1 变为 7, 不再满足循环条件, 停止循环 从以上分析, 可以看出, 函数调用和宏调用在形式上相似, 但在本质上是完全不同 的, 如表.2 所示总结了宏与函数的不同之处 表.2 宏与函数的不同之处 属性 #define 宏函数 处理阶段预处理阶段, 只是符号串的简单的替换编译阶段 代码长度 每次使用宏时, 宏代码都被插入到程序中 因此, 除了非常小的宏之外, 程序的长度都将被大幅增长 ( 除了 inline 函数之外 ) 函数代码只出现在一个地方, 每次使用这个函数, 都只调用那个地方的同一份代码 1 7

8 续表 属性 #define 宏函数 执行速度更快存在函数调用 / 返回的额外开销 (inline 函数除外 ) 操作符优先级 参数求值 参数类型 宏参数的求值是在所有周围表达式的上下文环境中, 除非它们加上括号, 否则邻近操作符的优先级可能会产生不可预料的结果 参数每次用于宏定义时, 它们都将重新求值 由于多次求值, 具有副作用的参数可能会产生不可预料的结果 宏与类型无关, 只要对参数的操作是合法的, 它可以适用于任何参数类型 函数参数只在函数调用时求值一次, 它的结果值传递给函数, 因此, 表达式的求值结果更容易预测 参数在函数被调用前只求值一次, 在函数中多次使用参数并不会导致多种求值问题, 参数的副作用不会造成任何特殊的问题 函数的参数与类型有关, 如果参数的类型不同, 就需要使用不同的函数, 即使它们执行的任务是相同的.1.2 文件包含 文件包含是 C 语言预处理程序的另一个重要功能, 文件包含命令行的一般形式为 : #include " 文件名 " 在前面我们已多次用此命令包含过库函数的头文件, 例如 : #include <stdio.h> #include <math.h> 文件包含语句的功能是把指定的文件插入该语句行位置, 从而把指定的文件和当前 的源程序文件连成一个源文件 在程序设计中, 文件包含是很有用的 一个大的程序可 以分为多个模块, 由多个程序员分别编写 有些公用的符号常量 宏 结构 函数等的 声明或定义可单独组成一个文件, 在其他文件的开头用包含命令包含该文件即可使用 这样就可避免在每个文件开头都去写那些公用量, 从而节省时间, 并减少出错 这里, 对文件包含命令还要说明以下几点 (1) 包含命令中的文件名可以用双引号括起来, 也可以用尖括号括起来, 例如以下 写法是允许的 : #include "stdio.h" #include <math.h> 但是这两种形式是有区别的 : 使用尖括号表示在系统头文件目录中去查找 ( 头文件 目录可以由用户来指定 ); 使用双引号则表示首先在当前的源文件目录中查找, 若未找到 才到系统头文件目录中去查找 用户编程时可根据自己文件所在的位置来选择某一种 形式 (2) 一个 include 命令只能指定一个被包含文件 ; 若有多个文件要包含, 则需用多个 include 命令 () 文件包含允许嵌套, 即在一个被包含的文件中又可以包含别的文件 8

9 嵌入式 Linux C 语言高级用法.1. 条件编译 预处理程序提供了条件编译的功能, 可以按不同的条件去编译不同的程序代码, 从而产生不同的目标代码文件, 这对于程序的移植和调试是很有用的 条件编译有 种形式, 下面分别介绍 1. 一种形式 条件编译的一种形式如下 : #ifdef 标识符程序段 1 #else 程序段 2 #endif 它的功能是, 如果标识符已被 #define 语句定义过, 则会编译程序段 1; 否则编译程 序段 2 如果没有程序段 2( 它为空 ), 本格式中的 #else 可以没有 例如有以下程序 : #include <stdio.h> #define NUM OK /* 宏定义 */ void main() struct stu int num; char *name; float score; *ps; ps = (struct stu*)malloc(sizeof(struct stu)); ps->num = 102; ps->name="david"; ps->score=92.5; #ifdef NUM /* 条件编译, 若定义了 NUM, 则打印以下内容 */ printf("number = %d\nscore = %f\n", ps->num, ps->score); #else /* 若没有定义 NUM, 则打印以下内容 */ printf("name=%s\n",ps->name); #endif free(ps); 该程序的运行结果为 : Number = 102 Score = 在程序中根据 NUM 是否被定义来决定编译哪一个 printf 语句 因为在程序的二行 中定义了宏 NUM, 因此应编译一个 printf 语句, 运行结果则为输出学号和成绩 1 9

10 在此程序中, 宏 NUM 是符号串 OK 的别名, 其实也可以为任何符号串, 甚至不给 出任何符号串, 如下所示 : #define NUM 这样也具有同样的意义 读者可以试着将本程序中的宏定义去掉, 看一下程序的运 行结果, 这种形式的条件编译通常用在调试程序中 在调试时, 可以将要打印的信息用 #ifdef DEBUG 语句包含起来, 这样在调试完成之后, 就可以直接去掉宏定义 #define DEBUG, 这样就可以做成产品的发布版本了 条件编译语句和宏定义语句一样, 在 #ifdef 语句后不能加分号 (;) 2. 二种形式 条件编译的二种形式如下 : #ifndef 标识符程序段 1 #else 程序段 2 #endif 与一种形式的区别是将 ifdef 改为 ifndef 它的功能是, 如果标识符未被 #define 语 句定义过, 则编译程序段 1; 否则编译程序段 2 这与一种形式的功能正好相反. 三种形式 条件编译的三种形式如下 : #if 常量表达式程序段 1 #else 程序段 2 #endif 它的功能是, 如常量表达式的值为真 ( 非 0), 则编译程序段 1; 否则编译程序段 2 因此, 可以使程序在不同条件下完成不同的功能 : #include <stdio.h> #define IS_CURCLE 1 void main() float c = 2, r, s; #if IS_CURCLE r = * c * c; printf("area of round is: %f\n",r); #else s = c * c; printf("area of square is: %f\n",s); #endif 10

11 嵌入式 Linux C 语言高级用法 本例中采用了三种形式的条件编译 在程序一行宏定义中, 将 IS_CURCLE 定义为 1, 因此在条件编译时, 只编译计算和输出圆面积的代码部分 上面介绍的程序的功能可以使用条件语句来实现 但是使用条件语句将会对整个源程序进行编译, 生成的目标代码程序很长, 也比较麻烦 采用条件编译, 则根据编译条件选择性地进行编译, 生成的目标程序较短, 尤其是在调试和发布不同版本时非常有用 C 语言中的内存分配 本节将讲解 C 语言程序中的内存分配的原理和方法 内存的使用是程序设计中需要 考虑的重要因素之一, 这不仅由于系统内存是有限的 ( 尤其在嵌入式系统中 ), 而且内存 分配也会直接影响到程序的效率.2.1 C 语言程序所占内存分类 一个由 C 语言编写的程序占用的内存分为以下几个部分 栈 (stack): 由编译器自动分配释放, 存放函数的参数值 局部变量的值 返回 地址等, 其操作方式类似于数据结构中的栈 堆 (heap): 一般由程序员动态分配 ( 调用 mallo() 函数 ) 和释放 ( 调用 free() 函 数 ), 若程序员不释放, 程序结束时可能由操作系统回收 数据段 (data): 存放的是全局变量 静态变量 常数 根据存放的数据, 数据 段又可以分成普通数据段 ( 包括可读可写 / 只读数据段, 存放静态初始化的全局 变量或常量 ) BSS 数据段 ( 存放未初始化的全局变量 ) 代码段 (code): 用于存放程序代码 下面的这段程序说明了不同类型的内存分配 : /*C 语言中数据的内存分配 */ int a = 0; /* 可读可写数据段 */ char *p1; /*BSS 段 */ void main() int b; /*b 在栈 */ char s[] = "abc"; /*s 在栈, abc 在常量去 */ char *p2; /*p2 在栈 */ char *p = "12456"; /* 在常量区,p 在栈 */ static int c =0; /* 可读可写数据段 */ p1 = (char *)malloc(10); /* 分配得来的 10 字节的区域在堆区 */ p2 = (char *)malloc(20); /* 分配得来的 20 字节的区域在堆区 */ /* 从常量区的 Hello World 字符串复制到刚分配到的堆区 */ strcpy(p1, "Hello World"); 1 11

12 .2.2 堆和栈的区别 堆和栈有以下区别 1. 申请方式栈 (stack) 是由系统自动分配的 例如, 声明函数中一个局部变量 int b;, 那么系统自动在栈中为 b 开辟空间 堆 (head) 需要程序员自己申请, 并在申请时指定大小 使用 C 语言中的 malloc() 函数的例子如下所示 : p1 = (char *)malloc(10); 2. 申请后系统的响应堆在操作系统中有一个记录空闲内存地址的链表, 当系统收到程序的申请时, 系统就会开始遍历该链表, 寻找一个空间大于所申请空间的堆节点, 然后将该节点从空闲节点链表中删除, 并将该节点的空间分配给程序 另外, 对于大多数系统, 会在这块内存空间中的首地址处记录本次分配的大小, 这样, 代码中的删除语句才能正确地释放本内存空间 如果找到的堆节点的大小与申请的大小不相同, 系统会自动地将多余的那部分重新放入空闲链表中 只要栈的剩余空间大于所申请空间, 系统将为程序提供内存 否则将报异常, 提示栈溢出. 申请大小的限制堆是向高地址扩展的数据结构, 是不连续的内存区域 这是由于系统用链表来存储的空闲内存地址是不连续的 ( 这一点在后一节中会有详细说明 ), 而链表的遍历方向是由低地址向高地址 堆的大小受限于计算机系统中有效的虚拟内存, 因此堆获得的空间比较灵活, 也比较大 栈是向低地址扩展的数据结构, 是一块连续的内存区域 因此, 栈顶的地址和栈的最大容量是系统预先规定好的, 如果申请的空间超过栈的剩余空间, 将提示栈溢出 因此, 能从栈获得的空间较小 4. 申请速度的限制堆是由 malloc() 等语句分配的内存, 一般速度比较慢, 而且容易产生内存碎片, 不过用起来很方便 栈由系统自动分配, 速度较快, 但程序员一般无法控制 5. 堆和栈中的存储内容堆一般在堆的头部用一字节存放堆的大小, 堆中的具体内容由程序员安排 在调用函数时, 一个进栈的是函数调用语句的下一条可执行语句的地址, 然后是函数的各个参数 在大多数 C 编译器中, 参数是由右往左入栈的, 然后是函数中的局部 12

13 嵌入式 Linux C 语言高级用法 变量 当本次函数调用结束后, 局部变量先出栈, 然后是参数, 最后栈顶指针指向最开 始的存储地址, 也就是调用该函数处的下一条指令, 程序由该点继续运行 程序的可移植性考虑 嵌入式开发很重要的一个问题就是可移植性的问题 Linux 是一个可移植性非常好的系统, 这也是嵌入式 Linux 能够迅速发展起来的一个主要原因 因此, 嵌入式 Linux 在可移植性方面所做的工作是非常值得学习的 本节结合嵌入式 Linux 实例来讲解嵌入式开发在可移植性方面需要考虑的问题..1 字长和数据类型 能够由机器一次完成处理的数据称为字, 不同体系结构的字长通常会有所区别, 如现在通用的处理器字长为 2 位 为了解决不同的体系结构有不同的字长问题, 在嵌入式 Linux 中存在两种数据类型, 其一是不透明数据类型, 其二是长度明确的数据类型 不透明数据类型隐藏了它们的内部格式或结构 在 C 语言中, 它们就像黑盒一样, 开发者们利用 typedef 声明一个类型, 把它叫做不透明数据类型, 并希望其他开发者不要重新将其转化为对应的那个标准 C 类型 例如用来保存进程标识符的 pid_t 类型的实际长度被隐藏起来了, 尽管任何人都可以揭开它的面纱, 其实它就是一个 int 型数据 长度明确的数据类型也非常常见 作为一个程序员, 通常在程序中需要操作硬件设备, 这时就必须明确数据的长度 嵌入式 Linux 内核在 <asm/types.h> 中定义了这些长度明确的类型, 如表. 所示为这些类型的完整说明 表. 类型说明 类型描述 s8 u8 s16 u16 s2 u2 s64 u64 带符号字节无符号字节带符号 16 位整数无符号 16 位整数带符号 2 位整数无符号 2 位整数带符号 64 位整数无符号 64 位整数 1 1

14 这些长度明确的数据类型大部分是通过 typedef 对标准的 C 类型进行映射得到的, 在嵌入式 Linux 中的 </asm-arm/types.h> 就有如下定义 : typedef _signed_ char _s8; typedef unsigned char _u8; typedef _signed_ short _s16; typedef unsigned short _u16; typedef _signed_ int _s2; typedef unsigned int _u2; typedef _signed_ long long _s64; typedef unsigned long long _u64;..2 数据对齐 对齐是内存数据与内存中的相对位置相关的话题 如果一个变量的内存地址正好是 它长度的整数倍, 它就被称做是自然对齐的 例如, 对于一个 2 位 (4 个字节 ) 类型的 数据, 如果它在内存中的地址刚好可以被 4 整除 ( 最低两位是 0), 那它就是自然对齐的 一些体系结构对对齐的要求非常严格 通常基于 RISC 的系统载入未对齐的数据会 导致处理器陷入 ( 一种可处理的错误 ); 还有一些系统可以访问没有对齐的数据, 但性能 会下降 编写可移植性高的代码要避免对齐问题, 保证所有的类型都能够自然对齐.. 字节顺序 字节顺序是指一个字中各个字节的顺序, 有大端模式和小端模式 大端模式是指在 这种格式中, 字数据的高字节存储在低地址中, 而字数据的低字节则存放在高地址中 小端模式与大端存储格式相反, 在小端存储格式中, 低地址中存放的是字数据的低字节, 而高地址存放的是字数据的高字节 模式 ARM 体系结构支持大端模式 (big-endian) 和小端模式 (little-endian) 两种内存 请看下面的一段代码, 通过该段代码我们可以查看一个字 ( 通常为 4 字节 ) 数据的 每个字节在内存中的分布情况, 即可以分辨出当前系统采用哪种字节顺序模式 typedef unsigned char byte; typedef unsigned int word; word val2 = 0x ; byte val8 = *((byte*)&val2); 这段代码在小端模式和大端模式下的运行结果分别为 val8 = 0x21 和 val8 = 0x87 其 实, 变量 val8 所在的地方是 val2 的低地址, 因此如 val8 值为 val2 的低字节 (0x21), 则本系统是小端模式 ; 如 val8 值为 val2 的高字节 (0x87), 则本系统是大端模式, 如 图.1 所示 这种功能也可以用 union 联合体来实现, 建议读者动手编程尝试一下 14

15 嵌入式 Linux C 语言高级用法 图.1 小端和大端模式 C 和汇编的接口 C 语言是一种优秀的中级语言, 它既可以实现高级语言的模块化编程, 又可以实现 很多底层的操作 但是, 与汇编语言相比,C 语言的效率毕竟还是无法与之相媲美的 因此, 在对效率或硬件操作要求比较高的地方, 可以采用将部分汇编语句嵌入到 C 语言 中的方式来进行 GCC 的内嵌式汇编语言提供了一种在 C 语言源程序中直接嵌入汇编指令的办法, 既 能够直接控制所形成的指令序列, 又有着与 C 语言的良好接口, 所以在 Linux 内核代码 中有很多地方都使用了这一语句 在内嵌汇编中, 可以将 C 语言表达式指定为汇编指令的操作数, 而且不用去管如何 将 C 语言表达式的值读入哪个寄存器, 以及如何将计算结果写回 C 变量 用户只要告诉 程序中 C 语言表达式与汇编指令操作数之间的对应关系即可,GCC 会自动插入代码完成 必要的操作.4.1 内嵌汇编的语法 在阅读 C/C++ 原代码时经常会遇到内联汇编的情况, 下面简要介绍一下 ARM 体系 结构下的 asm 内嵌汇编用法 带有 C/C++ 表达式的内联汇编格式为 : asm ( 汇编语句模板 : 输出部分 : 输入部分 : 破坏描述部分 ) _asm_ 是 GCC 关键字 asm 的宏定义 :_asm_ 或 asm 用来声明一个内联汇编表达式, 所以任何一个内联汇编表达式都是以它开头的, 是必不可少的, 如下所示 : #define _asm_ asm #define _volatile_ volatile 有时在 _asm_ 后面使用 _volatile_ _volatile_ 或 volatile 是可选的 如果用了它, 则是 向 GCC 声明不允许对该内联汇编优化 ; 否则当使用了优化选项 (-O) 进行编译时,GCC 将根据自己的判断决定是否对这个内联汇编表达式中的指令进行优化 1 15

16 内联汇编共由 4 个部分组成 : 汇编语句模板 输出部分 输入部分和破坏描述部分, 各部分使用 : 隔开 如果使用了后面的部分, 而前面部分为空, 也需要用 : 隔开, 相应部分内容为空, 例如 : _asm_("": : :"memory") 下面就分别对关键部分进行一一介绍 1. 汇编语言模板汇编语句模板由汇编语句序列组成, 语句之间使用 ; \n 或 \n\t 分开 它可以是空的, 比如 _asm volatile_(""); 或 _asm_ (""); 都是完全合法的内联汇编表达式, 只不过这两条语句没有什么意义 但并非所有汇编语句模板为空的内联汇编表达式都是没有意义的, 比如 :_asm_ ("":::"memory"); 就非常有意义, 它向 GCC 声明 : 内存做了改动, GCC 在编译的时候会将此因素考虑进去 当在汇编语句模板中有多条指令的时候, 可以在一对引号中列出全部指令, 也可以将一条或几条指令放在一对引号中, 所有指令放在多对引号中 如果是前者, 可以将每一条指令放在一行 ; 如果要将多条指令放在一行, 则必须用分号 (;) 或换行符 (\n) 将它们分开 以上可以综合概括为 : 每条指令都必须被双引号括起来 两条指令必须用换行或分号分开 指令中的操作数可以使用占位符引用 C 语言变量, 操作数占位符最多 10 个, 如为 %0,%1,...,%9 例如, 在 ARM 系统结构上关闭中断的操作 : int disable_interrupts(void) unsigned long old,temp; _asm volatile_("mrs %0, cpsr\n" "orr %1, %0, #0x80\n" "msr cpsr_c, %1" : "=r" (old), "=r" (temp) : : "memory"); return (old & 0x80) == 0; 2. 输出部分输出部分用来指定当前内联汇编语句的输出 例如, 从 ARM 协处理器 p15 中读出 c1 值 : static unsigned long read_p15_c1 (void) unsigned long value; asm volatile_( 16

17 嵌入式 Linux C 语言高级用法 "mrcp15, 0, %0, c1, c0, read control reg\n" : "=r" 编译器选择一个 R* 寄存器 : : "memory"); #ifdef MMU_DEBUG printf ("p15/c1 is = %08lx\n", value); #endif return value; 输出部分描述输出操作数, 不同的操作数描述符之间用逗号隔开, 每个操作数描述 符由限定字符串和 C 语言变量组成 每个输出操作数的限定字符串必须包含 =, 表示 它是一个输出操作数 限定字符串表示对该变量的限制条件, 这样 GCC 就可以根据这些 条件决定如何分配寄存器, 如何产生必要的代码处理指令操作数与 C 表达式或 C 变量之 间的联系. 输入部分 输入部分用来指定当前内联汇编语句的输入, 每个操作数描述符由限定字符串和 C 语言表达式或者 C 语言变量组成, 格式为形如 "constraint" (variable) 的列表 ( 不同的操作 数描述符之间使用逗号隔开 ) 例如, 向 ARM 协处理器 p15 中写入 C1 值 : static void write_p15_c1 (unsigned long value) #ifdef MMU_DEBUG printf ("write %08lx to p15/c1\n", value); #endif _asm volatile_( "mcrp15, 0, %0, c1, c0, write it back\n" : : "r" 编译器选择一个 R* 寄存器 : "memory"); 4. 破坏描述部分 有时候, 我们想通知 GCC 当前内联汇编语句可能会对某些寄存器或内存进行修改, 希望 GCC 在编译时能够将这一点考虑进去, 那么就可以在破坏描述部分声明这些寄存器 或内存 这种情况一般发生在 : 一个寄存器出现在汇编语句模板中, 但不是由输入 / 输出 部分操作表达式所指定的, 也不是在一些输入 / 输出操作表达式使用 r 约束时由 GCC 为其选择的 ; 同时此寄存器被汇编语句模板中的指令修改, 而这个寄存器只是供当前内 联汇编临时使用的情况 例如 : _asm_ ("mov R0, #0x4" : : : "R0"); 1 17

18 寄存器 R0 出现在汇编语句模板, 并且被 mov 指令修改, 但未被任何输入 / 输出部分 操作表达式指定, 所以需要在破坏描述部分指定 R0, 以让 GCC 知道这一点 因为在输入 / 输出部分操作表达式所指定的寄存器, 或为一些输入 / 输出部分操作表 达式使用 r 约束, 让 GCC 为自己选择一个寄存器时,GCC 对这些寄存器是非常清 楚的 它知道这些寄存器是被修改的, 我们根本不需要在破坏描述部分再声明它们 但除此之外,GCC 对剩下的寄存器中哪些会被当前的内联汇编修改一无所知 所以如果 真的在当前内联汇编指令中修改了它们, 那么最好在破坏描述部分中声明它们, 让 GCC 针对这些寄存器做相应的处理 ; 否则有可能会造成寄存器的不一致, 从而造成程序执行 错误 如果一个内联汇编语句的破坏描述部分存在 memory, 那么 GCC 会保护内存数据 如果在此内联汇编之前某个内存的内容被装入了寄存器, 那么在这个内联汇编之后, 当 需要使用这个内存中的内容时, 就会直接到这个内存中重新读取, 而不是使用被存放在 寄存器中的备份, 因为这个时候寄存器中的备份已经很可能和内存中的内容不一致了 这只是使用 memory 时 GCC 会保证做到的一点, 但这并不是全部 因为使用 memory 是向 GCC 声明内存发生了变化, 而内存发生变化带来的影响并不止这一点 例如 : int main(int _argc, char* _argv[]) int* _p = (int*)_argc; (*_p) = 9999; _asm_("":::"memory"); if((*_p) == 9999) return 5; return (*_p); 本例中, 如果没有那条内联汇编语句, 则 if 语句的判断条件就完全是多余的 GCC 在优化时会意识到这一点, 直接只生成 return 5 的汇编代码, 而不会再生成 if 语句的相 关代码, 也不会生成 return (*_p) 的相关代码 但如果加上了这条内联汇编语句, 它除了 声明内存变化之外, 什么都没有做 但因为内存变量可能发生变化,GCC 就不能简单地 认为它不需要判断就知道 (*_p) 一定与 9999 相等, 它只有老老实实生成这条 if 语句的汇 编代码, 一起相关的两个 return 语句相关代码 另外, 在 Linux 内核中内存屏障也是基于它实现的 在 <include/asm/system.h> 中 : # define barrier() _asm_volatile_("": : :"memory") memory 可能是内嵌汇编中比较难懂的部分 为解释清楚它, 先介绍一下编译器 的优化知识, 再看 C 关键字 volatile 18

19 嵌入式 Linux C 语言高级用法.4.2 编译器优化介绍 由于内存访问速度远不及 CPU 处理速度, 为提高机器整体性能, 在硬件上引入硬件高速缓存 Cache, 加速对内存的访问 另外, 在现代 CPU 中指令的执行并不一定严格按照顺序执行, 没有相关性的指令可以乱序执行, 以充分利用 CPU 的指令流水线, 提高执行速度 以上是硬件级别的优化 软件级别的优化有两种 : 一种是在编写代码时由程序员优化, 另一种是由编译器进行优化 编译器优化常用的方法有 : 将内存变量缓存到寄存器和调整指令顺序充分利用 CPU 指令流水线等, 常见的是重新排序读写指令 对常规内存进行优化的时候, 这些优化是透明的, 而且效率很好 由编译器优化或者硬件重新排序引起的问题的解决办法是在以特定顺序执行的操作之间设置内存屏障 (memory barrier), Linux 提供了一个宏用于解决编译器的执行顺序问题 : void barrier(void) 主要是保证程序的执行遵循顺序一致性 有时候写代码的顺序不一定是最终执行的顺序, 这是和处理器有关的 这个函数通知编译器插入一个内存屏障, 但对硬件无效, 编译后的代码会把当前 CPU 寄存器中的所有修改过的数值存入内存, 需要这些数据的时候再重新从内存中读出.4. C 语言关键字 volatile C 语言关键字 volatile( 注意它是用来修饰变量而不是上面介绍的 volatile ) 表明某个变量的值可能随时被外部改变 ( 如外设端口寄存器值 ), 因此对这些变量的存取不能缓存到寄存器, 每次使用时需要重新读取 该关键字在多线程环境下经常使用, 因为在编写多线程的程序时, 同一个变量可能被多个线程修改, 而程序通过该变量同步各个线程 对于 C 编译器来说, 它并不知道这个值会被其他线程修改, 自然就把它缓存到寄存器里面 volatile 的本意是指这个值可能会在当前线程外部被改变, 此时编译器知道该变量的值会在外部改变, 因此每次访问该变量时会重新读取 这个关键字在外设接口编程中经常会使用.4.4 memory 描述符 有了上面的知识就不难理解 memory 修改描述符了,memory 描述符告知 GCC 以下内容 不要将该段内嵌汇编指令与前面的指令重新排序, 也就是说在执行内嵌汇编代码之前, 它前面的指令都执行完毕 不要将变量缓存到寄存器, 因为这段代码可能会用到内存变量, 而这些内存变 1 19

20 量会以不可预知的方式发生改变, 因此 GCC 插入必要的代码前先将缓存到寄存器的变量值写回内存, 如果后面又访问这些变量, 则需要重新访问内存 如果汇编指令修改了内存, 但是 GCC 本身却察觉不到, 因为在输出部分没有描述, 此时就需要在修改描述部分增加 memory, 告诉 GCC 内存已经被修改,GCC 得知这个信息后, 就会在这段指令之前插入必要的指令将前面因为优化 Cache 而缓存到寄存器中的变量值先写回内存, 如果以后又要使用这些变量, 则再重新读取 当然, 使用 volatile 也可以达到这个目的 本小结 本主要介绍了嵌入式 Linux C 语言的高级用法, 包括一些重要的话题, 如预处理 内存分配 程序的移植性考虑及 C 语言与汇编语言之间的混合编程等 这些在使用嵌入式 Linux C 开发的应用程序中都是常见的 在本中重点讲述了一些在嵌入式 Linux C 语言中常见的基本问题和高级问题, 希望读者熟练掌握每个小节的基本知识点 本习题 1. 宏定义和函数之间有哪些区别, 宏定义 inline 函数有区别吗? 2. 请具体分析 hello.c 程序的预处理之后的代码. 简述 C 语言的各种数据如何在内存中分配, 它们分别对程序的运行效率有哪些影响 4. 与程序的移植性相关的问题有哪些? 怎么能写出平台无关或者移植性很强的程序? 20

21 嵌入式 Linux C 语言高级用法 5. 在 ARM 目标板的某个 GPIO 端口上连续进行写操作 ( 交替进行写 0 和写 1 的操作 ), 以便观察 I/O 端口的工作频率 分别用纯 C 语言和内嵌汇编的 C 语言编写该功能代码, 并比较两种方法的运行效率 资源分享 : 1 华清远见精品图书专区 : 2 华清远见嵌入式 Linux 视频下载基地 : 华清远见近期免费活动公告 : 4 华清远见学员大本营 : 联系我们 : 免费电话 : , 华清远见集团官网 : 华清远见企业学院 : 华清远见嵌入式学院 : 华清远见 G 学院 : 1 21