1 // RUN: %clang_cc1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s
2 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
3 // RUN: %clang_cc1 -fopenmp -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
4 // RUN: %clang_cc1 -verify -fopenmp -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s
5 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
6 // RUN: %clang_cc1 -fopenmp -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
7 // expected-no-diagnostics
8 #ifndef HEADER
9 #define HEADER
10 
11 
12 // CHECK-DAG: [[GA:@.+]] = global double 1.000000e+00
13 // CHECK-DAG: [[GB:@.+]] = global double 2.000000e+00
14 // CHECK-DAG: [[GC:@.+]] = global double 3.000000e+00
15 // CHECK-DAG: [[GD:@.+]] = global double 4.000000e+00
16 // CHECK-DAG: [[FA:@.+]] = internal global float 5.000000e+00
17 // CHECK-DAG: [[FB:@.+]] = internal global float 6.000000e+00
18 // CHECK-DAG: [[FC:@.+]] = internal global float 7.000000e+00
19 // CHECK-DAG: [[FD:@.+]] = internal global float 8.000000e+00
20 // CHECK-DAG: [[BA:@.+]] = internal global float 9.000000e+00
21 // CHECK-DAG: [[BB:@.+]] = internal global float 1.000000e+01
22 // CHECK-DAG: [[BC:@.+]] = internal global float 1.100000e+01
23 // CHECK-DAG: [[BD:@.+]] = internal global float 1.200000e+01
24 double Ga = 1.0;
25 double Gb = 2.0;
26 double Gc = 3.0;
27 double Gd = 4.0;
28 
29 // CHECK: define {{.*}} @{{.*}}foo{{.*}}(
30 // CHECK-SAME: i16 {{[^,]*}}[[A:%[^,]+]],
31 // CHECK-SAME: i16 {{[^,]*}}[[B:%[^,]+]],
32 // CHECK-SAME: i16 {{[^,]*}}[[C:%[^,]+]],
33 // CHECK-SAME: i16 {{[^,]*}}[[D:%[^,]+]])
34 // CHECK: [[LA:%.+]] = alloca i16
35 // CHECK: [[LB:%.+]] = alloca i16
36 // CHECK: [[LC:%.+]] = alloca i16
37 // CHECK: [[LD:%.+]] = alloca i16
38 int foo(short a, short b, short c, short d){
39   static float Sa = 5.0;
40   static float Sb = 6.0;
41   static float Sc = 7.0;
42   static float Sd = 8.0;
43 
44   // CHECK-DAG: [[REFB:%.+]] = bitcast i16* [[LB]] to i8*
45   // CHECK-DAG: store i8* [[REFB]], i8** [[GEPB:%.+]], align
46   // CHECK-DAG: [[REFC:%.+]] = bitcast i16* [[LC]] to i8*
47   // CHECK-DAG: store i8* [[REFC]], i8** [[GEPC:%.+]], align
48   // CHECK-DAG: [[REFD:%.+]] = bitcast i16* [[LD]] to i8*
49   // CHECK-DAG: store i8* [[REFD]], i8** [[GEPD:%.+]], align
50   // CHECK-DAG: store i8* bitcast (double* [[GB]] to i8*), i8** [[GEPGB:%.+]], align
51   // CHECK-DAG: store i8* bitcast (double* [[GC]] to i8*), i8** [[GEPGC:%.+]], align
52   // CHECK-DAG: store i8* bitcast (double* [[GD]] to i8*), i8** [[GEPGD:%.+]], align
53   // CHECK-DAG: store i8* bitcast (float* [[FB]] to i8*), i8** [[GEPFB:%.+]], align
54   // CHECK-DAG: store i8* bitcast (float* [[FC]] to i8*), i8** [[GEPFC:%.+]], align
55   // CHECK-DAG: store i8* bitcast (float* [[FD]] to i8*), i8** [[GEPFD:%.+]], align
56   // CHECK-DAG: [[GEPB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
57   // CHECK-DAG: [[GEPC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
58   // CHECK-DAG: [[GEPD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
59   // CHECK-DAG: [[GEPGB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
60   // CHECK-DAG: [[GEPGC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
61   // CHECK-DAG: [[GEPGD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
62   // CHECK-DAG: [[GEPFB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
63   // CHECK-DAG: [[GEPFC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
64   // CHECK-DAG: [[GEPFD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
65   // CHECK: call i32 @__tgt_target
66   // CHECK: call void [[OFFLOADF:@.+]](
67   // Capture b, Gb, Sb, Gc, c, Sc, d, Gd, Sd
68   #pragma omp target if(Ga>0.0 && a>0 && Sa>0.0)
69   {
70     b += 1;
71     Gb += 1.0;
72     Sb += 1.0;
73 
74     // CHECK: define internal void [[OFFLOADF]]({{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}})
75     // The parallel region only uses 3 captures.
76     // CHECK:     call {{.*}}@__kmpc_fork_call(%ident_t* {{.+}}, i32 {{.+}}, void (i32*, i32*, ...)* bitcast ({{.*}}[[PARF:@.+]] to {{.*}}), {{.+}}* %{{.+}}, {{.+}}* %{{.+}}, {{.+}}* %{{.+}})
77     // CHECK:     call void @.omp_outlined.(i32* %{{.+}}, i32* %{{.+}}, {{.+}}* %{{.+}}, {{.+}}* %{{.+}}, {{.+}}* %{{.+}})
78     // Capture d, Gd, Sd,
79 
80     // CHECK: define internal void [[PARF]](i32* noalias %{{.*}}, i32* noalias %{{.*}},
81     #pragma omp parallel if(Gc>0.0 && c>0 && Sc>0.0)
82     {
83       d += 1;
84       Gd += 1.0;
85       Sd += 1.0;
86     }
87   }
88   return a + b + c + d + (int)Sa + (int)Sb + (int)Sc + (int)Sd;
89 }
90 
91 // CHECK: define {{.*}} @{{.*}}bar{{.*}}(
92 // CHECK-SAME: i16 {{[^,]*}}[[A:%[^,]+]],
93 // CHECK-SAME: i16 {{[^,]*}}[[B:%[^,]+]],
94 // CHECK-SAME: i16 {{[^,]*}}[[C:%[^,]+]],
95 // CHECK-SAME: i16 {{[^,]*}}[[D:%[^,]+]])
96 // CHECK: [[LA:%.+]] = alloca i16
97 // CHECK: [[LB:%.+]] = alloca i16
98 // CHECK: [[LC:%.+]] = alloca i16
99 // CHECK: [[LD:%.+]] = alloca i16
100 int bar(short a, short b, short c, short d){
101   static float Sa = 9.0;
102   static float Sb = 10.0;
103   static float Sc = 11.0;
104   static float Sd = 12.0;
105 
106   // CHECK: call void {{.*}}@__kmpc_fork_call(%ident_t* {{.+}}, i32 {{.+}}, void (i32*, i32*, ...)* bitcast ({{.*}}[[PARF:@.+]] to {{.*}}), i16* %{{.+}}, i16* %{{.+}}, i16* %{{.+}}, i16* %{{.+}})
107   // CHECK: define internal void [[PARF]](i32* noalias %{{.*}}, i32* noalias %{{.*}}, i16* dereferenceable(2) [[A:%.+]], i16* dereferenceable(2) [[B:%.+]], i16* dereferenceable(2) [[C:%.+]], i16* dereferenceable(2) [[D:%.+]])
108   // Capture a, b, c, d
109   #pragma omp parallel
110   {
111     // CHECK: [[ADRA:%.+]] = alloca i16*, align
112     // CHECK: [[ADRB:%.+]] = alloca i16*, align
113     // CHECK: [[ADRC:%.+]] = alloca i16*, align
114     // CHECK: [[ADRD:%.+]] = alloca i16*, align
115     // CHECK: store i16* [[A]], i16** [[ADRA]], align
116     // CHECK: store i16* [[B]], i16** [[ADRB]], align
117     // CHECK: store i16* [[C]], i16** [[ADRC]], align
118     // CHECK: store i16* [[D]], i16** [[ADRD]], align
119     // CHECK: [[REFA:%.+]] = load i16*, i16** [[ADRA]],
120     // CHECK: [[REFB:%.+]] = load i16*, i16** [[ADRB]],
121     // CHECK: [[REFC:%.+]] = load i16*, i16** [[ADRC]],
122     // CHECK: [[REFD:%.+]] = load i16*, i16** [[ADRD]],
123 
124     // CHECK: load float, float* [[BA]]
125 
126     // CHECK-DAG: [[CSTB:%.+]] = bitcast i16* [[REFB]] to i8*
127     // CHECK-DAG: [[CSTC:%.+]] = bitcast i16* [[REFC]] to i8*
128     // CHECK-DAG: [[CSTD:%.+]] = bitcast i16* [[REFD]] to i8*
129     // CHECK-DAG: store i8* [[CSTB]], i8** [[GEPB:%.+]], align
130     // CHECK-DAG: store i8* [[CSTC]], i8** [[GEPC:%.+]], align
131     // CHECK-DAG: store i8* [[CSTD]], i8** [[GEPD:%.+]], align
132     // CHECK-DAG: store i8* bitcast (double* [[GB]] to i8*), i8** [[GEPGB:%.+]], align
133     // CHECK-DAG: store i8* bitcast (double* [[GC]] to i8*), i8** [[GEPGC:%.+]], align
134     // CHECK-DAG: store i8* bitcast (double* [[GD]] to i8*), i8** [[GEPGD:%.+]], align
135     // CHECK-DAG: store i8* bitcast (float* [[BB]] to i8*), i8** [[GEPBB:%.+]], align
136     // CHECK-DAG: store i8* bitcast (float* [[BC]] to i8*), i8** [[GEPBC:%.+]], align
137     // CHECK-DAG: store i8* bitcast (float* [[BD]] to i8*), i8** [[GEPBD:%.+]], align
138 
139     // CHECK-DAG: [[GEPB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
140     // CHECK-DAG: [[GEPC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
141     // CHECK-DAG: [[GEPD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
142     // CHECK-DAG: [[GEPGB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
143     // CHECK-DAG: [[GEPGC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
144     // CHECK-DAG: [[GEPGD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
145     // CHECK-DAG: [[GEPBB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
146     // CHECK-DAG: [[GEPBC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
147     // CHECK-DAG: [[GEPBD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{.+}}
148     // CHECK: call i32 @__tgt_target
149     // CHECK: call void [[OFFLOADF:@.+]](
150     // Capture b, Gb, Sb, Gc, c, Sc, d, Gd, Sd
151     #pragma omp target if(Ga>0.0 && a>0 && Sa>0.0)
152     {
153       b += 1;
154       Gb += 1.0;
155       Sb += 1.0;
156 
157       // CHECK: define internal void [[OFFLOADF]]({{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}}, {{.+}}* {{.*}}%{{.+}})
158       // CHECK: call void {{.*}}@__kmpc_fork_call(%ident_t* {{.+}}, i32 {{.+}}, void (i32*, i32*, ...)* bitcast ({{.*}}[[PARF:@.+]] to {{.*}})
159 
160       // CHECK: define internal void [[PARF]](i32* noalias %{{.*}}, i32* noalias %{{.*}}, {{.+}}* dereferenceable({{.+}}) %{{.+}}, {{.+}}* dereferenceable({{.+}}) %{{.+}}, {{.+}}* dereferenceable({{.+}}) %{{.+}})
161       // Capture d, Gd, Sd
162       #pragma omp parallel if(Gc>0.0 && c>0 && Sc>0.0)
163       {
164         d += 1;
165         Gd += 1.0;
166         Sd += 1.0;
167       }
168     }
169   }
170   return a + b + c + d + (int)Sa + (int)Sb + (int)Sc + (int)Sd;
171 }
172 
173 #endif
174