C - Optimization Boundary with Inline Assembly? - c

Question

Consider following code:
// String literals
#define _def0Impl(a0) #a0
#define _def0(a0) _def0Impl(a0)
// Labels
#define _asm_label(tag) tag: asm volatile (_def0(tag) ":")
// Assume 32 bits
typedef unsigned int uptr;
int main (int argc, void *argv[]) {
register int ctr, var;
uptr tbl[0x4];
ctr = 0x0;
var = 0x0;
// Push some tasks to tbl ...
// Suppose that tbl holds {&&tag0, &&tag1, &&tag2, &&tag1}
// Suppose that ctr holds 0xC
// tag* may exported to somewhere else.
ctr = 0x3 * sizeof(uptr);
tbl[0x0] = &&tag0;
tbl[0x1] = &&tag1;
tbl[0x2] = &&tag2;
tbl[0x3] = &&tag1;
// Run tasks table
goto *(((uptr)&tbl[0x0]) + ctr);
_asm_label(tag2);
// Task I
ctr -= sizeof(uptr);
var += 0x1;
goto *(((uptr)&tbl[0x0]) + ctr);
_asm_label(tag1);
// Task II
ctr -= sizeof(uptr);
var -= 0x1;
goto *(((uptr)&tbl[0x0]) + ctr);
_asm_label(tag0);
// Continue executation
return var;
}
Can I re-write this implementation with inline assembly?
Old statement
Consider following code:
#define _asm_label(tag) asm volatile(tag ":")
// PowerPC for example
#define _asm_jump(tag) asm volatile ("b " tag)
#define _asm_bar() asm volatile ("" ::: "cc", "memory")
int main(int argc, void *argv[]) {
register int var;
var = 0;
_asm_jump("bar");
_asm_bar(); // Boundary
var += 1;
_asm_label("bar");
_asm_bar(); // Boundary
var += 1;
return var;
}
With -O0 gcc generates:
li 30,0
b bar
# 0 "" 2
addi 30,30,1
bar:
# 0 "" 2
addi 30,30,1
mr 9,30
mr 3,9 # r3 = 0x1
But with -O2:
b bar
# 0 "" 2
bar:
# 0 "" 2
lwz 0,12(1) # restore link register
li 3,2 # incorrect
The output is incorrect since the statements get optimized out.
Are there any ways to make a "barrier" of optimization in GCC?
Edit : Attempt #1
Adding volatile to var.
With -O2:
li 9,0
stw 9,8(1)
# 10 "attempt1.c" 1
b bar
# 0 "" 2
lwz 9,8(1)
addi 9,9,1
stw 9,8(1)
# 15 "attempt1.c" 1
bar:
# 0 "" 2
lwz 9,8(1)
lwz 0,28(1)
addi 9,9,1
stw 9,8(1)
In this case, var is put into stack (r1 + 0x8).
However, put volatile on var will stop all optimization about var.
I am thinking about make use of asm goto, but it is only available on gcc >= 4.5, iirc.

Answer 1

The output is incorrect
The output is completely fine, your code is not correct.
Are there any ways to make a "barrier" of optimization in GCC?
The best you can get is
__asm volatile ("" ::: "memory", <more-clobbers>)
However, that doesn't fix your wrong code. The code is wrong because the inline asm has side effects you don't tell the compiler, this will almost certainly bite you sooner or later. If jumping is what you want, then like so:
int func (void)
{
int var = 0;
__asm volatile goto ("b %0" :::: labl);
var += 1;
labl:;
var += 1;
return var;
}
Generated code:
func:
# 5 "b.c" 1
b .L3
# 0 "" 2
li 3,2
blr
.p2align 4,,15
.L3:
.L2:
li 3,1
blr