c防止编译器优化指令

1. volatile 可以用来修饰函数返回值吗

1.直接修饰C函数，方便编译器进行优化

我们会在一些代码中用volatile关键字来修饰函数，如linux0.12的源代码中就有这样的语句：

在linux的source code（linux/mm/memory.c)中有这样两句：

volatile void do_exit(long code);
static inline volatile void oom(void)
{
printk("out of memory ");
do_exit(SIGSEGV);
}

那么这里的volatile是什么意思呢？查了很多资料，都是说volatile对变量作用的结果，很少谈及对函数名修饰的作用。

其实这里的作用是帮助编译器进行优化，而不是防止编译器优化，对应oom()和do_exit()函数而言，它们是永远都不会返回的，如果还将调用它们的函数的返回地址保存在堆栈上的话，是没有任何意义的，

但是加了volatile过后，就意味着这个函数不会返回，就相当于告诉编译器，我调用后是不用保存调用我的函数的返回地址的。这样就达到了优化的作用。

这种优化来源于GCC，在GCC2.5版本以后，使用noreturn属性来做优化，如void
fatal () __attribute__
((noreturn));，但是在Gcc2.5的版本以前，没有noreturn属性，所以就用volatile来表示不会返回的函数，以此达到优化的效果。

2.修饰嵌入式汇编，防止编译器进行优化

例如，我们有如下的函数：

以下附上，volatile的一般作用：

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：
1). 并行设备的硬件寄存器（如：状态寄存器）
2). 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
3). 多线程应用中被几个任务共享的变量
回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。嵌入式系统程序员经常同硬件、中断、RTOS等等打交道，所用这些都要求volatile变量。不懂得volatile内容将会带来灾难。
假设被面试者正确地回答了这是问题（嗯，怀疑这否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。
1). 一个参数既可以是const还可以是volatile吗？解释为什么。
2). 一个指针可以是volatile 吗？解释为什么。
3). 下面的函数有什么错误：
int square(volatile int *ptr)
{
return *ptr * *ptr;
}
下面是答案：
1). 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
2). 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
3). 这段代码的有个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：
int square(volatile int *ptr)
{
int a,b;
a = *ptr;
b = *ptr;
return a * b;
}
由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：
long square(volatile int *ptr)
{
int a;
a = *ptr;
return a * a;
}

