1 // RUN: %clang_cc1 -verify -fopenmp -x c++ -std=c++14 -fexceptions -fcxx-exceptions %s -ast-print -o - -Wno-source-uses-openmp | 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 | 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(unknown)})
21 // CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(ibm)})
22 // CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(llvm)})
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(ibm)}, implementation={vendor(llvm)})
27 #pragma omp declare variant(foofoo <int>) match(implementation={vendor(unknown)})
28 int bar();
29 
30 // CHECK:      #pragma omp declare variant(foofoo<T>) match(implementation={vendor(unknown)})
31 // CHECK-NEXT: #pragma omp declare variant(foofoo<T>) match(implementation={vendor(ibm)})
32 // CHECK-NEXT: #pragma omp declare variant(foofoo<T>) match(implementation={vendor(llvm)})
33 // CHECK-NEXT: template <typename T> T barbar();
34 #pragma omp declare variant(foofoo <T>) match(xxx = {})
35 #pragma omp declare variant(foofoo <T>) match(xxx = {vvv})
36 #pragma omp declare variant(foofoo <T>) match(user = {score(<expr>) : condition(<expr>)})
37 #pragma omp declare variant(foofoo <T>) match(user = {score(<expr>) : condition(<expr>)}, user = {condition(<expr>)})
38 #pragma omp declare variant(foofoo <T>) match(user = {condition(<expr>)})
39 #pragma omp declare variant(foofoo <T>) match(user = {condition(<expr>)})
40 #pragma omp declare variant(foofoo <T>) match(implementation={vendor(ibm)}, implementation={vendor(llvm)})
41 #pragma omp declare variant(foofoo <T>) match(implementation={vendor(unknown)})
42 template <typename T>
43 T barbar();
44 
45 // CHECK:      #pragma omp declare variant(foofoo<int>) match(implementation={vendor(unknown)})
46 // CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(ibm)})
47 // CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(llvm)})
48 // CHECK-NEXT: template<> int barbar<int>();
49 
50 // CHECK-NEXT: int baz() {
51 // CHECK-NEXT: return barbar<int>();
52 // CHECK-NEXT: }
53 int baz() {
54   return barbar<int>();
55 }
56 
57 // CHECK:      template <class C> void h_ref(C *hp, C *hp2, C *hq, C *lin) {
58 // CHECK-NEXT: }
59 // CHECK-NEXT: template<> void h_ref<double>(double *hp, double *hp2, double *hq, double *lin) {
60 // CHECK-NEXT: }
61 // CHECK-NEXT: template<> void h_ref<float>(float *hp, float *hp2, float *hq, float *lin) {
62 // CHECK-NEXT: }
63 template <class C>
64 void h_ref(C *hp, C *hp2, C *hq, C *lin) {
65 }
66 
67 // CHECK:      #pragma omp declare variant(h_ref<C>) match(implementation={vendor(unknown)})
68 // CHECK-NEXT: #pragma omp declare variant(h_ref<C>) match(implementation={vendor(ibm)})
69 // CHECK-NEXT: #pragma omp declare variant(h_ref<C>) match(implementation={vendor(llvm)})
70 // CHECK-NEXT: template <class C> void h(C *hp, C *hp2, C *hq, C *lin) {
71 // CHECK-NEXT: }
72 #pragma omp declare variant(h_ref <C>) match(xxx = {})
73 #pragma omp declare variant(h_ref <C>) match(implementation={vendor(ibm)}, implementation={vendor(llvm)})
74 #pragma omp declare variant(h_ref <C>) match(implementation={vendor(unknown)})
75 template <class C>
76 void h(C *hp, C *hp2, C *hq, C *lin) {
77 }
78 
79 // CHECK:      #pragma omp declare variant(h_ref<float>) match(implementation={vendor(unknown)})
80 // CHECK-NEXT: #pragma omp declare variant(h_ref<float>) match(implementation={vendor(ibm)})
81 // CHECK-NEXT: #pragma omp declare variant(h_ref<float>) match(implementation={vendor(llvm)})
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)}, implementation={vendor(llvm)})
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(unknown)})
101 // CHECK-NEXT: #pragma omp declare variant(fn) match(implementation={vendor(ibm)})
102 // CHECK-NEXT: #pragma omp declare variant(fn) match(implementation={vendor(llvm)})
103 // CHECK-NEXT: int overload();
104 #pragma omp declare variant(fn) match(xxx = {})
105 #pragma omp declare variant(fn) match(implementation={vendor(ibm)}, implementation={vendor(llvm)})
106 #pragma omp declare variant(fn) match(implementation={vendor(unknown)})
107 int overload(void);
108 
109 // CHECK:      int fn_deduced_variant() {
110 // CHECK-NEXT: return 0;
111 // CHECK-NEXT: }
112 auto fn_deduced_variant() { return 0; }
113 // CHECK:      #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(unknown)})
114 // CHECK-NEXT: #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(ibm)})
115 // CHECK-NEXT: #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(llvm)})
116 // CHECK-NEXT: int fn_deduced();
117 #pragma omp declare variant(fn_deduced_variant) match(xxx = {})
118 #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(ibm)}, implementation={vendor(llvm)})
119 #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(unknown)})
120 int fn_deduced();
121 
122 // CHECK: int fn_deduced_variant1();
123 int fn_deduced_variant1();
124 // CHECK:      #pragma omp declare variant(fn_deduced_variant1) match(implementation={vendor(unknown)})
125 // CHECK-NEXT: #pragma omp declare variant(fn_deduced_variant1) match(implementation={vendor(ibm)})
126 // CHECK-NEXT: #pragma omp declare variant(fn_deduced_variant1) match(implementation={vendor(llvm)})
127 // CHECK-NEXT: int fn_deduced1() {
128 // CHECK-NEXT: return 0;
129 // CHECK-NEXT: }
130 #pragma omp declare variant(fn_deduced_variant1) match(xxx = {})
131 #pragma omp declare variant(fn_deduced_variant1) match(implementation={vendor(ibm)}, implementation={vendor(llvm)})
132 #pragma omp declare variant(fn_deduced_variant1) match(implementation={vendor(unknown)})
133 auto fn_deduced1() { return 0; }
134 
135 // CHECK:      struct SpecialFuncs {
136 // CHECK-NEXT: void vd() {
137 // CHECK-NEXT: }
138 // CHECK-NEXT: SpecialFuncs();
139 // CHECK-NEXT: ~SpecialFuncs() noexcept;
140 // CHECK-NEXT: void baz() {
141 // CHECK-NEXT: }
142 // CHECK-NEXT: void bar() {
143 // CHECK-NEXT: }
144 // CHECK-NEXT: void bar(int) {
145 // CHECK-NEXT: }
146 // CHECK-NEXT: #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(unknown)})
147 // CHECK-NEXT: #pragma omp declare variant(SpecialFuncs::bar) match(implementation={vendor(ibm)})
148 // CHECK-NEXT: #pragma omp declare variant(SpecialFuncs::bar) match(implementation={vendor(llvm)})
149 // CHECK-NEXT: void foo1() {
150 // CHECK-NEXT: }
151 // CHECK-NEXT: #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(unknown)})
152 // CHECK-NEXT: void xxx();
153 // CHECK-NEXT: } s;
154 struct SpecialFuncs {
155   void vd() {}
156   SpecialFuncs();
157   ~SpecialFuncs();
158 
159   void baz() {}
160   void bar() {}
161   void bar(int) {}
162 #pragma omp declare variant(SpecialFuncs::baz) match(xxx = {})
163 #pragma omp declare variant(SpecialFuncs::bar) match(xxx = {})
164 #pragma omp declare variant(SpecialFuncs::bar) match(implementation={vendor(ibm)}, implementation={vendor(llvm)})
165 #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(unknown)})
166   void foo1() {}
167 #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(unknown)})
168   void xxx();
169 } s;
170 
171 // CHECK:      #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(unknown)})
172 // CHECK-NEXT: void SpecialFuncs::xxx() {
173 // CHECK-NEXT: }
174 void SpecialFuncs::xxx() {}
175 
176 // CHECK:      static void static_f_variant() {
177 // CHECK-NEXT: }
178 static void static_f_variant() {}
179 // CHECK:      #pragma omp declare variant(static_f_variant) match(implementation={vendor(unknown)})
180 // CHECK-NEXT: #pragma omp declare variant(static_f_variant) match(implementation={vendor(ibm)})
181 // CHECK-NEXT: #pragma omp declare variant(static_f_variant) match(implementation={vendor(llvm)})
182 // CHECK-NEXT: static void static_f() {
183 // CHECK-NEXT: }
184 #pragma omp declare variant(static_f_variant) match(xxx = {})
185 #pragma omp declare variant(static_f_variant) match(implementation={vendor(ibm)}, implementation={vendor(llvm)})
186 #pragma omp declare variant(static_f_variant) match(implementation={vendor(unknown)})
187 static void static_f() {}
188 
189 // CHECK: void bazzzz() {
190 // CHECK-NEXT: s.foo1();
191 // CHECK-NEXT: static_f();
192 // CHECK-NEXT: }
193 void bazzzz() {
194   s.foo1();
195   static_f();
196 }
197