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-LABEL: 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-LABEL: 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-LABEL: 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 // CHECK-NEXT: [[T0:%.*]] = load [6 x i8]** [[P]], align 4 120 // CHECK-NEXT: [[T1:%.*]] = load i32* [[N]], align 4 121 // CHECK-NEXT: [[T2:%.*]] = udiv i32 [[T1]], 2 122 // CHECK-NEXT: [[T3:%.*]] = mul nuw i32 [[DIM0]], [[DIM1]] 123 // CHECK-NEXT: [[T4:%.*]] = mul nsw i32 [[T2]], [[T3]] 124 // CHECK-NEXT: [[T5:%.*]] = getelementptr inbounds [6 x i8]* [[T0]], i32 [[T4]] 125 // CHECK-NEXT: [[T6:%.*]] = load i32* [[N]], align 4 126 // CHECK-NEXT: [[T7:%.*]] = udiv i32 [[T6]], 4 127 // CHECK-NEXT: [[T8:%.*]] = sub i32 0, [[T7]] 128 // CHECK-NEXT: [[T9:%.*]] = mul nuw i32 [[DIM0]], [[DIM1]] 129 // CHECK-NEXT: [[T10:%.*]] = mul nsw i32 [[T8]], [[T9]] 130 // CHECK-NEXT: [[T11:%.*]] = getelementptr inbounds [6 x i8]* [[T5]], i32 [[T10]] 131 // CHECK-NEXT: store [6 x i8]* [[T11]], [6 x i8]** [[P2]], align 4 132 __typeof(p) p2 = (p + n/2) - n/4; 133 134 // CHECK-NEXT: [[T0:%.*]] = load [6 x i8]** [[P2]], align 4 135 // CHECK-NEXT: [[T1:%.*]] = load [6 x i8]** [[P]], align 4 136 // CHECK-NEXT: [[T2:%.*]] = ptrtoint [6 x i8]* [[T0]] to i32 137 // CHECK-NEXT: [[T3:%.*]] = ptrtoint [6 x i8]* [[T1]] to i32 138 // CHECK-NEXT: [[T4:%.*]] = sub i32 [[T2]], [[T3]] 139 // CHECK-NEXT: [[T5:%.*]] = mul nuw i32 [[DIM0]], [[DIM1]] 140 // CHECK-NEXT: [[T6:%.*]] = mul nuw i32 6, [[T5]] 141 // CHECK-NEXT: [[T7:%.*]] = sdiv exact i32 [[T4]], [[T6]] 142 // CHECK-NEXT: ret i32 [[T7]] 143 return p2 - p; 144 } 145 146 // rdar://11485774 147 void test5(void) 148 { 149 // CHECK-LABEL: define void @test5( 150 int a[5], i = 0; 151 // CHECK: [[A:%.*]] = alloca [5 x i32], align 4 152 // CHECK-NEXT: [[I:%.*]] = alloca i32, align 4 153 // CHECK-NEXT: [[CL:%.*]] = alloca i32*, align 4 154 // CHECK-NEXT: store i32 0, i32* [[I]], align 4 155 156 (typeof(++i, (int (*)[i])a)){&a} += 0; 157 // CHECK-NEXT: [[Z:%.*]] = load i32* [[I]], align 4 158 // CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[Z]], 1 159 // CHECK-NEXT: store i32 [[INC]], i32* [[I]], align 4 160 // CHECK-NEXT: [[O:%.*]] = load i32* [[I]], align 4 161 // CHECK-NEXT: [[AR:%.*]] = getelementptr inbounds [5 x i32]* [[A]], i32 0, i32 0 162 // CHECK-NEXT: [[T:%.*]] = bitcast [5 x i32]* [[A]] to i32* 163 // CHECK-NEXT: store i32* [[T]], i32** [[CL]] 164 // CHECK-NEXT: [[TH:%.*]] = load i32** [[CL]] 165 // CHECK-NEXT: [[VLAIX:%.*]] = mul nsw i32 0, [[O]] 166 // CHECK-NEXT: [[ADDPTR:%.*]] = getelementptr inbounds i32* [[TH]], i32 [[VLAIX]] 167 // CHECK-NEXT: store i32* [[ADDPTR]], i32** [[CL]] 168 } 169 170 void test6(void) 171 { 172 // CHECK-LABEL: define void @test6( 173 int n = 20, **a, i=0; 174 // CHECK: [[N:%.*]] = alloca i32, align 4 175 // CHECK-NEXT: [[A:%.*]] = alloca i32**, align 4 176 // CHECK-NEXT: [[I:%.*]] = alloca i32, align 4 177 (int (**)[i]){&a}[0][1][5] = 0; 178 // CHECK-NEXT: [[CL:%.*]] = alloca i32**, align 4 179 // CHECK-NEXT: store i32 20, i32* [[N]], align 4 180 // CHECK-NEXT: store i32 0, i32* [[I]], align 4 181 // CHECK-NEXT: [[Z:%.*]] = load i32* [[I]], align 4 182 // CHECK-NEXT: [[O:%.*]] = bitcast i32*** [[A]] to i32** 183 // CHECK-NEXT: store i32** [[O]], i32*** [[CL]] 184 // CHECK-NEXT: [[T:%.*]] = load i32*** [[CL]] 185 // CHECK-NEXT: [[IX:%.*]] = getelementptr inbounds i32** [[T]], i32 0 186 // CHECK-NEXT: [[TH:%.*]] = load i32** [[IX]], align 4 187 // CHECK-NEXT: [[F:%.*]] = mul nsw i32 1, [[Z]] 188 // CHECK-NEXT: [[IX1:%.*]] = getelementptr inbounds i32* [[TH]], i32 [[F]] 189 // CHECK-NEXT: [[IX2:%.*]] = getelementptr inbounds i32* [[IX1]], i32 5 190 // CHECK-NEXT: store i32 0, i32* [[IX2]], align 4 191 } 192 193 // Follow gcc's behavior for VLAs in parameter lists. PR9559. 194 void test7(int a[b(0)]) { 195 // CHECK-LABEL: define void @test7( 196 // CHECK: call i32 @b(i8* null) 197 } 198