讲讲我的理解： （欢迎打板子...~~！）
关键在于两个地方：
1. 编译器的优化 (请高手帮我看看下面的理解)
在本次线程内, 当读取一个变量时，为提高存取速度，编译器优化时有时会先把变量读取到一个寄存器中；以后，再取变量值时，就直接从寄存器中取值；
当变量值在本线程里改变时，会同时把变量的新值到该寄存器中，以便保持一致
当变量在因别的线程等而改变了值，该寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致
当该寄存器在因别的线程等而改变了值，原变量的值不会改变，从而造成应用程序读取的值和实际的变量值不一致
举一个不太准确的例子：
发薪资时，会计每次都把员工叫来登记他们的银行卡号；一次会计为了省事，没有即时登记，用了以前登记的银行卡号；刚好一个员工的银行卡丢了，已挂失该银行卡号；从而造成该员工领不到工资
员工 －－ 原始变量地址
银行卡号 －－ 原始变量在寄存器的备份
2. 在什么情况下会出现(如1楼所说)
1). 并行设备的硬件寄存器（如：状态寄存器）
2). 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
3). 多线程应用中被几个任务共享的变量
补充： volatile应该解释为“直接存取原始内存地址”比较合适，“易变的”这种解释简直有点误导人；
“易变”是因为外在因素引起的，象多线程，中断等，并不是因为用volatile修饰了的变量就是“易变”了，假如没有外因，即使用volatile定义，它也不会变化；
而用volatile定义之后，其实这个变量就不会因外因而变化了，可以放心使用了； 大家看看前面那种解释（易变的）是不是在误导人
－－－－－－－－－－－－简明示例如下：－－－－－－－－－－－－－－－－－－
volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。
使用该关键字的例子如下：
int volatile nVint;
>>>>当要求使用volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。
例如：
volatile int i=10;
int a = i;
...
//其他代码，并未明确告诉编译器，对i进行过操作
int b = i;
>>>>volatile
指出
i是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，因而编译器生成的汇编代码会重新从i的地址读取数据放在b中。而优化做法是，由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读的数据放在b中。而不是重新从i里面读。这样以来，如果i是一个寄存器变量或者表示一个端口数据就容易出错，所以说volatile可以保证对特殊地址的稳定访问。
>>>>注意，在vc6中，一般调试模式没有进行代码优化，所以这个关键字的作用看不出来。下面通过插入汇编代码，测试有无volatile关键字，对程序最终代码的影响：
>>>>首先，用classwizard建一个win32 console工程，插入一个voltest.cpp文件，输入下面的代码：
>>
＃i nclude <stdio.h>
void main()
{
int i=10;
int a = i;
printf("i= %d",a);
//下面汇编语句的作用就是改变内存中i的值，但是又不让编译器知道
__asm {
mov dword ptr [ebp-4], 20h
}
int b = i;
printf("i= %d",b);
}
然后，在调试版本模式运行程序，输出结果如下：
i = 10
i = 32
然后，在release版本模式运行程序，输出结果如下：
i = 10
i = 10
输出的结果明显表明，release模式下，编译器对代码进行了优化，第二次没有输出正确的i值。下面，我们把 i的声明加上volatile关键字，看看有什么变化：
＃i nclude <stdio.h>
void main()
{
volatile int i=10;
int a = i;
printf("i= %d",a);
__asm {
mov dword ptr [ebp-4], 20h
}
int b = i;
printf("i= %d",b);
}
分别在调试版本和release版本运行程序，输出都是：
i = 10
i = 32
这说明这个关键字发挥了它的作用！
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
volatile对应的变量可能在你的程序本身不知道的情况下发生改变
比如多线程的程序，共同访问的内存当中，多个程序都可以操纵这个变量
你自己的程序，是无法判定合适这个变量会发生变化
还比如，他和一个外部设备的某个状态对应，当外部设备发生操作的时候，通过驱动程序和中断事件，系统改变了这个变量的数值，而你的程序并不知道。
对于volatile类型的变量，系统每次用到他的时候都是直接从对应的内存当中提取，而不会利用cache当中的原有数值，以适应它的未知何时会发生的变化，系统对这种变量的处理不会做优化——显然也是因为它的数值随时都可能变化的情况。
--------------------------------------------------------------------------------
典型的例子
for ( int i=0; i<100000; i++);
这个语句用来测试空循环的速度的
但是编译器肯定要把它优化掉，根本就不执行
如果你写成
for ( volatile int i=0; i<100000; i++);
它就会执行了
volatile的本意是“易变的”
由于访问寄存器的速度要快过RAM，所以编译器一般都会作减少存取外部RAM的优化。比如：
static int i=0;
int main(void)
{
...
while (1)
{
if (i) dosomething();
}
}
/* Interrupt service routine. */
void ISR_2(void)
{
i=1;
}
程序的本意是希望ISR_2中断产生时，在main当中调用dosomething函数，但是，由于编译器判断在main函数里面没有修改过i，因此
可能只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致dosomething永远也不会被
调用。如果将将变量加上volatile修饰，则编译器保证对此变量的读写操作都不会被优化（肯定执行）。此例中i也应该如此说明。
一般说来，volatile用在如下的几个地方：
1、中断服务程序中修改的供其它程序检测的变量需要加volatile；
2、多任务环境下各任务间共享的标志应该加volatile；
3、存储器映射的硬件寄存器通常也要加volatile说明，因为每次对它的读写都可能由不同意义；
另外，以上这几种情况经常还要同时考虑数据的完整性（相互关联的几个标志读了一半被打断了重写），在1中可以通过关中断来实
现，2中可以禁止任务调度，3中则只能依靠硬件的良好设计了。

2. 怎么指定某段代码不被编译器优化掉

在c语言中， 某些语句，如：
int a；
a = 0；
a = 1；
a =2； 这个可能编译器会把前面两句给优惠掉， 这个如果 前面两句也是必须要执行的， 可以把 int a 改成 volatile int a。
在编译的时候， 编译器可能会预测到某个变量的值， 就把中间的没有必要的语句给优化掉，volatile 关键字就是告诉编译器，不要做这样的预测性优化， 按照文本代码来翻译。

3. C语言编程问题 *volatile....

