llvm dev - Sep 2007 - [LLVMdev] volatiles

The attached file contains some simple functions that manipulate volatile 
varibles.  The functions near the top of the file should turn into code 
that loads from x and then stores to it.  The LLVM version on the web (not 
sure if it's the latest...) gets most of these wrong.

John Regehr
-------------- next part --------------
////////////////////////////////////////////////////////////////////////

// typedef unsigned int t;
typedef int t;

volatile t x;

void self_assign_1 (void)
{
  x = x;
}

void self_assign_2 (void)
{
  t sink = x;
  x = sink;
}

void self_assign_3 (void)
{
  volatile t *xp = &x;
  *xp = *xp;
}

void self_assign_4 (void)
{
  volatile t *xp = &x;
  t sink = *xp;
  *xp = sink;
}

void self_assign_5 (void)
{
  volatile t *xp1 = &x;
  volatile t *xp2 = &x;
  *xp1 = *xp2;
}

void self_assign_6 (void)
{
  volatile t *xp = &x;
  volatile t **xpp = &xp;
  t sink = **xpp;
  **xpp = sink;
}

void self_assign_7 (void)
{
  volatile t *xp1 = &x;
  volatile t *xp2 = &x;
  volatile t **xpp1 = &xp1;
  volatile t **xpp2 = &xp2;
  **xpp1 = **xpp2;
}

void self_assign_8 (void)
{
  volatile t *xp = &x;
  volatile t **xpp = &xp;
  t sink = *xp;
  **xpp = sink;
}

void self_assign_9 (void)
{
  volatile t *xp1 = &x;
  volatile t *xp2 = &x;
  volatile t **xpp2 = &xp2;
  *xp1 = **xpp2;
}

void self_assign_10 (void)
{
  volatile t *xp = &x;
  volatile t **xpp = &xp;
  t sink = **xpp;
  *xp = sink;
}

void self_assign_11 (void)
{
  volatile t *xp1 = &x;
  volatile t *xp2 = &x;
  volatile t **xpp1 = &xp1;
  **xpp1 = *xp2;
}

void or_1 (void)
{
  x |= 0;
}

void or_2 (void)
{
  x = x | 0;
}

void or_3 (void)
{
  t sink = x | 0;
  x = sink;
}

void or_4 (void)
{
  t zero = 0;
  t sink = x | zero;
  x = sink;
}

void or_5 (void)
{
  volatile t zero = 0;
  t sink = x | zero;
  x = sink;
}

void or_6 (void)
{
  t zero = 0;
  volatile t sink = x | zero;
  x = sink;
}

void and_1 (void)
{
  x &= ~0;
}

void and_2 (void)
{
  x = x & ~0;
}

void and_3 (void)
{
  t sink = x & ~0;
  x = sink;
}

void and_4 (void)
{
  t not_zero = ~0;
  t sink = x & not_zero;
  x = sink;
}

void and_5 (void)
{
  volatile t not_zero = ~0;
  t sink = x & not_zero;
  x = sink;
}

void and_6 (void)
{
  t not_zero = ~0;
  volatile t sink = x & not_zero;
  x = sink;
}

volatile t y;

void loop_1 (void)
{
  t i;
  t result = y;
  for (i=0; i<10; i++) {
    result += x;
  }
  y = result;
}

void loop_2 (void)
{
  t i;
  for (i=0; i<10; i++) {
    x += 3;
  }
}

void loop_3 (void)
{
  t i;
  volatile t z;
  for (i=0; i<10; i++) {
    z += 3;
  }
}

void loop_4 (t n)
{
  t b;
  t res = 0;
  for (b=0; b<n; b++) {
    res += x;
  }
}

void loop_5 (t n)
{
  t b;
  t res = n;
  for (b=0; b<n; b++) {
    x += res;
  }
}

void load_only_1 (void)
{
  x;
}

void load_only_2 (void)
{
  1 && x;
}

void load_only_3 (void)
{
  1 && x && 0;
}

void load_only_4 (void)
{
  1 && x && 0 && x;
}

void load_only_5 (void)
{
  0 || x;
}

void load_only_6 (void)
{
  0 || x || 1;
}

void load_only_7 (void)
{
  0 || x || 1 || x;
}

int my_true = 1;
int my_false = 0;

void load_only_8 (void)
{
  my_true && x;
}

void load_only_9 (void)
{
  my_true && x && my_false;
}

void load_only_10 (void)
{
  my_true && x && my_false && x;
}

void load_only_11 (void)
{
  my_false || x;
}

void load_only_12 (void)
{
  my_false || x || my_true;
}

void load_only_13 (void)
{
  my_false || x || my_true || x;
}

volatile int vol_my_true = 1;
volatile int vol_my_false = 0;

void load_only_14 (void)
{
  vol_my_true && x;
}

void load_only_15 (void)
{
  vol_my_true && x && vol_my_false;
}

void load_only_16 (void)
{
  vol_my_true && x && vol_my_false && x;
}

void load_only_17 (void)
{
  vol_my_false || x;
}

void load_only_18 (void)
{
  vol_my_false || x || vol_my_true;
}

void load_only_19 (void)
{
  vol_my_false || x || vol_my_true || x;
}

////////////////////////////////////////////////////////////////////////

On Sep 11, 2007, at 3:49 PM, John Regehr wrote:
> The attached file contains some simple functions that manipulate  
> volatile
> varibles.  The functions near the top of the file should turn into  
> code
> that loads from x and then stores to it.  The LLVM version on the  
> web (not
> sure if it's the latest...) gets most of these wrong.
Hi John,

This appears to work with mainline llvm.  The web page is from LLVM  
2.0.  When LLVM 2.1 is released we'll update it.  For reference, here  
is the output of mainline, please let me know if you see any problems:

$ llvm-gcc test_volatile.c -emit-llvm -O3 -S -o test_volatile.ll

-------------- next part --------------
A non-text attachment was scrubbed...
Name: test_volatile.ll
Type: application/octet-stream
Size: 17432 bytes
Desc: not available
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20070911/bc78985d/attachment.obj>
-------------- next part --------------

Thanks!

-Chris

> This appears to work with mainline llvm.  The web page is from LLVM 2.0. 
When
> LLVM 2.1 is released we'll update it.  For reference, here is the
output of
> mainline, please let me know if you see any problems:
Excellent -- yes, this output looks good!

John Regehr