test/CodeGen/vla.c

   1 // RUN: %clang_cc1 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s
   2
   3 int b(char* x);
   4
   5 // Extremely basic VLA test
   6 void a(int x) {
   7   char arry[x];
   8   arry[0] = 10;
   9   b(arry);
  10 }
  11
  12 int c(int n)
  13 {
  14   return sizeof(int[n]);
  15 }
  16
  17 int f0(int x) {
  18   int vla[x];
  19   return vla[x-1];
  20 }
  21
  22 void
  23 f(int count)
  24 {
  25  int a[count];
  26
  27   do {  } while (0);
  28
  29   if (a[0] != 3) {
  30   }
  31 }
  32
  33 void g(int count) {
  34   // Make sure we emit sizes correctly in some obscure cases
  35   int (*a[5])[count];
  36   int (*b)[][count];
  37 }
  38
  39 // rdar://8403108
  40 // CHECK: define void @f_8403108
  41 void f_8403108(unsigned x) {
  42   // CHECK: call i8* @llvm.stacksave()
  43   char s1[x];
  44   while (1) {
  45     // CHECK: call i8* @llvm.stacksave()
  46     char s2[x];
  47     if (1)
  48       break;
  49   // CHECK: call void @llvm.stackrestore(i8*
  50   }
  51   // CHECK: call void @llvm.stackrestore(i8*
  52 }
  53
  54 // pr7827
  55 void function(short width, int data[][width]) {} // expected-note {{passing argument to parameter 'data' here}}
  56
  57 void test() {
  58      int bork[4][13];
  59      // CHECK: call void @function(i16 signext 1, i32* null)
  60      function(1, 0);
  61      // CHECK: call void @function(i16 signext 1, i32* inttoptr
  62      function(1, 0xbadbeef); // expected-warning {{incompatible integer to pointer conversion passing}}
  63      // CHECK: call void @function(i16 signext 1, i32* {{.*}})
  64      function(1, bork);
  65 }
  66
  67 void function1(short width, int data[][width][width]) {}
  68 void test1() {
  69      int bork[4][13][15];
  70      // CHECK: call void @function1(i16 signext 1, i32* {{.*}})
  71      function1(1, bork);
  72      // CHECK: call void @function(i16 signext 1, i32* {{.*}})
  73      function(1, bork[2]);
  74 }
  75
  76 // rdar://8476159
  77 static int GLOB;
  78 int test2(int n)
  79 {
  80   GLOB = 0;
  81   char b[1][n+3];                       /* Variable length array.  */
  82   // CHECK:  [[tmp_1:%.*]] = load i32* @GLOB, align 4
  83   // CHECK-NEXT: add nsw i32 [[tmp_1]], 1
  84   __typeof__(b[GLOB++]) c;
  85   return GLOB;
  86 }
  87
  88 // http://llvm.org/PR8567
  89 // CHECK: define double @test_PR8567
  90 double test_PR8567(int n, double (*p)[n][5]) {
  91   // CHECK:      [[NV:%.*]] = alloca i32, align 4
  92   // CHECK-NEXT: [[PV:%.*]] = alloca [5 x double]*, align 4
  93   // CHECK-NEXT: store
  94   // CHECK-NEXT: store
  95   // CHECK-NEXT: [[N:%.*]] = load i32* [[NV]], align 4
  96   // CHECK-NEXT: [[P:%.*]] = load [5 x double]** [[PV]], align 4
  97   // CHECK-NEXT: [[T0:%.*]] = mul nsw i32 1, [[N]]
  98   // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [5 x double]* [[P]], i32 [[T0]]
  99   // CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds [5 x double]* [[T1]], i32 2
 100   // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [5 x double]* [[T2]], i32 0, i32 3
 101   // CHECK-NEXT: [[T4:%.*]] = load double* [[T3]]
 102   // CHECK-NEXT: ret double [[T4]]
 103  return p[1][2][3];
 104 }
 105
 106 int test4(unsigned n, char (*p)[n][n+1][6]) {
 107   // CHECK:    define i32 @test4(
 108   // CHECK:      [[N:%.*]] = alloca i32, align 4
 109   // CHECK-NEXT: [[P:%.*]] = alloca [6 x i8]*, align 4
 110   // CHECK-NEXT: [[P2:%.*]] = alloca [6 x i8]*, align 4
 111   // CHECK-NEXT: store i32
 112   // CHECK-NEXT: store [6 x i8]*
 113
 114   // VLA captures.
 115   // CHECK-NEXT: [[DIM0:%.*]] = load i32* [[N]], align 4
 116   // CHECK-NEXT: [[T0:%.*]] = load i32* [[N]], align 4
 117   // CHECK-NEXT: [[DIM1:%.*]] = add i32 [[T0]], 1
 118
 119   // __typeof.  FIXME: does this really need to be loaded?
 120   // CHECK-NEXT: load [6 x i8]** [[P]]
 121
 122   // CHECK-NEXT: [[T0:%.*]] = load [6 x i8]** [[P]], align 4
 123   // CHECK-NEXT: [[T1:%.*]] = load i32* [[N]], align 4
 124   // CHECK-NEXT: [[T2:%.*]] = udiv i32 [[T1]], 2
 125   // CHECK-NEXT: [[T3:%.*]] = mul nuw i32 [[DIM0]], [[DIM1]]
 126   // CHECK-NEXT: [[T4:%.*]] = mul nsw i32 [[T2]], [[T3]]
 127   // CHECK-NEXT: [[T5:%.*]] = getelementptr inbounds [6 x i8]* [[T0]], i32 [[T4]]
 128   // CHECK-NEXT: [[T6:%.*]] = load i32* [[N]], align 4
 129   // CHECK-NEXT: [[T7:%.*]] = udiv i32 [[T6]], 4
 130   // CHECK-NEXT: [[T8:%.*]] = sub i32 0, [[T7]]
 131   // CHECK-NEXT: [[T9:%.*]] = mul nuw i32 [[DIM0]], [[DIM1]]
 132   // CHECK-NEXT: [[T10:%.*]] = mul nsw i32 [[T8]], [[T9]]
 133   // CHECK-NEXT: [[T11:%.*]] = getelementptr inbounds [6 x i8]* [[T5]], i32 [[T10]]
 134   // CHECK-NEXT: store [6 x i8]* [[T11]], [6 x i8]** [[P2]], align 4
 135   __typeof(p) p2 = (p + n/2) - n/4;
 136
 137   // CHECK-NEXT: [[T0:%.*]] = load [6 x i8]** [[P2]], align 4
 138   // CHECK-NEXT: [[T1:%.*]] = load [6 x i8]** [[P]], align 4
 139   // CHECK-NEXT: [[T2:%.*]] = ptrtoint [6 x i8]* [[T0]] to i32
 140   // CHECK-NEXT: [[T3:%.*]] = ptrtoint [6 x i8]* [[T1]] to i32
 141   // CHECK-NEXT: [[T4:%.*]] = sub i32 [[T2]], [[T3]]
 142   // CHECK-NEXT: [[T5:%.*]] = mul nuw i32 [[DIM0]], [[DIM1]]
 143   // CHECK-NEXT: [[T6:%.*]] = mul nuw i32 6, [[T5]]
 144   // CHECK-NEXT: [[T7:%.*]] = sdiv exact i32 [[T4]], [[T6]]
 145   // CHECK-NEXT: ret i32 [[T7]]
 146   return p2 - p;
 147 }