1 // RUN: %clang_cc1 -verify -fopenmp -x c++ -std=c++14 -fexceptions -fcxx-exceptions %s -ast-print -o - -Wno-source-uses-openmp -Wno-openmp-clauses | FileCheck %s
2 
3 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -std=c++14 -fexceptions -fcxx-exceptions %s -ast-print -o - -Wno-source-uses-openmp -Wno-openmp-clauses | FileCheck %s
4 
5 // expected-no-diagnostics
6 
7 // CHECK: int foo();
8 int foo();
9 
10 // CHECK:      template <typename T> T foofoo() {
11 // CHECK-NEXT: return T();
12 // CHECK-NEXT: }
13 template <typename T>
14 T foofoo() { return T(); }
15 
16 // CHECK:      template<> int foofoo<int>() {
17 // CHECK-NEXT: return int();
18 // CHECK-NEXT: }
19 
20 // CHECK:      #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(5):ibm)},device={kind(fpga)})
21 // CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(0):unknown)})
22 // CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(0):llvm)},device={kind(cpu)})
23 // CHECK-NEXT: int bar();
24 #pragma omp declare variant(foofoo <int>) match(xxx = {})
25 #pragma omp declare variant(foofoo <int>) match(xxx = {vvv})
26 #pragma omp declare variant(foofoo <int>) match(implementation={vendor(llvm), xxx}, device={kind(cpu)})
27 #pragma omp declare variant(foofoo <int>) match(implementation={vendor(unknown)})
28 #pragma omp declare variant(foofoo <int>) match(implementation={vendor(score(5): ibm)}, device={kind(fpga)})
29 int bar();
30 
31 // CHECK:      #pragma omp declare variant(foofoo<T>) match(implementation={vendor(score(C + 5):ibm, xxx)},device={kind(cpu, host)})
32 // CHECK-NEXT: #pragma omp declare variant(foofoo<T>) match(implementation={vendor(score(0):unknown)})
33 // CHECK-NEXT: #pragma omp declare variant(foofoo<T>) match(implementation={vendor(score(0):llvm)},device={kind(cpu)})
34 // CHECK-NEXT: template <typename T, int C> T barbar();
35 #pragma omp declare variant(foofoo <T>) match(xxx = {})
36 #pragma omp declare variant(foofoo <T>) match(xxx = {vvv})
37 #pragma omp declare variant(foofoo <T>) match(user = {score(<expr>) : condition(<expr>)})
38 #pragma omp declare variant(foofoo <T>) match(user = {score(<expr>) : condition(<expr>)})
39 #pragma omp declare variant(foofoo <T>) match(user = {condition(<expr>)})
40 #pragma omp declare variant(foofoo <T>) match(user = {condition(<expr>)})
41 #pragma omp declare variant(foofoo <T>) match(implementation={vendor(llvm)},device={kind(cpu)})
42 #pragma omp declare variant(foofoo <T>) match(implementation={vendor(unknown)})
43 #pragma omp declare variant(foofoo <T>) match(implementation={vendor(score(C+5): ibm, xxx, ibm)},device={kind(cpu,host)})
44 template <typename T, int C>
45 T barbar();
46 
47 // CHECK:      #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(3 + 5):ibm, xxx)},device={kind(cpu, host)})
48 // CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(0):unknown)})
49 // CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(0):llvm)},device={kind(cpu)})
50 // CHECK-NEXT: template<> int barbar<int, 3>();
51 
52 // CHECK-NEXT: int baz() {
53 // CHECK-NEXT: return barbar<int, 3>();
54 // CHECK-NEXT: }
55 int baz() {
56   return barbar<int, 3>();
57 }
58 
59 // CHECK:      template <class C> void h_ref(C *hp, C *hp2, C *hq, C *lin) {
60 // CHECK-NEXT: }
61 // CHECK-NEXT: template<> void h_ref<double>(double *hp, double *hp2, double *hq, double *lin) {
62 // CHECK-NEXT: }
63 // CHECK-NEXT: template<> void h_ref<float>(float *hp, float *hp2, float *hq, float *lin) {
64 // CHECK-NEXT: }
65 template <class C>
66 void h_ref(C *hp, C *hp2, C *hq, C *lin) {
67 }
68 
69 // CHECK:      #pragma omp declare variant(h_ref<C>) match(implementation={vendor(score(0):unknown)},device={kind(nohost)})
70 // CHECK-NEXT: #pragma omp declare variant(h_ref<C>) match(implementation={vendor(score(0):llvm)},device={kind(gpu)})
71 // CHECK-NEXT: template <class C> void h(C *hp, C *hp2, C *hq, C *lin) {
72 // CHECK-NEXT: }
73 #pragma omp declare variant(h_ref <C>) match(xxx = {})
74 #pragma omp declare variant(h_ref <C>) match(implementation={vendor(llvm)}, device={kind(gpu)})
75 #pragma omp declare variant(h_ref <C>) match(implementation={vendor(unknown)},device={kind(nohost)})
76 template <class C>
77 void h(C *hp, C *hp2, C *hq, C *lin) {
78 }
79 
80 // CHECK:      #pragma omp declare variant(h_ref<float>) match(implementation={vendor(score(0):unknown)},device={kind(nohost)})
81 // CHECK-NEXT: #pragma omp declare variant(h_ref<float>) match(implementation={vendor(score(0):llvm)},device={kind(gpu)})
82 // CHECK-NEXT: template<> void h<float>(float *hp, float *hp2, float *hq, float *lin) {
83 // CHECK-NEXT: }
84 
85 // CHECK-NEXT: template<> void h<double>(double *hp, double *hp2, double *hq, double *lin) {
86 // CHECK-NEXT:   h((float *)hp, (float *)hp2, (float *)hq, (float *)lin);
87 // CHECK-NEXT: }
88 #pragma omp declare variant(h_ref <double>) match(xxx = {})
89 #pragma omp declare variant(h_ref <double>) match(implementation={vendor(ibm)},device={kind(cpu,gpu)})
90 #pragma omp declare variant(h_ref <double>) match(implementation={vendor(unknown)})
91 template <>
92 void h(double *hp, double *hp2, double *hq, double *lin) {
93   h((float *)hp, (float *)hp2, (float *)hq, (float *)lin);
94 }
95 
96 // CHECK: int fn();
97 int fn();
98 // CHECK: int fn(int);
99 int fn(int);
100 // CHECK:      #pragma omp declare variant(fn) match(implementation={vendor(score(0):unknown)},device={kind(cpu, gpu)})
101 // CHECK-NEXT: #pragma omp declare variant(fn) match(implementation={vendor(score(0):llvm)})
102 // CHECK-NEXT: int overload();
103 #pragma omp declare variant(fn) match(xxx = {})
104 #pragma omp declare variant(fn) match(implementation={vendor(llvm)})
105 #pragma omp declare variant(fn) match(implementation={vendor(unknown)},device={kind(cpu,gpu)})
106 int overload(void);
107 
108 // CHECK:      int fn_deduced_variant() {
109 // CHECK-NEXT: return 0;
110 // CHECK-NEXT: }
111 auto fn_deduced_variant() { return 0; }
112 // CHECK:      #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(score(0):unknown)},device={kind(gpu, nohost)})
113 // CHECK-NEXT: #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(score(0):llvm)},device={kind(cpu, host)})
114 // CHECK-NEXT: int fn_deduced();
115 #pragma omp declare variant(fn_deduced_variant) match(xxx = {})
116 #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(llvm)},device={kind(cpu,host)})
117 #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(unknown)},device={kind(gpu,nohost)})
118 int fn_deduced();
119 
120 // CHECK: int fn_deduced_variant1();
121 int fn_deduced_variant1();
122 // CHECK:      #pragma omp declare variant(fn_deduced_variant1) match(implementation={vendor(score(0):unknown)},device={kind(cpu, host)})
123 // CHECK-NEXT: #pragma omp declare variant(fn_deduced_variant1) match(implementation={vendor(score(0):ibm)},device={kind(gpu, nohost)})
124 // CHECK-NEXT: int fn_deduced1() {
125 // CHECK-NEXT: return 0;
126 // CHECK-NEXT: }
127 #pragma omp declare variant(fn_deduced_variant1) match(xxx = {})
128 #pragma omp declare variant(fn_deduced_variant1) match(implementation={vendor(ibm)},device={kind(gpu,nohost)})
129 #pragma omp declare variant(fn_deduced_variant1) match(implementation={vendor(unknown)},device={kind(cpu,host)})
130 auto fn_deduced1() { return 0; }
131 
132 // CHECK:      struct SpecialFuncs {
133 // CHECK-NEXT: void vd() {
134 // CHECK-NEXT: }
135 // CHECK-NEXT: SpecialFuncs();
136 // CHECK-NEXT: ~SpecialFuncs() noexcept;
137 // CHECK-NEXT: void baz() {
138 // CHECK-NEXT: }
139 // CHECK-NEXT: void bar() {
140 // CHECK-NEXT: }
141 // CHECK-NEXT: void bar(int) {
142 // CHECK-NEXT: }
143 // CHECK-NEXT: #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(score(0):unknown)},device={kind(nohost)})
144 // CHECK-NEXT: #pragma omp declare variant(SpecialFuncs::bar) match(implementation={vendor(score(0):ibm)},device={kind(cpu)})
145 // CHECK-NEXT: void foo1() {
146 // CHECK-NEXT: }
147 // CHECK-NEXT: #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(score(0):unknown)},device={kind(cpu, host)})
148 // CHECK-NEXT: void xxx();
149 // CHECK-NEXT: } s;
150 struct SpecialFuncs {
151   void vd() {}
152   SpecialFuncs();
153   ~SpecialFuncs();
154 
155   void baz() {}
156   void bar() {}
157   void bar(int) {}
158 #pragma omp declare variant(SpecialFuncs::baz) match(xxx = {})
159 #pragma omp declare variant(SpecialFuncs::bar) match(xxx = {})
160 #pragma omp declare variant(SpecialFuncs::bar) match(implementation={vendor(ibm)},device={kind(cpu)})
161 #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(unknown)},device={kind(nohost)})
162   void foo1() {}
163 #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(unknown)},device={kind(cpu, host)})
164   void xxx();
165 } s;
166 
167 // CHECK:      #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(score(0):unknown)},device={kind(cpu, host)})
168 // CHECK-NEXT: void SpecialFuncs::xxx() {
169 // CHECK-NEXT: }
170 void SpecialFuncs::xxx() {}
171 
172 // CHECK:      static void static_f_variant() {
173 // CHECK-NEXT: }
174 static void static_f_variant() {}
175 // CHECK:      #pragma omp declare variant(static_f_variant) match(implementation={vendor(score(0):unknown)})
176 // CHECK-NEXT: #pragma omp declare variant(static_f_variant) match(implementation={vendor(score(0):llvm)},device={kind(fpga)})
177 // CHECK-NEXT: static void static_f() {
178 // CHECK-NEXT: }
179 #pragma omp declare variant(static_f_variant) match(xxx = {})
180 #pragma omp declare variant(static_f_variant) match(implementation={vendor(llvm)},device={kind(fpga)})
181 #pragma omp declare variant(static_f_variant) match(implementation={vendor(unknown)})
182 static void static_f() {}
183 
184 // CHECK: void bazzzz() {
185 // CHECK-NEXT: s.foo1();
186 // CHECK-NEXT: static_f();
187 // CHECK-NEXT: }
188 void bazzzz() {
189   s.foo1();
190   static_f();
191 }
192 
193 // CHECK: int fn_linkage_variant();
194 // CHECK: extern "C" {
195 // CHECK:     #pragma omp declare variant(fn_linkage_variant) match(implementation={vendor(score(0):xxx)},device={kind(cpu, host)})
196 // CHECK:     int fn_linkage();
197 // CHECK: }
198 int fn_linkage_variant();
199 extern "C" {
200 #pragma omp declare variant(fn_linkage_variant) match(implementation = {vendor(xxx)},device={kind(cpu,host)})
201 int fn_linkage();
202 }
203 
204 // CHECK: extern "C" int fn_linkage_variant1()
205 // CHECK: #pragma omp declare variant(fn_linkage_variant1) match(implementation={vendor(score(0):xxx)},device={kind(cpu, host)})
206 // CHECK: int fn_linkage1();
207 extern "C" int fn_linkage_variant1();
208 #pragma omp declare variant(fn_linkage_variant1) match(implementation = {vendor(xxx)},device={kind(cpu,host)})
209 int fn_linkage1();
210 
211