贴这个题时，就没把他当成coding style issue; 想问的就是编译器的行为；您的分析，简单化为coding风格不妥，绕开了原来的关键点，所以问题没得到解决； -eagle_no1(瞎起哄) @拉斯维加斯华人论坛:拉斯维加斯枫下论坛 The Rolia Forum of Las Vegas

工作学习 / 学科技术讨论 / 廉颇老亦，谁能告诉我结果，并告诉我原因？（ C question) -eagle_no1(瞎起哄); 2009-7-15 {267} (#5420989@0)
main()
{
int x=20,y=35;
x=y++ + x++;
y= ++y + ++x;
printf(“%d%d\n”,x,y);

}

main()
{
volatile int x=20,y=35;
x=y++ + x++;
y= ++y + ++x;
printf(“%d%dn”,x,y);

}

第一个结果是 94 57？第二个不清楚，忘了volatile是啥意思了。 -walkthrough(胸围>肚围); 2009-7-15 {74} (#5421055@0)
x=y++ + x++ : x=20+35 +1=56, y=36
y=++y + ++x : y=1+36 + 1+56= 94

second thought. 93,56 -walkthrough(胸围>肚围); 2009-7-15 {80} (#5421077@0)
x=y++ + x++ : x=20+35 =55, y=35+1=36
y=++y + ++x : y=1+36 + 1+55= 93, x=55+1=56

2259 -eagle_no1(瞎起哄); 2009-7-15 (#5421093@0)

看来用CACHE跟不用还是有很大区别的嘛。 -luckystar889(luckystar); 2009-7-15 (#5421197@0)

volitale的作用好象不是禁Cache而是禁Reg吧？ -philishave(Philishave); 2009-7-15 (#5421263@0)

对的；第二个呢？牛哥，猫哥，车哥怎么都躲起来了？ -eagle_no1(瞎起哄); 2009-7-15 (#5421085@0)

牛人们是不需要做这些的，打发手下的实习生和苦力们去干就可以了。:P -pipe(Pipe); 2009-7-15 (#5421095@0)

是啊，我也觉得我自己不需要做这些，但不做不行啊，你看，关键时候全躲起来了。：－） -eagle_no1(瞎起哄); 2009-7-15 (#5421109@0)

2. Depends on external change (interrupt service or mapped hardware) in embedded system. 1. I had the 2nd thought, which one is correct or depends on compiler? -panda5wu(郁闷：天生我才咋没用); 2009-7-15 (#5421231@0)

1) is clear, #5421290@0; but i got confussed with the running result with is 2259, i guess something wrong somewhere; -eagle_no1(瞎起哄); 2009-7-15 (#5421302@0)

呵呵，我已经15年没编过代码了，不是干这行的。本科那会儿学的那些基本编程的东西也早忘光了。 -mikesmith(老猫); 2009-7-15 {1735} (#5421254@0)
本文发表在 rolia.net 枫下论坛Googled

[Bug c/17282] x = y++ + x++ operation wrongly implemented on solaris version
From: "gaurav_har at rediffmail dot com" <gcc-bugzilla at gcc dot gnu dot org>
To: gcc-bugs at gcc dot gnu dot org
Date: 3 Sep 2004 05:12:41 -0000
Subject: [Bug c/17282] x = y++ + x++ operation wrongly implemented on solaris version
References: <20040902120650.17282.gaurav_har@rediffmail.com>
Reply-to: gcc-bugzilla at gcc dot gnu dot org

--------------------------------------------------------------------------------

------- Additional Comments From gaurav_har at rediffmail dot com 2004-09-03 05:12 -------
Hi,

It seems to me that this problem is different for what defined in other bug.
Here we are assigning a value after adding and the variable with other
constant, but instead of adding then incrementing the variable compiler is just
incrementing the value. Behavior is different in Linux.

Code is:
x=20;
y=35;

x = y++ + x++;

For this expression compiler should first add x and y and then increment x.
This expression should be broken like this.
x = x + y;
y++;
x++;

but compiler on Solaris is doing something like this:
temp = x++;
temp1 = y++;
x = x + y;
y = temp1;
x = temp; /* reassigning the variable with incremented value. This is wrong */

expected value of x here is 56, but its giving 21.

Same is working fine with Linux. this problem is there with Solaris and
compilers cc and g++ also.

Regards,
Gaurav

--
What |Removed |Added
----------------------------------------------------------------------------
Status|RESOLVED |UNCONFIRMED
Resolution|DUPLICATE |

更多精彩文章及讨论，请光临枫下论坛 rolia.net
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=17282

佩服！站的高度的确不一样！我经常纠缠于具体细节，缺乏outside the box思考问题的习惯。 -wangqingshui(忘情水); 2009-7-15 (#5421358@0)

不敢不敢。 -mikesmith(老猫); 2009-7-16 (#5422882@0)

这都那跟那啊？我是偶然看到这页想到 volatile的 -eagle_no1(瞎起哄); 2009-7-15 (#5421396@0)

That bug explained the result of 2259.. I guess.. or maybe it is just coincidence -mikesmith(老猫); 2009-7-15 (#5421463@0)

maybe it's the same kind of bug, just wandering how does the compiler deal with those code... -eagle_no1(瞎起哄); 2009-7-15 (#5421522@0)

You can check C89 for official answer. This is about language standard question. -iwantcar_majia(iwantcar); 2009-7-16 (#5422271@0)

volatile 的意思是其值可被另一线程或硬件随时改变。如果没有被改变， volatile变量和一般变量应该没有区别 -limn(limn); 2009-7-19 (#5428097@0)

第一个不是5693吗？ -wangqingshui(忘情水); 2009-7-15 (#5421205@0)

帮我看看我哪里错了吧 -wangqingshui(忘情水); 2009-7-15 {639} (#5421261@0)
main()
{
int x=20,y=35;
x=y++ + x++;
y= ++y + ++x;
printf(“%d%d ”,x,y);

}

Step 1. calculate "y++", the result of the expression is 35 and y is 36;
Step 2. calculate "x++", the result is 20 and x is 21;
Step 3. calculate "(y++) + (x++)" (use results of the above 2 steps, the result is 35 + 20, i.e. 55.
Step 4. assign 55 to x. Up to now x = 55 and y = 36.

Step 5. calculate "++y", the result is 37 and y is 37.
Step 6. calculate "++x", the result is 56 and x is 56
Step 7. calculate "(++y) + (++x)", using the results of the above 2 steps, the result is 93.
Step 8. assign 93 to y. Now x = 56 and y = 93.

seems -eagle_no1(瞎起哄); 2009-7-15 {141} (#5421290@0)
step1: x = y + x; (55)
step2; y = y+1; (36)
step3; x= x+1; (56)

step4: y= y+1; (37)
step5: x=x+1; (57)
step6:y=y+x; (94)

FYI: C Language Operator Precedence Chart -wangqingshui(忘情水); 2009-7-15 (#5421319@0)

如果是单线程，纯内存操作，我看不出有volatile 对第二题的影响。能请夏老师指点一下吗？ -wangqingshui(忘情水); 2009-7-15 (#5421222@0)

第一个 #5421055@0的解释和运算结果一致；2259 是第二个的运行结果；在x86上，linux ,gcc编译运行的；正抓狂想原因；可惜x86汇编不熟； -eagle_no1(瞎起哄); 2009-7-15 (#5421241@0)

为什么要声明volatile？是不是被你贴出来的逻辑以外的东东改变了数值？那这里说什么都白搭。 -wangqingshui(忘情水); 2009-7-15 (#5421267@0)

completed code: -eagle_no1(瞎起哄); 2009-7-15 {155} (#5421314@0)
#include "stdio.h"

void func()
{
volatile int x=20, y=35;
x=y++ + x++;
y= ++y + ++x;
printf("%d%d\n",x,y);

}

main()
{

func();

}

I usually do not pay too much attention to complicated syntax skills, like macros, unless I have no choice. Here what concerns me most is the intention of declaring "volatile", if the 2 variables are not used by other threads or external devices. -wangqingshui(忘情水); 2009-7-15 (#5421333@0)

夏老弟，看汇编没用，找一本最新的C标准，好好读读operator precedence一节。 -hubeir(作曲家wannabe); 2009-7-16 {48} (#5421631@0)
俺现在太忙了，等下下星期闲下来，再给出标准答案。

hehe, here is the result #5422795@0 -eagle_no1(瞎起哄); 2009-7-16 (#5423894@0)

"如果是单线程，纯内存操作，我看不出有volatile 对第二题的影响" --- 能解释一下如果是多线程环境又会怎样? -nicetomeetyou(蓦然回首彩虹跨天地); 2009-7-16 (#5421794@0)

这个volatile就是告诉编译器，不要作任何优化，每次操作老老实实从内存把数值load到寄存器，避免多线程（中断）间失步错误； -eagle_no1(瞎起哄); 2009-7-16 (#5421863@0)

谢谢,好久不用c, and embedded system, 脑子都简单了. 这可能是个有所帮助的link. -nicetomeetyou(蓦然回首彩虹跨天地); 2009-7-16 (#5421904@0)

volatile variable: -qwertyasd(东北人); 2009-7-16 {536} (#5421869@0)
A volatile variable is one that can change unexpectedly. Consequently, the compiler can make no assumptions about the value of the variable. In particular, the optimizer must be careful to reload the variable every time it is used instead of holding a copy in a register. Examples of volatile variables are:

* Hardware registers in peripherals (for example, status registers)
* Non-automatic variables referenced within an interrupt service routine
* Variables shared by multiple tasks in a multi-threaded application

humm. so my naive question is: If a variable is declared as volatile, all codes related with this variable will not be optimized by compiler, or, compiler simply shut off its optimization for all codes? -nicetomeetyou(蓦然回首彩虹跨天地); 2009-7-16 (#5421930@0)

I don't know the compiler's behavior on this case. But I guess a goos compiler should optimize other parts of code that are not related to the volatile variables base on the options from the user. -qwertyasd(东北人); 2009-7-16 (#5421999@0)

Compiler dependant吧？俺估计得objdump后才能告诉你结果。不过出这种题目是吃饱了撑的。招人考这种题目还不如问人DMA要注意些啥来得实际。 -philishave(Philishave); 2009-7-15 (#5421233@0)

高人来了；（不是考题，正好遇到了） -eagle_no1(瞎起哄); 2009-7-15 {1867} (#5421258@0)
本文发表在 rolia.net 枫下论坛#include "stdio.h"

void func()
{
volatile int x=20, y=35;
x=y++ + x++;
y= ++y + ++x;
printf("%d%d\n",x,y);

}

main()
{

func();

}

....
080483c4 <func>:
80483c4: 55 push %ebp
80483c5: 89 e5 mov %esp,%ebp
80483c7: 83 ec 28 sub $0x28,%esp
80483ca: c7 45 fc 14 00 00 00 movl $0x14,-0x4(%ebp)
80483d1: c7 45 f8 23 00 00 00 movl $0x23,-0x8(%ebp)
80483d8: 8b 55 f8 mov -0x8(%ebp),%edx
80483db: 8b 4d fc mov -0x4(%ebp),%ecx
80483de: 8d 04 0a lea (%edx,%ecx,1),%eax
80483e1: 89 45 fc mov %eax,-0x4(%ebp)
80483e4: 8d 42 01 lea 0x1(%edx),%eax
80483e7: 89 45 f8 mov %eax,-0x8(%ebp)
80483ea: 8d 41 01 lea 0x1(%ecx),%eax
80483ed: 89 45 fc mov %eax,-0x4(%ebp)
80483f0: 8b 45 f8 mov -0x8(%ebp),%eax
80483f3: 83 c0 01 add $0x1,%eax
80483f6: 89 45 f8 mov %eax,-0x8(%ebp)
80483f9: 8b 55 f8 mov -0x8(%ebp),%edx
80483fc: 8b 45 fc mov -0x4(%ebp),%eax
80483ff: 83 c0 01 add $0x1,%eax
8048402: 89 45 fc mov %eax,-0x4(%ebp)
8048405: 8b 45 fc mov -0x4(%ebp),%eax
8048408: 8d 04 02 lea (%edx,%eax,1),%eax
804840b: 89 45 f8 mov %eax,-0x8(%ebp)
804840e: 8b 45 f8 mov -0x8(%ebp),%eax
8048411: 8b 55 fc mov -0x4(%ebp),%edx
8048414: 89 44 24 08 mov %eax,0x8(%esp)
8048418: 89 54 24 04 mov %edx,0x4(%esp)
804841c: c7 04 24 10 85 04 08 movl $0x8048510,(%esp)
8048423: e8 d0 fe ff ff call 80482f8 <printf@plt>
8048428: c9 leave
8048429: c3 ret
...更多精彩文章及讨论，请光临枫下论坛 rolia.net

X86好长一段时间没工作过了。不是很熟。Coldfire及ARM反倒好一点。俺的意思是有些东西是C spec里没硬性规定一定要怎样的。所以不同的Compiler会有不同的编译方试，从而导致结果的不同。印象中volatile也是如此，C spec里也 -philishave(Philishave); 2009-7-15 {135} (#5421458@0)
印象中volatile也是如此，C spec里也没说Compiler一定不能把它优化到Reg，Compiler仍可忽略volatile.另外你objdump还可以多dump一些东西出来吧。

我是偶然遇到这个结果，估计象猫哥蒙的---是compiler的bug, 象是相加的结果没有load到内存，可惜不会用汇编求证；。。。 objdump 可以dump很多，我特意写成func，好objdump分离问题； -eagle_no1(瞎起哄); 2009-7-15 (#5421549@0)
objdump of second main. gcc (SUSE Linux) 4.3.2 [gcc-4_3-branch revision 141291] GNU objdump (GNU Binutils; openSUSE 11.1) 2.19 -qwertyasd(东北人); 2009-7-16 {15929} (#5421861@0)
本文发表在 rolia.net 枫下论坛est1: file format elf32-i386

Disassembly of section .init:

080482f4 <_init>:
80482f4: 55 push %ebp
80482f5: 89 e5 mov %esp,%ebp
80482f7: 53 push %ebx
80482f8: 83 ec 04 sub $0x4,%esp
80482fb: e8 00 00 00 00 call 8048300 <_init+0xc>
8048300: 5b pop %ebx
8048301: 81 c3 f4 1c 00 00 add $0x1cf4,%ebx
8048307: 8b 93 fc ff ff ff mov -0x4(%ebx),%edx
804830d: 85 d2 test %edx,%edx
804830f: 74 05 je 8048316 <_init+0x22>
8048311: e8 1e 00 00 00 call 8048334 <__gmon_start__@plt>
8048316: e8 e5 00 00 00 call 8048400 <frame_dummy>
804831b: e8 00 02 00 00 call 8048520 <__do_global_ctors_aux>
8048320: 58 pop %eax
8048321: 5b pop %ebx
8048322: c9 leave
8048323: c3 ret

Disassembly of section .plt:

08048324 <__gmon_start__@plt-0x10>:
8048324: ff 35 f8 9f 04 08 pushl 0x8049ff8
804832a: ff 25 fc 9f 04 08 jmp *0x8049ffc
8048330: 00 00 add %al,(%eax)
...

08048334 <__gmon_start__@plt>:
8048334: ff 25 00 a0 04 08 jmp *0x804a000
804833a: 68 00 00 00 00 push $0x0
804833f: e9 e0 ff ff ff jmp 8048324 <_init+0x30>

08048344 <__libc_start_main@plt>:
8048344: ff 25 04 a0 04 08 jmp *0x804a004
804834a: 68 08 00 00 00 push $0x8
804834f: e9 d0 ff ff ff jmp 8048324 <_init+0x30>

08048354 <printf@plt>:
8048354: ff 25 08 a0 04 08 jmp *0x804a008
804835a: 68 10 00 00 00 push $0x10
804835f: e9 c0 ff ff ff jmp 8048324 <_init+0x30>

Disassembly of section .text:

08048370 <_start>:
8048370: 31 ed xor %ebp,%ebp
8048372: 5e pop %esi
8048373: 89 e1 mov %esp,%ecx
8048375: 83 e4 f0 and $0xfffffff0,%esp
8048378: 50 push %eax
8048379: 54 push %esp
804837a: 52 push %edx
804837b: 68 b0 84 04 08 push $0x80484b0
8048380: 68 c0 84 04 08 push $0x80484c0
8048385: 51 push %ecx
8048386: 56 push %esi
8048387: 68 24 84 04 08 push $0x8048424
804838c: e8 b3 ff ff ff call 8048344 <__libc_start_main@plt>
8048391: f4 hlt
8048392: 90 nop
8048393: 90 nop
8048394: 90 nop
8048395: 90 nop
8048396: 90 nop
8048397: 90 nop
8048398: 90 nop
8048399: 90 nop
804839a: 90 nop
804839b: 90 nop
804839c: 90 nop
804839d: 90 nop
804839e: 90 nop
804839f: 90 nop

080483a0 <__do_global_dtors_aux>:
80483a0: 55 push %ebp
80483a1: 89 e5 mov %esp,%ebp
80483a3: 53 push %ebx
80483a4: 83 ec 04 sub $0x4,%esp
80483a7: 80 3d 14 a0 04 08 00 cmpb $0x0,0x804a014
80483ae: 75 40 jne 80483f0 <__do_global_dtors_aux+0x50>
80483b0: 8b 15 18 a0 04 08 mov 0x804a018,%edx
80483b6: b8 18 9f 04 08 mov $0x8049f18,%eax
80483bb: 2d 14 9f 04 08 sub $0x8049f14,%eax
80483c0: c1 f8 02 sar $0x2,%eax
80483c3: 8d 58 ff lea -0x1(%eax),%ebx
80483c6: 39 da cmp %ebx,%edx
80483c8: 73 1f jae 80483e9 <__do_global_dtors_aux+0x49>
80483ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80483d0: 8d 42 01 lea 0x1(%edx),%eax
80483d3: a3 18 a0 04 08 mov %eax,0x804a018
80483d8: ff 14 85 14 9f 04 08 call *0x8049f14(,%eax,4)
80483df: 8b 15 18 a0 04 08 mov 0x804a018,%edx
80483e5: 39 da cmp %ebx,%edx
80483e7: 72 e7 jb 80483d0 <__do_global_dtors_aux+0x30>
80483e9: c6 05 14 a0 04 08 01 movb $0x1,0x804a014
80483f0: 83 c4 04 add $0x4,%esp
80483f3: 5b pop %ebx
80483f4: 5d pop %ebp
80483f5: c3 ret
80483f6: 8d 76 00 lea 0x0(%esi),%esi
80483f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi

08048400 <frame_dummy>:
8048400: 55 push %ebp
8048401: 89 e5 mov %esp,%ebp
8048403: 83 ec 08 sub $0x8,%esp
8048406: a1 1c 9f 04 08 mov 0x8049f1c,%eax
804840b: 85 c0 test %eax,%eax
804840d: 74 12 je 8048421 <frame_dummy+0x21>
804840f: b8 00 00 00 00 mov $0x0,%eax
8048414: 85 c0 test %eax,%eax
8048416: 74 09 je 8048421 <frame_dummy+0x21>
8048418: c7 04 24 1c 9f 04 08 movl $0x8049f1c,(%esp)
804841f: ff d0 call *%eax
8048421: c9 leave
8048422: c3 ret
8048423: 90 nop

08048424 <main>:
8048424: 8d 4c 24 04 lea 0x4(%esp),%ecx
8048428: 83 e4 f0 and $0xfffffff0,%esp
804842b: ff 71 fc pushl -0x4(%ecx)
804842e: 55 push %ebp
804842f: 89 e5 mov %esp,%ebp
8048431: 51 push %ecx
8048432: 83 ec 24 sub $0x24,%esp
8048435: c7 45 f8 14 00 00 00 movl $0x14,-0x8(%ebp)
804843c: c7 45 f4 23 00 00 00 movl $0x23,-0xc(%ebp)
8048443: 8b 55 f4 mov -0xc(%ebp),%edx
8048446: 8b 4d f8 mov -0x8(%ebp),%ecx
8048449: 8d 04 0a lea (%edx,%ecx,1),%eax
804844c: 89 45 f8 mov %eax,-0x8(%ebp)
804844f: 8d 42 01 lea 0x1(%edx),%eax
8048452: 89 45 f4 mov %eax,-0xc(%ebp)
8048455: 8d 41 01 lea 0x1(%ecx),%eax
8048458: 89 45 f8 mov %eax,-0x8(%ebp)
804845b: 8b 45 f4 mov -0xc(%ebp),%eax
804845e: 83 c0 01 add $0x1,%eax
8048461: 89 45 f4 mov %eax,-0xc(%ebp)
8048464: 8b 55 f4 mov -0xc(%ebp),%edx
8048467: 8b 45 f8 mov -0x8(%ebp),%eax
804846a: 83 c0 01 add $0x1,%eax
804846d: 89 45 f8 mov %eax,-0x8(%ebp)
8048470: 8b 45 f8 mov -0x8(%ebp),%eax
8048473: 8d 04 02 lea (%edx,%eax,1),%eax
8048476: 89 45 f4 mov %eax,-0xc(%ebp)
8048479: 8b 45 f4 mov -0xc(%ebp),%eax
804847c: 8b 55 f8 mov -0x8(%ebp),%edx
804847f: 89 44 24 08 mov %eax,0x8(%esp)
8048483: 89 54 24 04 mov %edx,0x4(%esp)
8048487: c7 04 24 70 85 04 08 movl $0x8048570,(%esp)
804848e: e8 c1 fe ff ff call 8048354 <printf@plt>
8048493: b8 00 00 00 00 mov $0x0,%eax
8048498: 83 c4 24 add $0x24,%esp
804849b: 59 pop %ecx
804849c: 5d pop %ebp
804849d: 8d 61 fc lea -0x4(%ecx),%esp
80484a0: c3 ret
80484a1: 90 nop
80484a2: 90 nop
80484a3: 90 nop
80484a4: 90 nop
80484a5: 90 nop
80484a6: 90 nop
80484a7: 90 nop
80484a8: 90 nop
80484a9: 90 nop
80484aa: 90 nop
80484ab: 90 nop
80484ac: 90 nop
80484ad: 90 nop
80484ae: 90 nop
80484af: 90 nop

080484b0 <__libc_csu_fini>:
80484b0: 55 push %ebp
80484b1: 89 e5 mov %esp,%ebp
80484b3: 5d pop %ebp
80484b4: c3 ret
80484b5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80484b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi

080484c0 <__libc_csu_init>:
80484c0: 55 push %ebp
80484c1: 89 e5 mov %esp,%ebp
80484c3: 57 push %edi
80484c4: 56 push %esi
80484c5: 53 push %ebx
80484c6: e8 4f 00 00 00 call 804851a <__i686.get_pc_thunk.bx>
80484cb: 81 c3 29 1b 00 00 add $0x1b29,%ebx
80484d1: 83 ec 0c sub $0xc,%esp
80484d4: e8 1b fe ff ff call 80482f4 <_init>
80484d9: 8d bb 18 ff ff ff lea -0xe8(%ebx),%edi
80484df: 8d 83 18 ff ff ff lea -0xe8(%ebx),%eax
80484e5: 29 c7 sub %eax,%edi
80484e7: c1 ff 02 sar $0x2,%edi
80484ea: 85 ff test %edi,%edi
80484ec: 74 24 je 8048512 <__libc_csu_init+0x52>
80484ee: 31 f6 xor %esi,%esi
80484f0: 8b 45 10 mov 0x10(%ebp),%eax
80484f3: 89 44 24 08 mov %eax,0x8(%esp)
80484f7: 8b 45 0c mov 0xc(%ebp),%eax
80484fa: 89 44 24 04 mov %eax,0x4(%esp)
80484fe: 8b 45 08 mov 0x8(%ebp),%eax
8048501: 89 04 24 mov %eax,(%esp)
8048504: ff 94 b3 18 ff ff ff call *-0xe8(%ebx,%esi,4)
804850b: 83 c6 01 add $0x1,%esi
804850e: 39 fe cmp %edi,%esi
8048510: 72 de jb 80484f0 <__libc_csu_init+0x30>
8048512: 83 c4 0c add $0xc,%esp
8048515: 5b pop %ebx
8048516: 5e pop %esi
8048517: 5f pop %edi
8048518: 5d pop %ebp
8048519: c3 ret

0804851a <__i686.get_pc_thunk.bx>:
804851a: 8b 1c 24 mov (%esp),%ebx
804851d: c3 ret
804851e: 90 nop
804851f: 90 nop

08048520 <__do_global_ctors_aux>:
8048520: 55 push %ebp
8048521: 89 e5 mov %esp,%ebp
8048523: 53 push %ebx
8048524: 83 ec 04 sub $0x4,%esp
8048527: a1 0c 9f 04 08 mov 0x8049f0c,%eax
804852c: 83 f8 ff cmp $0xffffffff,%eax
804852f: 74 13 je 8048544 <__do_global_ctors_aux+0x24>
8048531: bb 0c 9f 04 08 mov $0x8049f0c,%ebx
8048536: 66 90 xchg %ax,%ax
8048538: 83 eb 04 sub $0x4,%ebx
804853b: ff d0 call *%eax
804853d: 8b 03 mov (%ebx),%eax
804853f: 83 f8 ff cmp $0xffffffff,%eax
8048542: 75 f4 jne 8048538 <__do_global_ctors_aux+0x18>
8048544: 83 c4 04 add $0x4,%esp
8048547: 5b pop %ebx
8048548: 5d pop %ebp
8048549: c3 ret
804854a: 90 nop
804854b: 90 nop

Disassembly of section .fini:

0804854c <_fini>:
804854c: 55 push %ebp
804854d: 89 e5 mov %esp,%ebp
804854f: 53 push %ebx
8048550: 83 ec 04 sub $0x4,%esp
8048553: e8 00 00 00 00 call 8048558 <_fini+0xc>
8048558: 5b pop %ebx
8048559: 81 c3 9c 1a 00 00 add $0x1a9c,%ebx
804855f: e8 3c fe ff ff call 80483a0 <__do_global_dtors_aux>
8048564: 59 pop %ecx
8048565: 5b pop %ebx
8048566: c9 leave
8048567: c3 ret更多精彩文章及讨论，请光临枫下论坛 rolia.net

翻译成c是这样子的 -baalinca(三碗不过冈十点不上网); 2009-7-17 {1515} (#5425373@0)
本文发表在 rolia.net 枫下论坛080483c4 <func>:
80483c4: 55 push %ebp
80483c5: 89 e5 mov %esp,%ebp
80483c7: 83 ec 28 sub $0x28,%esp
80483ca: c7 45 fc 14 00 00 00 movl $0x14,-0x4(%ebp) //x=20
80483d1: c7 45 f8 23 00 00 00 movl $0x23,-0x8(%ebp) //y=35
80483d8: 8b 55 f8 mov -0x8(%ebp),%edx
80483db: 8b 4d fc mov -0x4(%ebp),%ecx //ecx=x=20
80483de: 8d 04 0a lea (%edx,%ecx,1),%eax
80483e1: 89 45 fc mov %eax,-0x4(%ebp)//x=x+y=55

80483e4: 8d 42 01 lea 0x1(%edx),%eax
80483e7: 89 45 f8 mov %eax,-0x8(%ebp)//y=y+1=36
// 问题在这里，“x”不是从内存里面重新读出来的x的值，而是直接用了寄存器ecx，所以不是55而是20。前面好像少了一条指令: 8b 4d fc mov -0x4(%ebp),%ecx 像是个编译器bug.
80483ea: 8d 41 01 lea 0x1(%ecx),%eax
80483ed: 89 45 fc mov %eax,-0x4(%ebp)//x=“x”+1=21
//
80483f0: 8b 45 f8 mov -0x8(%ebp),%eax
80483f3: 83 c0 01 add $0x1,%eax
80483f6: 89 45 f8 mov %eax,-0x8(%ebp)//y=y+1=36+1=37

80483f9: 8b 55 f8 mov -0x8(%ebp),%edx //edx = y = 37

80483fc: 8b 45 fc mov -0x4(%ebp),%eax
80483ff: 83 c0 01 add $0x1,%eax
8048402: 89 45 fc mov %eax,-0x4(%ebp) //x=x+1=22

8048405: 8b 45 fc mov -0x4(%ebp),%eax
8048408: 8d 04 02 lea (%edx,%eax,1),%eax
804840b: 89 45 f8 mov %eax,-0x8(%ebp)//y=x+y=22+37=59

//下面是打印
804840e: 8b 45 f8 mov -0x8(%ebp),%eax
8048411: 8b 55 fc mov -0x4(%ebp),%edx
8048414: 89 44 24 08 mov %eax,0x8(%esp)
8048418: 89 54 24 04 mov %edx,0x4(%esp)
804841c: c7 04 24 10 85 04 08 movl $0x8048510,(%esp)
8048423: e8 d0 fe ff ff call 80482f8 <printf@plt>
8048428: c9 leave
8048429: c3 ret更多精彩文章及讨论，请光临枫下论坛 rolia.net

对呀！高人啊。和我蒙的是一致的：－） #5422795@0 and #5423300@0 -eagle_no1(瞎起哄); 2009-7-17 (#5425591@0)

都很努力学习嘛, 夜校啊? -iceblake(美丽之夏，CYCLING); 2009-7-15 (#5421372@0)

夏老师的贴，一定要捧场的。 -wangqingshui(忘情水); 2009-7-15 (#5421382@0)

都是能人, 佩服佩服 -iceblake(美丽之夏，CYCLING); 2009-7-15 (#5421400@0)

我现在准备混在事业版和牛哥，猫哥，车哥，忘情水哥学习了；：－） -eagle_no1(瞎起哄); 2009-7-15 (#5421434@0)

哈哈，把我与事业版的大腕列在一对了，荣幸！谢谢夏老师提携！ -wangqingshui(忘情水); 2009-7-15 (#5421451@0)

都挺能起哄. 我能在这里当学生嘛? -iceblake(美丽之夏，CYCLING); 2009-7-15 (#5421466@0)

当冰哥。在这里没有客气的。 -mikesmith(老猫); 2009-7-15 (#5421509@0)

冰歌,好听些 -iceblake(美丽之夏，CYCLING); 2009-7-15 (#5421516@0)

bingo -wangqingshui(忘情水); 2009-7-15 (#5421530@0)

对了，我原来的大号就叫哄哥，应是被你们整成了什么“夏老师” -eagle_no1(瞎起哄); 2009-7-15 (#5421442@0)

多谢，多谢；回头再发一帖，多多帮忙； -eagle_no1(瞎起哄); 2009-7-15 (#5421425@0)

我看了这贴不回不行。编程的要领是什么？3R(自己Google去)。可读性是非常重要的。我编写了22年程序，重来都以可读性为上，这样其他人也好跟进你的程序。若我看到其他人写出搂主题目这样含糊不清故弄玄虚的程序，我立马叫他重编，若他不重编，立马赶人。 -armstrong2(动动猴他爸); 2009-7-15 (#5421452@0)

同感。不是干活是玩人呢。 -w4b(Watch for Beauty); 2009-7-15 (#5421477@0)

痛感. -iceblake(美丽之夏，CYCLING); 2009-7-15 (#5421517@0)

谔谔锷，这词可不能瞎说，痛并快乐着 -w4b(Watch for Beauty); 2009-7-15 (#5421564@0)

+1. LZ在逗着玩呢 -wangqingshui(忘情水); 2009-7-15 (#5421523@0)
哎！又来一个当领导的；怎么都不喜欢具体分析问题解决问题呢？ -eagle_no1(瞎起哄); 2009-7-15 (#5421531@0)

NO,至今我还不是领导，因为我不爱走领导这路，但我是SMTS(指个人技术上的职位)。我的老板很听我的意见(比如面试评价或赶人走)。至于你的具体分析问题解决问题请见内。 -armstrong2(动动猴他爸); 2009-7-16 {992} (#5421647@0)
第一段，按你的程序输出应该是5794,而不是"94 57"(#5421055)，你居然还说人家对(#5421085)?
你若把程序写成以下这样，估计99%的人都能正确解答。
main()
{
int x=20,y=35;

x=y+x;
y++;
x++;

++y;
++x;
y=y+x;

printf("%d%d",x,y);
}

第二段，volatile适用于其他程序如中断程序可能会修改的变量。你现在的程序根本就不能很好的利用到volatile的好处，因为x和y都在堆栈里，地址是动态的，其他程序如中断程序很难知道到x和y在哪.你真想要利用到volatile的好处,就应该把volatile x,y放到全局变量处。
若单看你的程序，假设运行main()时没有任何其它程序修改x和y，结果就应该和没有volatile一样。有人已经提到实际运行结果在Linux中是2259，我也证实了此不可思议的结果。归根结底就是这段程序设计含糊不清，不同编译器有不同结果。若你改成以下代码，则在任何c编译器下的结果和第一段相同 5794(也得假设运行main()时没有任何其它程序修改x和y)
main()
{
volatile int x=20,y=35;

x=y+x;
y++;
x++;

++y;
++x;
y=y+x;

printf("%d%d",x,y);
}

+1.... -barefoot(FoneBone); 2009-7-16 (#5421733@0)
贴这个题时，就没把他当成coding style issue; 想问的就是编译器的行为；您的分析，简单化为coding风格不妥，绕开了原来的关键点，所以问题没得到解决； -eagle_no1(瞎起哄); 2009-7-16 {528} (#5421753@0)
基于这样的考虑， "94 57"(#5421055)，给出了编译器的行为和结果，就可以认为对了，这个上贴错序的小错是一目了然的，大家都明白，不用在这种细枝末节上纠缠了；

volatile x,y放到全局变量处或自动变量在这里对编译器的行为没有影响；这样写的目的是用简单的方法敏化问题；

上面的讨论中很多大侠提到了编译器问题，这是解决问题的关键思路；看看上面的反汇编，应该能得到具体的解释；

另外，绕开了根本问题，指责原问题问得幼稚或错误，这个解决“问题”的方法我以前用过，没用；对解决问题或增加自己的credit都没用；不管说自己是SMTS，或CTO,全没用；

华人小公司的技术骨干？谁要是不听你的，立马赶人？这就是贵公司的企业文化？这种公司，不用赶，有点本事的都不会在那里混。有你这样的小头头，算你那些同事倒霉。 -hubeir(作曲家wannabe); 2009-7-17 (#5426311@0)
换个角度说，虽然不推荐代码写成这样，但是你最好能看懂，所以俺们这里讨论讨论是必要的 - 当然，这是理论上说。实际上，我还没见过哪个real project中出现过类似的代码，程序员们还是有点common sense的。。。一般会让它易读一点，因为他们也不想自己日后费脑子。。。 -erixfan(erixfan); 2009-7-24 (#5440293@0)

俺以务实的精神讲，答案是５７，９４和５６，９３。AIX Polymake下编译并执行。 -laura999(Laura); 2009-7-16 (#5422699@0)

fair enough -eagle_no1(瞎起哄); 2009-7-16 (#5422711@0)

Actually the root cause is x= y++ + x++, which behavior according to c standard is undefined, so it just happens to be the output you expect in case of without volatile keyword. -vacu(vacu); 2009-7-16 {20} (#5422758@0)
take a look at this:
http://c-faq.com/expr/ieqiplusplus.html

good to know. thx -eagle_no1(瞎起哄); 2009-7-18 (#5426780@0)
without the volatile, though the x = y++ + x++ could be handled differenly by different compiler, but the results are same. -frankwoo(柳五随风); 2009-9-19 (#5558418@0)

why is 2259? -eagle_no1(瞎起哄); 2009-7-16 {2454} (#5422795@0)
本文发表在 rolia.net 枫下论坛一个简单的问题，答案是56 93，或是57 94 似乎都make sense.应为这是是和编译器相关的问题；

昨天顺手加上 volatile 希望关掉优化编译，但得到 2259的结果是无论无何都不应该算对的；才贴上了这个问题；

各位侠哥都意识到编译器相关，或标准相关，但有些忽略这是个不能接受的结果；
忘情水哥概念入手，坚持真理，直逼问题核心，思路正确；
猫哥艺高人胆大， google一把，就蒙对了答案------- 编译器在此处出错了！！

咱也google 一下 X86 汇编指令，分析错误原因如下：
#include "stdio.h"

void func()
{
volatile int x=20, y=35;
x=y++ + x++;
y= ++y + ++x;
printf("%d%d ",x,y);

}

main()
{

func();

}

....
080483c4 <func>:
80483c4: 55 push %ebp <----- push stack
80483c5: 89 e5 mov %esp,%ebp <------ point to top of stack
80483c7: 83 ec 28 sub $0x28,%esp <----- allocate stack space why is 0x28 i don't know
80483ca: c7 45 fc 14 00 00 00 movl $0x14,-0x4(%ebp) <--- now we confirmed offset 0x4 is x memory space
80483d1: c7 45 f8 23 00 00 00 movl $0x23,-0x8(%ebp) <---- offset 0x8 is y memory space
80483d8: 8b 55 f8 mov -0x8(%ebp),%edx <------load Y to register edx
80483db: 8b 4d fc mov -0x4(%ebp),%ecx <------- load X to register ecx
80483de: 8d 04 0a lea (%edx,%ecx,1),%eax <----- reg eax = edx( y value) + ecx(x value) + 1 (?)
80483e1: 89 45 fc mov %eax,-0x4(%ebp) <---- reg eax load to X memory space( correct here )....
80483e4: 8d 42 01 lea 0x1(%edx),%eax <----- eax = edx + 1
80483e7: 89 45 f8 mov %eax,-0x8(%ebp) <------- reg eax load to Y memory space (valie y++)
80483ea: 8d 41 01 lea 0x1(%ecx),%eax <------eax = ecx + 1; (value 20 +1 )
80483ed: 89 45 fc mov %eax,-0x4(%ebp) <-------- load to X memory again !!!!!!!!! wrong..!!!!!!!
80483f0: 8b 45 f8 mov -0x8(%ebp),%eax
80483f3: 83 c0 01 add $0x1,%eax
80483f6: 89 45 f8 mov %eax,-0x8(%ebp)
80483f9: 8b 55 f8 mov -0x8(%ebp),%edx
80483fc: 8b 45 fc mov -0x4(%ebp),%eax
80483ff: 83 c0 01 add $0x1,%eax
8048402: 89 45 fc mov %eax,-0x4(%ebp)
8048405: 8b 45 fc mov -0x4(%ebp),%eax
8048408: 8d 04 02 lea (%edx,%eax,1),%eax
804840b: 89 45 f8 mov %eax,-0x8(%ebp)
804840e: 8b 45 f8 mov -0x8(%ebp),%eax
8048411: 8b 55 fc mov -0x4(%ebp),%edx
8048414: 89 44 24 08 mov %eax,0x8(%esp)
8048418: 89 54 24 04 mov %edx,0x4(%esp)
804841c: c7 04 24 10 85 04 08 movl $0x8048510,(%esp)
8048423: e8 d0 fe ff ff call 80482f8 <printf@plt>
8048428: c9 leave
8048429: c3 ret
...
＜本文发表于: 相约加拿大:枫下论坛 www.rolia.net/forum ＞更多精彩文章及讨论，请光临枫下论坛 rolia.net
http://en.wikibooks.org/wiki/X86_Disassembly/Functions_and_Stack_Frames

"google一把，就蒙对了答案".. LOL..不会编程，还是会google的。 -mikesmith(老猫); 2009-7-16 (#5422879@0)
lea (%edx,%ecx,1),%eax = ecx * 1 + edx -> eax. -canadiantire(轮胎 - Cornelius); 2009-7-16 (#5423213@0)

ok. thx; this addresses my confusion here. compiler should load the X value into register again before do X++, which is exactly volatile supposed to do. -eagle_no1(瞎起哄); 2009-7-16 (#5423300@0)

刚才在Cygwin的gcc上面试了一下，发现gcc还是牛多了，hehe -canadiantire(轮胎 - Cornelius); 2009-7-16 (#5423528@0)

结果是什么呀？ -eagle_no1(瞎起哄); 2009-7-16 (#5423588@0)

5693 -canadiantire(轮胎 - Cornelius); 2009-7-17 (#5424220@0)
比较搞的是我把你的第一个func放上去想比较一下生成的汇编有啥区别, 结果被gcc优化成这个样子: -canadiantire(轮胎 - Cornelius); 2009-7-17 {170} (#5424237@0)
pushl %ebp
movl $94, %edx
movl %esp, %ebp
movl $57, %eax
subl $24, %esp
movl %edx, 8(%esp)
movl %eax, 4(%esp)
movl $LC0, (%esp)
call _printf
leave
ret

真是有钱有闲又有权啊.我实在没有精力研究这个问题.C还没有认全. -iwantcar_majia(iwantcar); 2009-7-18 (#5426969@0)

好象没有标准答案，不同编译器有不同的实现（没查C标准，不十分肯定）。俺的理解，下面两个答案都应该是正确的： -hubeir(作曲家wannabe); 2009-7-17 {295} (#5424068@0)
Without volatile:

int x = 20, y = 35;
x = y + x;
x++;
y++;
++y;
++x;
y = y + x;

Results are (57, 94)

Or

int x = 20, y = 35;
register A = y + x;
x++; // this increment will be discarded later
y++;
x = register A; // x <-- 55
++y;
++x;
y = y + x;

Results are (56, 93)

加上volatile 限定词之后，又多了一种可能： -hubeir(作曲家wannabe); 2009-7-17 {303} (#5424076@0)
volatile int x = 20;
volatile int y = 35;
reg X <-- x;
reg Y <-- y;
reg Z = reg Y + reg X;
x <-- reg Z;
reg X++;
reg Y++;
x <-- reg X; // the writeback happens because x is volatile. x == 21 here !
y <-- reg Y;

问题的关键在 x = y++ + x++; 一句，x赋值在先，还是加1在先，C标准有明确的规定吗？
no, 5693 should be -eagle_no1(瞎起哄); 2009-7-17 {116} (#5424444@0)
x=x+y
y++
x++
y=x+y
x++
y++

this increment can not be discarded later, it's compiler error again otherwise;
按照操作符优先权来解释这段程序，只有一个答案，5794，没有歧义。得出不同结果的编译器有bug，至少是没有严格遵守C标准。 -baalinca(三碗不过冈十点不上网); 2009-7-17 (#5425488@0)

参考答案 -goodlifeseek(chineseman); 2009-7-25 {323} (#5442265@0)
看了大家的回复，我作为半个电脑工程师，不知道该跟大家说什么好。先公布一下参考答案。
本答案是手算结果，大家可以用电脑校验一下。
build without -O:
both are the same results as:x=57. y=94.

build with -O2 or -O2:
seconds result is: x=57. y=94.
first result is: x=22 y=59

本人今年年底将失业。如果大家有工作，介绍一下。

上面讨论很充分了，编译器相关， x=22 y=59的结果应该是编译器的bug造成的。 -eagle_no1(瞎起哄); 2009-7-25 (#5442284@0)
年底还早着呢，找新工作应该没问题的；：－） -eagle_no1(瞎起哄); 2009-7-25 (#5442289@0)

volatile + x=x + optimization 真可怕 -frankwoo(柳五随风); 2009-9-18 (#5558409@0)
我来回答这个问题：在C（或者C++）语言的标准里，有一个概念称为sequence point，请进来看…… -perryuan(perryuan); 2009-10-25 {2081} (#5633086@0)
本文发表在 rolia.net 枫下论坛　　C语言1999年标准（ISO-IEC 9899:1999）的第十三页：

Evaluation of an expression may produce side effects. At certain specified points in the execution sequence called sequence points, all side effects of previous evaluations shall be complete and no side effects of subsequent evaluations shall have taken place.

In the abstract machine, all expressions are evaluated as specified by the semantics. An actual implementation need not evaluate part of an expression if it can deduce that its value is not used and that no needed side effects are produced (including any caused by calling a function or accessing a volatile object).

　　那就是说，一个表达式中，可以被若干个sequence points分成几个小段（可以称之为子表达式）。在一个子表达式内，如何计算side effects是不确定的，不同的编译器可以采用不同的方法和运算次序。

　　但是，在表达式的计算到达任何一个sequence point 的时刻，在这个sequence point 之前的子表达式的所有的side effects必须全部计算完毕。

　　那么，哪些点是sequence point 呢？第四百三十七页：

— The call to a function, after the arguments have been evaluated.

— The end of the first operand of the following operators: logical AND &&; logical OR ||; conditional ?; comma ,.

— The end of a full declarator: declarators;

— The end of a full expression: an initializer; the expression in an expression statement; the controlling expression of a selection statement (if or switch); the controlling expression of a while or do statement (6.8.5); each of the expressions of a for statement (6.8.5.3); the expression in a return statement.

— Immediately before a library function returns.

— After the actions associated with each formatted input / output function conversion specifier.

— Immediately before and immediately after each call to a comparison function, and also between any call to a comparison function and any movement of the objects passed as arguments to that call.

　　看几个例子：

　　a = ++a;

　　a的值不确定。

　　if( a++ != 0 || b[a] > 5 ) ...

　　布尔表达式的值确定，因为“||”是一个sequence point。更多精彩文章及讨论，请光临枫下论坛 rolia.net

@Las Vegas

贴这个题时，就没把他当成coding style issue; 想问的就是编译器的行为；您的分析，简单化为coding风格不妥，绕开了原来的关键点，所以问题没得到解决；

Replies, comments and Discussions:

More Topics

@Las Vegas

贴这个题时， 就没把他当成coding style issue; 想问的就是编译器的行为； 您的分析，简单化为coding风格不妥，绕开了原来的关键点，所以问题没得到解决；

Replies, comments and Discussions:

More Topics

贴这个题时，就没把他当成coding style issue; 想问的就是编译器的行为；您的分析，简单化为coding风格不妥，绕开了原来的关键点，所以问题没得到解决；