volatile就是不要让编译器优化这个变量。读写变量的时候直接对内存操作。如果优化了，会先读取寄存器的值，（这样就有可能和内存中的值不一样了）。常用于多线程变量，中断变量等

4. 如何防止因编译器开启优化，而导致程序执行错误

我的经验是：未优化的c程序可正常运行，优化后不能运行，那一定是我的程序有问题。我还没经历过不是我程序的情况。
发现这种不易发现的问题，需要看汇编码。
避免的方法，我的经验：写c程序，尽量规矩；似是而非的概念，一定要搞清楚，别侥幸。因为侥幸而留的雷，现在不出问题，将来一定会出问题；不优化不出问题，优化就出问题。
最后要说，每个应用程序，都让他开优化运行，只要时间允许，一定要查出开优化后出问题的原因。时间不允许，只能不开优化凑合着，在有时间的时候继续查问题。

5. 在单片机C语言中*(volatile unsigned int *)0x500是什么意思详细一点，谢谢。

(unsigned int *)0x500:将地址0x500强制转化为int型指针
*(unsigned int *)0x500=0x10：对地址为0x500赋值为0x10
补充：
关键字volatile声明变量可被意想不到的改变，一般用于声明：中断的非自动变量、寄存器定义、再入函数。总之，被它声明的变量编译器不会进行优化，每次都会小心翼翼的从内存中读取、修改、再写入内存。

6. c语言防止优化

编译器编译命令里有设置选项，通过设置，你可以要求 不优化，也可以要求用哪种优化。
具体选项有哪些，要查自己编译器的帮助文件。
例如，MS VC++ 6.0 编译器编
优化选项：
/O1：优化使产生的可执行代码最小
/O2：优化使产生的可执行代码速度最快
/Oa：指示编译器程序里没有使用别名，可以提高程序的执行速度
/Ob：控制内联（inline）函数的展开
/Od：禁止代码优化
/Og：使用全局优化
/Oi：用内部函数去代替程序里的函数调用，可以使程序运行的更快，但程序的长度变长
/Op：提高浮点数比较运算的一致性
/Os：产生尽可能小的可执行代码
/Ot：产生尽可能块的可执行代码
/Ow：指示编译器在函数体内部没有使用别名
/Ox：组合了几个优化开关，达到尽可能多的优化
/Oy：阻止调用堆栈里创建帧指针

/O2 为了加速，会优化掉。 选 /Od 不优化。

7. 如何优化你的C代码

一、程序结构的优化
1、程序的书写结构
虽然书写格式并不会影响生成的代码质量，但是在实际编写程序时还是应该尊循一定的书写规则，一个书写清晰、明了的程序，有利于以后的维护。在书写程序时，特别是对于While、for、do…while、if…elst、switch…case等语句或这些语句嵌套组合时，应采用“缩格”的书写形式，

2、标识符
程序中使用的用户标识符除要遵循标识符的命名规则以外，一般不要用代数符号(如a、b、x1、y1)作为变量名，应选取具有相关含义的英文单词(或缩写)或汉语拼音作为标识符，以增加程序的可读性，如：count、number1、red、work等。

3、程序结构
C语言是一种高级程序设计语言，提供了十分完备的规范化流程控制结构。因此在采用C语言设计单片机应用系统程序时，首先要注意尽可能采用结构化的程序设计方法，这样可使整个应用系统程序结构清晰，便于调试和维护。于一个较大的应用程序，通常将整个程序按功能分成若干个模块，不同模块完成不同的功能。各个模块可以分别编写，甚至还可以由不同的程序员编写，一般单个模块完成的功能较为简单，设计和调试也相对容易一些。在C语言中，一个函数就可以认为是一个模块。所谓程序模块化，不仅是要将整个程序划分成若干个功能模块，更重要的是，还应该注意保持各个模块之间变量的相对独立性，即保持模块的独立性，尽量少使用全局变量等。对于一些常用的功能模块，还可以封装为一个应用程序库，以便需要时可以直接调用。但是在使用模块化时，如果将模块分成太细太小，又会导致程序的执行效率变低(进入和退出一个函数时保护和恢复寄存器占用了一些时间)。

4、定义常数
在程序化设计过程中，对于经常使用的一些常数，如果将它直接写到程序中去，一旦常数的数值发生变化，就必须逐个找出程序中所有的常数，并逐一进行修改，这样必然会降低程序的可维护性。因此，应尽量当采用预处理命令方式来定义常数，而且还可以避免输入错误。

