Clang Project

clang_source_code/test/CodeGen/vla.c
1// RUN: %clang_cc1 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s -check-prefixes=CHECK,NULL-INVALID
2// RUN: %clang_cc1 -triple i386-unknown-unknown %s -emit-llvm -fno-delete-null-pointer-checks -o - | FileCheck %s -check-prefixes=CHECK,NULL-VALID
3
4int b(char* x);
5
6// Extremely basic VLA test
7void a(int x) {
8  char arry[x];
9  arry[0] = 10;
10  b(arry);
11}
12
13int c(int n)
14{
15  return sizeof(int[n]);
16}
17
18int f0(int x) {
19  int vla[x];
20  return vla[x-1];
21}
22
23void
24f(int count)
25{
26 int a[count];
27
28  do {  } while (0);
29
30  if (a[0] != 3) {
31  }
32}
33
34void g(int count) {
35  // Make sure we emit sizes correctly in some obscure cases
36  int (*a[5])[count];
37  int (*b)[][count];
38}
39
40// rdar://8403108
41// CHECK-LABEL: define void @f_8403108
42void f_8403108(unsigned x) {
43  // CHECK: call i8* @llvm.stacksave()
44  char s1[x];
45  while (1) {
46    // CHECK: call i8* @llvm.stacksave()
47    char s2[x];
48    if (1)
49      break;
50  // CHECK: call void @llvm.stackrestore(i8*
51  }
52  // CHECK: call void @llvm.stackrestore(i8*
53}
54
55// pr7827
56void function(short width, int data[][width]) {} // expected-note {{passing argument to parameter 'data' here}}
57
58void test() {
59     int bork[4][13];
60     // CHECK: call void @function(i16 signext 1, i32* null)
61     function(1, 0);
62     // CHECK: call void @function(i16 signext 1, i32* inttoptr
63     function(1, 0xbadbeef); // expected-warning {{incompatible integer to pointer conversion passing}}
64     // CHECK: call void @function(i16 signext 1, i32* {{.*}})
65     function(1, bork);
66}
67
68void function1(short width, int data[][width][width]) {}
69void test1() {
70     int bork[4][13][15];
71     // CHECK: call void @function1(i16 signext 1, i32* {{.*}})
72     function1(1, bork);
73     // CHECK: call void @function(i16 signext 1, i32* {{.*}}) 
74     function(1, bork[2]);
75}
76
77// rdar://8476159
78static int GLOB;
79int test2(int n)
80{
81  GLOB = 0;
82  char b[1][n+3]; /* Variable length array.  */
83  // CHECK:  [[tmp_1:%.*]] = load i32, i32* @GLOB, align 4
84  // CHECK-NEXT: add nsw i32 [[tmp_1]], 1
85  __typeof__(b[GLOB++]) c;
86  return GLOB;
87}
88
89// http://llvm.org/PR8567
90// CHECK-LABEL: define double @test_PR8567
91double test_PR8567(int n, double (*p)[n][5]) {
92  // CHECK:      [[NV:%.*]] = alloca i32, align 4
93  // CHECK-NEXT: [[PV:%.*]] = alloca [5 x double]*, align 4
94  // CHECK-NEXT: store
95  // CHECK-NEXT: store
96  // CHECK-NEXT: [[N:%.*]] = load i32, i32* [[NV]], align 4
97  // CHECK-NEXT: [[P:%.*]] = load [5 x double]*, [5 x double]** [[PV]], align 4
98  // CHECK-NEXT: [[T0:%.*]] = mul nsw i32 1, [[N]]
99  // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [5 x double], [5 x double]* [[P]], i32 [[T0]]
100  // CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds [5 x double], [5 x double]* [[T1]], i32 2
101  // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [5 x double], [5 x double]* [[T2]], i32 0, i32 3
102  // CHECK-NEXT: [[T4:%.*]] = load double, double* [[T3]]
103  // CHECK-NEXT: ret double [[T4]]
104 return p[1][2][3];
105}
106
107int test4(unsigned n, char (*p)[n][n+1][6]) {
108  // CHECK-LABEL:    define i32 @test4(
109  // CHECK:      [[N:%.*]] = alloca i32, align 4
110  // CHECK-NEXT: [[P:%.*]] = alloca [6 x i8]*, align 4
111  // CHECK-NEXT: [[P2:%.*]] = alloca [6 x i8]*, align 4
112  // CHECK-NEXT: store i32
113  // CHECK-NEXT: store [6 x i8]*
114
115  // VLA captures.
116  // CHECK-NEXT: [[DIM0:%.*]] = load i32, i32* [[N]], align 4
117  // CHECK-NEXT: [[T0:%.*]] = load i32, i32* [[N]], align 4
118  // CHECK-NEXT: [[DIM1:%.*]] = add i32 [[T0]], 1
119
120  // CHECK-NEXT: [[T0:%.*]] = load [6 x i8]*, [6 x i8]** [[P]], align 4
121  // CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[N]], align 4
122  // CHECK-NEXT: [[T2:%.*]] = udiv i32 [[T1]], 2
123  // CHECK-NEXT: [[T3:%.*]] = mul nuw i32 [[DIM0]], [[DIM1]]
124  // CHECK-NEXT: [[T4:%.*]] = mul nsw i32 [[T2]], [[T3]]
125  // CHECK-NEXT: [[T5:%.*]] = getelementptr inbounds [6 x i8], [6 x i8]* [[T0]], i32 [[T4]]
126  // CHECK-NEXT: [[T6:%.*]] = load i32, i32* [[N]], align 4
127  // CHECK-NEXT: [[T7:%.*]] = udiv i32 [[T6]], 4
128  // CHECK-NEXT: [[T8:%.*]] = sub i32 0, [[T7]]
129  // CHECK-NEXT: [[T9:%.*]] = mul nuw i32 [[DIM0]], [[DIM1]]
130  // CHECK-NEXT: [[T10:%.*]] = mul nsw i32 [[T8]], [[T9]]
131  // CHECK-NEXT: [[T11:%.*]] = getelementptr inbounds [6 x i8], [6 x i8]* [[T5]], i32 [[T10]]
132  // CHECK-NEXT: store [6 x i8]* [[T11]], [6 x i8]** [[P2]], align 4
133  __typeof(p) p2 = (p + n/2) - n/4;
134
135  // CHECK-NEXT: [[T0:%.*]] = load [6 x i8]*, [6 x i8]** [[P2]], align 4
136  // CHECK-NEXT: [[T1:%.*]] = load [6 x i8]*, [6 x i8]** [[P]], align 4
137  // CHECK-NEXT: [[T2:%.*]] = ptrtoint [6 x i8]* [[T0]] to i32
138  // CHECK-NEXT: [[T3:%.*]] = ptrtoint [6 x i8]* [[T1]] to i32
139  // CHECK-NEXT: [[T4:%.*]] = sub i32 [[T2]], [[T3]]
140  // CHECK-NEXT: [[T5:%.*]] = mul nuw i32 [[DIM0]], [[DIM1]]
141  // CHECK-NEXT: [[T6:%.*]] = mul nuw i32 6, [[T5]]
142  // CHECK-NEXT: [[T7:%.*]] = sdiv exact i32 [[T4]], [[T6]]
143  // CHECK-NEXT: ret i32 [[T7]]
144  return p2 - p;
145}
146
147// rdar://11485774
148void test5(void)
149{
150  // CHECK-LABEL: define void @test5(
151  int a[5], i = 0;
152  // CHECK: [[A:%.*]] = alloca [5 x i32], align 4
153  // CHECK-NEXT: [[I:%.*]] = alloca i32, align 4
154  // CHECK-NEXT: [[CL:%.*]] = alloca i32*, align 4
155  // CHECK-NEXT: store i32 0, i32* [[I]], align 4
156
157  (typeof(++i, (int (*)[i])a)){&a} += 0;
158  // CHECK-NEXT: [[Z:%.*]] = load i32, i32* [[I]], align 4
159  // CHECK-NEXT: [[INC:%.*]]  = add nsw i32 [[Z]], 1
160  // CHECK-NEXT: store i32 [[INC]], i32* [[I]], align 4
161  // CHECK-NEXT: [[O:%.*]] = load i32, i32* [[I]], align 4
162  // CHECK-NEXT: [[AR:%.*]] = getelementptr inbounds [5 x i32], [5 x i32]* [[A]], i32 0, i32 0
163  // CHECK-NEXT: [[T:%.*]] = bitcast [5 x i32]* [[A]] to i32*
164  // CHECK-NEXT: store i32* [[T]], i32** [[CL]]
165  // CHECK-NEXT: [[TH:%.*]] = load i32*, i32** [[CL]]
166  // CHECK-NEXT: [[VLAIX:%.*]] = mul nsw i32 0, [[O]]
167  // CHECK-NEXT: [[ADDPTR:%.*]] = getelementptr inbounds i32, i32* [[TH]], i32 [[VLAIX]]
168  // CHECK-NEXT: store i32* [[ADDPTR]], i32** [[CL]]
169}
170
171void test6(void)
172{
173  // CHECK-LABEL: define void @test6(
174  int n = 20, **a, i=0;
175  // CHECK: [[N:%.*]] = alloca i32, align 4
176  // CHECK-NEXT: [[A:%.*]] = alloca i32**, align 4
177  // CHECK-NEXT: [[I:%.*]] = alloca i32, align 4
178 (int (**)[i]){&a}[0][1][5] = 0;
179  // CHECK-NEXT: [[CL:%.*]] = alloca i32**, align 4
180  // CHECK-NEXT: store i32 20, i32* [[N]], align 4
181  // CHECK-NEXT: store i32 0, i32* [[I]], align 4
182  // CHECK-NEXT: [[Z:%.*]] = load i32, i32* [[I]], align 4
183  // CHECK-NEXT: [[O:%.*]] = bitcast i32*** [[A]] to i32**
184  // CHECK-NEXT: store i32** [[O]], i32*** [[CL]]
185  // CHECK-NEXT: [[T:%.*]] = load i32**, i32*** [[CL]]
186  // CHECK-NEXT: [[IX:%.*]] = getelementptr inbounds i32*, i32** [[T]], i32 0
187  // CHECK-NEXT: [[TH:%.*]] = load i32*, i32** [[IX]], align 4
188  // CHECK-NEXT: [[F:%.*]] = mul nsw i32 1, [[Z]]
189  // CHECK-NEXT: [[IX1:%.*]] = getelementptr inbounds i32, i32* [[TH]], i32 [[F]]
190  // CHECK-NEXT: [[IX2:%.*]] = getelementptr inbounds i32, i32* [[IX1]], i32 5
191  // CHECK-NEXT: store i32 0, i32* [[IX2]], align 4
192}
193
194// Follow gcc's behavior for VLAs in parameter lists.  PR9559.
195void test7(int a[b(0)]) {
196  // CHECK-LABEL: define void @test7(
197  // CHECK: call i32 @b(i8* null)
198}
199
200// Make sure we emit dereferenceable or nonnull when the static keyword is
201// provided.
202void test8(int a[static 3]) { }
203// CHECK: define void @test8(i32* dereferenceable(12) %a)
204
205void test9(int n, int a[static n]) { }
206// NULL-INVALID: define void @test9(i32 %n, i32* nonnull %a)
207// NULL-VALID: define void @test9(i32 %n, i32* %a)
208
209
CodeThinker, Enjoy your reading code