5、减少判断语句
能够使用条件编译(ifdef)的地方就使用条件编译而不使用if语句，有利于减少编译生成的代码的长度，能够不用判断语句则少用判断用语句。

6、表达式
对于一个表达式中各种运算执行的优先顺序不太明确或容易混淆的地方，应当采用圆括号明确指定它们的优先顺序。一个表达式通常不能写得太复杂，如果表达式太复杂，时间久了以后，自己也不容易看得懂，不利于以后的维护。

7、函数
对于程序中的函数，在使用之前，应对函数的类型进行说明，对函数类型的说明必须保证它与原来定义的函数类型一致，对于没有参数和没有返回值类型的函数应加上“void”说明。如果果需要缩短代码的长度，可以将程序中一些公共的程序段定义为函数，在Keil中的高级别优化就是这样的。如果需要缩短程序的执行时间，在程序调试结束后，将部分函数用宏定义来代替。注意，应该在程序调试结束后再定义宏，因为大多数编译系统在宏展开之后才会报错，这样会增加排错的难度。

8、尽量少用全局变量，多用局部变量。
因为全局变量是放在数据存储器中，定义一个全局变量，MCU就少一个可以利用的数据存储器空间，如果定义了太多的全局变量，会导致编译器无足够的内存可以分配。而局部变量大多定位于MCU内部的寄存器中，在绝大多数MCU中，使用寄存器操作速度比数据存储器快，指令也更多更灵活，有利于生成质量更高的代码，而且局部变量所的占用的寄存器和数据存储器在不同的模块中可以重复利用。

9、设定合适的编译程序选项
许多编译程序有几种不同的优化选项，在使用前应理解各优化选项的含义，然后选用最合适的一种优化方式。通常情况下一旦选用最高级优化，编译程序会近乎病态地追求代码优化，可能会影响程序的正确性，导致程序运行出错。因此应熟悉所使用的编译器，应知道哪些参数在优化时会受到影响，哪些参数不会受到影响。
在ICCAVR中，有“Default”和“Enable Code Compression”两个优化选项。
在CodeVisionAVR中，“Tiny”和“small”两种内存模式。
在IAR中，共有7种不同的内存模式选项。
在GCCAVR中优化选项更多，一不小心更容易选到不恰当的选项。

二、代码的优化
1、选择合适的算法和数据结构
应该熟悉算法语言，知道各种算法的优缺点，具体资料请参见相应的参考资料，有很多计算机书籍上都有介绍。将比较慢的顺序查找法用较快的二分查找或乱序查找法代替，插入排序或冒泡排序法用快速排序、合并排序或根排序代替，都可以大大提高程序执行的效率。.选择一种合适的数据结构也很重要，比如你在一堆随机存放的数中使用了大量的插入和删除指令，那使用链表要快得多。
数组与指针语句具有十分密码的关系，一般来说，指针比较灵活简洁，而数组则比较直观，容易理解。对于大部分的编译器，使用指针比使用数组生成的代码更短，执行效率更高。但是在Keil中则相反，使用数组比使用的指针生成的代码更短。。

3、使用尽量小的数据类型
能够使用字符型(char)定义的变量，就不要使用整型(int)变量来定义；能够使用整型变量定义的变量就不要用长整型(long int)，能不使用浮点型(float)变量就不要使用浮点型变量。当然，在定义变量后不要超过变量的作用范围，如果超过变量的范围赋值，C编译器并不报错，但程序运行结果却错了，而且这样的错误很难发现。
在ICCAVR中，可以在Options中设定使用printf参数，尽量使用基本型参数(%c、%d、%x、%X、%u和%s格式说明符)，少用长整型参数(%ld、%lu、%lx和%lX格式说明符)，至于浮点型的参数(%f)则尽量不要使用，其它C编译器也一样。在其它条件不变的情况下，使用%f参数，会使生成的代码的数量增加很多，执行速度降低。

4、使用自加、自减指令
通常使用自加、自减指令和复合赋值表达式(如a-=1及a+=1等)都能够生成高质量的程序代码，编译器通常都能够生成inc和dec之类的指令，而使用a=a+1或a=a-1之类的指令，有很多C编译器都会生成二到三个字节的指令。在AVR单片适用的ICCAVR、GCCAVR、IAR等C编译器以上几种书写方式生成的代码是一样的，也能够生成高质量的inc和dec之类的的代码。

5、减少运算的强度
可以使用运算量小但功能相同的表达式替换原来复杂的的表达式。如下：

(1)、求余运算。
a=a%8;
可以改为：
a=a&7;
说明：位操作只需一个指令周期即可完成，而大部分的C编译器的“%”运算均是调用子程序来完成，代码长、执行速度慢。通常，只要求是求2n方的余数，均可使用位操作的方法来代替。

(2)、平方运算
a=pow(a,2.0);
可以改为：
a=a*a;
说明：在有内置硬件乘法器的单片机中(如51系列)，乘法运算比求平方运算快得多，因为浮点数的求平方是通过调用子程序来实现的，在自带硬件乘法器的AVR单片机中，如ATMega163中，乘法运算只需2个时钟周期就可以完成。既使是在没有内置硬件乘法器的AVR单片机中，乘法运算的子程序比平方运算的子程序代码短，执行速度快。

如果是求3次方，如：
a=pow(a,3.0);
更改为：
a=a*a*a；
则效率的改善更明显。

(3)、用移位实现乘除法运算
a=a*4;
b=b/4;
可以改为：
a=a<<2;
b=b>>2;
说明：通常如果需要乘以或除以2n，都可以用移位的方法代替。在ICCAVR中，如果乘以2n，都可以生成左移的代码，而乘以其它的整数或除以任何数，均调用乘除法子程序。用移位的方法得到代码比调用乘除法子程序生成的代码效率高。实际上，只要是乘以或除以一个整数，均可以用移位的方法得到结果，如：
a=a*9
可以改为：
a=(a<<3)+a

6、循环
(1)、循环语
对于一些不需要循环变量参加运算的任务可以把它们放到循环外面，这里的任务包括表达式、函数的调用、指针运算、数组访问等，应该将没有必要执行多次的操作全部集合在一起，放到一个init的初始化程序中进行。

(2)、延时函数：
通常使用的延时函数均采用自加的形式：
void delay (void)
{
unsigned int i;
for (i=0;i<1000;i++)
;
}
将其改为自减延时函数：
void delay (void)
{
unsigned int i;
for (i=1000;i>0;i--)
;
}
两个函数的延时效果相似，但几乎所有的C编译对后一种函数生成的代码均比前一种代码少1~3个字节，因为几乎所有的MCU均有为0转移的指令，采用后一种方式能够生成这类指令。
在使用while循环时也一样，使用自减指令控制循环会比使用自加指令控制循环生成的代码更少1~3个字母。
但是在循环中有通过循环变量“i”读写数组的指令时，使用预减循环时有可能使数组超界，要引起注意。

(3)while循环和do…while循环
用while循环时有以下两种循环形式：
unsigned int i;
i=0;
while (i<1000)
{
i++;
//用户程序
}
或：
unsigned int i;
i=1000;
do
i--;
//用户程序
while (i>0);
在这两种循环中，使用do…while循环编译后生成的代码的长度短于while循环。

7、查表
在程序中一般不进行非常复杂的运算，如浮点数的乘除及开方等，以及一些复杂的数学模型的插补运算，对这些即消耗时间又消费资源的运算，应尽量使用查表的方式，并且将数据表置于程序存储区。如果直接生成所需的表比较困难，也尽量在启动时先计算，然后在数据存储器中生成所需的表，后以在程序运行直接查表就可以了，减少了程序执行过程中重复计算的工作量。

8. 怎么防止keil编译器自作聪明优化掉有用语句

在51环境下：options for target -> C51 -> emphasis选择default (不要选择size、speed)
优化标准：选择 0:constant folding 即可保留所有垃圾语句，

9. 如何在编译java的时候，取消编译器对编译常量的优化

遇到的问题是想重新编译某个java文件（比如A.java），里面有个常量（比如finalinta）和上次编译时不一样，但是另一个使用A.class的a的文件（比如B.java）由于在javac在上次编译的时候将当时的A.class里面的常量直接给内联了，所以就达不到想要的效果。
如果是这样的话，对于String可以使用.intern()来防止编译器进行优化，对于其他类型，可以要么不定义为常量，要么将常量定义为private，然后使用一个static方法来返回这个常量。