Clang Project

clang_source_code/test/AST/float16.cpp
1// RUN: %clang_cc1 -std=c++11 -ast-dump -triple aarch64-linux-gnu %s | FileCheck %s --strict-whitespace
2// RUN: %clang_cc1 -std=c++11 -ast-dump -triple aarch64-linux-gnu -fnative-half-type %s | FileCheck %s --check-prefix=CHECK-NATIVE --strict-whitespace
3
4/*  Various contexts where type _Float16 can appear. */
5
6/*  Namespace */
7namespace {
8  _Float16 f1n;
9  _Float16 f2n = 33.f16;
10  _Float16 arr1n[10];
11  _Float16 arr2n[] = { 1.2, 3.0, 3.e4 };
12  const volatile _Float16 func1n(const _Float16 &arg) {
13    return arg + f2n + arr1n[4] - arr2n[1];
14  }
15}
16
17//CHECK:      |-NamespaceDecl
18//CHECK-NEXT: | |-VarDecl {{.*}} f1n '_Float16'
19//CHECK-NEXT: | |-VarDecl {{.*}} f2n '_Float16' cinit
20//CHECK-NEXT: | | `-FloatingLiteral {{.*}} '_Float16' 3.300000e+01
21//CHECK-NEXT: | |-VarDecl {{.*}} arr1n '_Float16 [10]'
22//CHECK-NEXT: | |-VarDecl {{.*}} arr2n '_Float16 [3]' cinit
23//CHECK-NEXT: | | `-InitListExpr {{.*}} '_Float16 [3]'
24//CHECK-NEXT: | |   |-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
25//CHECK-NEXT: | |   | `-FloatingLiteral {{.*}} 'double' 1.200000e+00
26//CHECK-NEXT: | |   |-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
27//CHECK-NEXT: | |   | `-FloatingLiteral {{.*}} 'double' 3.000000e+00
28//CHECK-NEXT: | |   `-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
29//CHECK-NEXT: | |     `-FloatingLiteral {{.*}} 'double' 3.000000e+04
30//CHECK-NEXT: | `-FunctionDecl {{.*}} func1n 'const volatile _Float16 (const _Float16 &)'
31
32/* File */
33_Float16 f1f;
34_Float16 f2f = 32.4;
35_Float16 arr1f[10];
36_Float16 arr2f[] = { -1.2, -3.0, -3.e4 };
37_Float16 func1f(_Float16 arg);
38
39//CHECK:      |-VarDecl {{.*}} f1f '_Float16'
40//CHECK-NEXT: |-VarDecl {{.*}} f2f '_Float16' cinit
41//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
42//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'double' 3.240000e+01
43//CHECK-NEXT: |-VarDecl {{.*}} arr1f '_Float16 [10]'
44//CHECK-NEXT: |-VarDecl {{.*}} arr2f '_Float16 [3]' cinit
45//CHECK-NEXT: | `-InitListExpr {{.*}} '_Float16 [3]'
46//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
47//CHECK-NEXT: |   | `-UnaryOperator {{.*}} 'double' prefix '-'
48//CHECK-NEXT: |   |   `-FloatingLiteral {{.*}} 'double' 1.200000e+00
49//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
50//CHECK-NEXT: |   | `-UnaryOperator {{.*}} 'double' prefix '-'
51//CHECK-NEXT: |   |   `-FloatingLiteral {{.*}} 'double' 3.000000e+00
52//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
53//CHECK-NEXT: |     `-UnaryOperator {{.*}} 'double' prefix '-'
54//CHECK-NEXT: |       `-FloatingLiteral {{.*}} 'double' 3.000000e+04
55//CHECK-NEXT: |-FunctionDecl {{.*}} func1f '_Float16 (_Float16)'
56//CHECK-NEXT: | `-ParmVarDecl {{.*}} arg '_Float16'
57
58
59// Mixing __fp16 and Float16 types:
60// The _Float16 type is first converted to __fp16 type and then the operation
61// is completed as if both operands were of __fp16 type.
62
63__fp16 B = -0.1;
64auto C = -1.0f16 + B;
65
66// When we do *not* have native half types, we expect __fp16 to be promoted to
67// float, and consequently also _Float16 promotions to float:
68
69//CHECK:      -VarDecl {{.*}} used B '__fp16' cinit
70//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} '__fp16' <FloatingCast>
71//CHECK-NEXT: |   `-UnaryOperator {{.*}} 'double' prefix '-'
72//CHECK-NEXT: |     `-FloatingLiteral {{.*}} 'double' 1.000000e-01
73//CHECK-NEXT: |-VarDecl {{.*}} C 'float':'float' cinit
74//CHECK-NEXT: | `-BinaryOperator {{.*}} 'float' '+'
75//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'float' <FloatingCast>
76//CHECK-NEXT: |   | `-UnaryOperator {{.*}} '_Float16' prefix '-'
77//CHECK-NEXT: |   |   `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
78//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'float' <FloatingCast>
79//CHECK-NEXT: |     `-ImplicitCastExpr {{.*}} '__fp16' <LValueToRValue>
80//CHECK-NEXT: |       `-DeclRefExpr {{.*}} '__fp16' lvalue Var 0x{{.*}} 'B' '__fp16'
81
82// When do have native half types, we expect to see promotions to fp16:
83
84//CHECK-NATIVE: |-VarDecl {{.*}} used B '__fp16' cinit
85//CHECK-NATIVE: | `-ImplicitCastExpr {{.*}} '__fp16' <FloatingCast>
86//CHECK-NATIVE: |   `-UnaryOperator {{.*}} 'double' prefix '-'
87//CHECK-NATIVE: |     `-FloatingLiteral {{.*}} 'double' 1.000000e-01
88//CHECK-NATIVE: |-VarDecl {{.*}} C '__fp16':'__fp16' cinit
89//CHECK-NATIVE: | `-BinaryOperator {{.*}} '__fp16' '+'
90//CHECK-NATIVE: |   |-ImplicitCastExpr {{.*}} '__fp16' <FloatingCast>
91//CHECK-NATIVE: |   | `-UnaryOperator {{.*}} '_Float16' prefix '-'
92//CHECK-NATIVE: |   |   `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
93//CHECK-NATIVE: |   `-ImplicitCastExpr {{.*}} '__fp16' <LValueToRValue>
94//CHECK-NATIVE: |     `-DeclRefExpr {{.*}} '__fp16' lvalue Var 0x{{.*}} 'B' '__fp16'
95
96
97/* Class */
98
99class C1 {
100  _Float16 f1c;
101  static const _Float16 f2c;
102  volatile _Float16 f3c;
103public:
104  C1(_Float16 arg) : f1c(arg), f3c(arg) { }
105  _Float16 func1c(_Float16 arg ) {
106    return f1c + arg;
107  }
108  static _Float16 func2c(_Float16 arg) {
109    return arg * C1::f2c;
110  }
111};
112
113//CHECK:      |-CXXRecordDecl {{.*}} referenced class C1 definition
114//CHECK:      | |-CXXRecordDecl {{.*}} implicit referenced class C1
115//CHECK-NEXT: | |-FieldDecl {{.*}} referenced f1c '_Float16'
116//CHECK-NEXT: | |-VarDecl {{.*}} used f2c 'const _Float16' static
117//CHECK-NEXT: | |-FieldDecl {{.*}} f3c 'volatile _Float16'
118//CHECK-NEXT: | |-AccessSpecDecl
119//CHECK-NEXT: | |-CXXConstructorDecl {{.*}} used C1 'void (_Float16)
120//CHECK-NEXT: | | |-ParmVarDecl {{.*}} used arg '_Float16'
121//CHECK-NEXT: | | |-CXXCtorInitializer Field {{.*}} 'f1c' '_Float16'
122//CHECK-NEXT: | | | `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
123//CHECK-NEXT: | | |   `-DeclRefExpr {{.*}} '_Float16' lvalue ParmVar 0x{{.*}} 'arg' '_Float16'
124//CHECK-NEXT: | | |-CXXCtorInitializer Field {{.*}} 'f3c' 'volatile _Float16'
125//CHECK-NEXT: | | | `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
126//CHECK-NEXT: | | |   `-DeclRefExpr {{.*}} '_Float16' lvalue ParmVar 0x{{.*}} 'arg' '_Float16'
127//CHECK-NEXT: | | `-CompoundStmt
128//CHECK-NEXT: | |-CXXMethodDecl {{.*}} used func1c '_Float16 (_Float16)
129//CHECK-NEXT: | | |-ParmVarDecl {{.*}} used arg '_Float16'
130//CHECK-NEXT: | | `-CompoundStmt
131//CHECK-NEXT: | |   `-ReturnStmt
132//CHECK-NEXT: | |     `-BinaryOperator {{.*}} '_Float16' '+'
133//CHECK-NEXT: | |       |-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
134//CHECK-NEXT: | |       | `-MemberExpr {{.*}} '_Float16' lvalue ->f1c 0x{{.*}}
135//CHECK-NEXT: | |       |   `-CXXThisExpr {{.*}} 'C1 *' implicit this
136//CHECK-NEXT: | |       `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
137//CHECK-NEXT: | |         `-DeclRefExpr {{.*}} '_Float16' lvalue ParmVar 0x{{.*}} 'arg' '_Float16'
138//CHECK-NEXT: | |-CXXMethodDecl {{.*}} used func2c '_Float16 (_Float16)' static
139//CHECK-NEXT: | | |-ParmVarDecl {{.*}} used arg '_Float16'
140//CHECK-NEXT: | | `-CompoundStmt
141//CHECK-NEXT: | |   `-ReturnStmt
142//CHECK-NEXT: | |     `-BinaryOperator {{.*}} '_Float16' '*'
143//CHECK-NEXT: | |       |-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
144//CHECK-NEXT: | |       | `-DeclRefExpr {{.*}} '_Float16' lvalue ParmVar 0x{{.*}} 'arg' '_Float16'
145//CHECK-NEXT: | |       `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
146//CHECK-NEXT: | |         `-DeclRefExpr {{.*}} 'const _Float16' lvalue Var 0x{{.*}} 'f2c' 'const _Float16'
147
148
149/*  Template */
150
151template <class C> C func1t(C arg) {
152  return arg * 2.f16;
153}
154
155//CHECK:      |-FunctionTemplateDecl {{.*}} func1t
156//CHECK-NEXT: | |-TemplateTypeParmDecl {{.*}} C
157//CHECK-NEXT: | |-FunctionDecl {{.*}} func1t 'C (C)'
158//CHECK-NEXT: | | |-ParmVarDecl {{.*}} referenced arg 'C'
159//CHECK-NEXT: | | `-CompoundStmt
160//CHECK-NEXT: | |   `-ReturnStmt
161//CHECK-NEXT: | |     `-BinaryOperator {{.*}} '<dependent type>' '*'
162//CHECK-NEXT: | |       |-DeclRefExpr {{.*}} 'C' lvalue ParmVar {{.*}} 'arg' 'C'
163//CHECK-NEXT: | |       `-FloatingLiteral {{.*}} '_Float16' 2.000000e+00
164//CHECK-NEXT: | `-FunctionDecl {{.*}} used func1t '_Float16 (_Float16)'
165//CHECK-NEXT: |   |-TemplateArgument type '_Float16'
166//CHECK-NEXT: |   |-ParmVarDecl {{.*}} used arg '_Float16':'_Float16'
167//CHECK-NEXT: |   `-CompoundStmt
168//CHECK-NEXT: |     `-ReturnStmt
169//CHECK-NEXT: |       `-BinaryOperator {{.*}} '_Float16' '*'
170//CHECK-NEXT: |         |-ImplicitCastExpr {{.*}} '_Float16':'_Float16' <LValueToRValue>
171//CHECK-NEXT: |         | `-DeclRefExpr {{.*}} '_Float16':'_Float16' lvalue ParmVar {{.*}} 'arg' '_Float16':'_Float16'
172//CHECK-NEXT: |         `-FloatingLiteral {{.*}} '_Float16' 2.000000e+00
173
174
175template <class C> struct S1 {
176  C mem1;
177};
178
179//CHECK:      |-ClassTemplateDecl {{.*}} S1
180//CHECK-NEXT: | |-TemplateTypeParmDecl {{.*}} referenced class depth 0 index 0 C
181//CHECK-NEXT: | |-CXXRecordDecl {{.*}} struct S1 definition
182//CHECK:      | | |-CXXRecordDecl {{.*}} implicit struct S1
183//CHECK-NEXT: | | `-FieldDecl {{.*}} mem1 'C'
184//CHECK-NEXT: | `-ClassTemplateSpecialization {{.*}} 'S1'
185
186template <> struct S1<_Float16> {
187  _Float16 mem2;
188};
189
190
191/* Local */
192
193extern int printf (const char *__restrict __format, ...);
194
195int main(void) {
196  _Float16 f1l = 1e3f16;
197//CHECK:       | `-VarDecl {{.*}} used f1l '_Float16' cinit
198//CHECK-NEXT:  |   `-FloatingLiteral {{.*}} '_Float16' 1.000000e+03
199
200  _Float16 f2l = -0.f16;
201//CHECK:       | `-VarDecl {{.*}} used f2l '_Float16' cinit
202//CHECK-NEXT:  |   `-UnaryOperator {{.*}} '_Float16' prefix '-'
203//CHECK-NEXT:  |     `-FloatingLiteral {{.*}} '_Float16' 0.000000e+00
204
205  _Float16 f3l = 1.000976562;
206//CHECK:       | `-VarDecl {{.*}} used f3l '_Float16' cinit
207//CHECK-NEXT:  |   `-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
208//CHECK-NEXT:  |     `-FloatingLiteral {{.*}} 'double' 1.000977e+00
209
210  C1 c1(f1l);
211//CHECK:       | `-VarDecl{{.*}} used c1 'C1' callinit
212//CHECK-NEXT:  |   `-CXXConstructExpr {{.*}} 'C1' 'void (_Float16)
213//CHECK-NEXT:  |     `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
214//CHECK-NEXT:  |       `-DeclRefExpr {{.*}} '_Float16' lvalue Var 0x{{.*}} 'f1l' '_Float16'
215
216  S1<_Float16> s1 = { 132.f16 };
217//CHECK:       | `-VarDecl {{.*}} used s1 'S1<_Float16>':'S1<_Float16>' cinit
218//CHECK-NEXT:  |   `-InitListExpr {{.*}} 'S1<_Float16>':'S1<_Float16>'
219//CHECK-NEXT:  |     `-FloatingLiteral {{.*}} '_Float16' 1.320000e+02
220
221  _Float16 f4l = func1n(f1l)  + func1f(f2l) + c1.func1c(f3l) + c1.func2c(f1l) +
222    func1t(f1l) + s1.mem2 - f1n + f2n;
223//CHECK:       | `-VarDecl {{.*}} used f4l '_Float16' cinit
224//CHECK-NEXT:  |   `-BinaryOperator {{.*}} '_Float16' '+'
225//CHECK-NEXT:  |     |-BinaryOperator {{.*}} '_Float16' '-'
226//CHECK-NEXT:  |     | |-BinaryOperator {{.*}} '_Float16' '+'
227//CHECK-NEXT:  |     | | |-BinaryOperator {{.*}} '_Float16' '+'
228//CHECK-NEXT:  |     | | | |-BinaryOperator {{.*}} '_Float16' '+'
229//CHECK-NEXT:  |     | | | | |-BinaryOperator {{.*}} '_Float16' '+'
230//CHECK-NEXT:  |     | | | | | |-BinaryOperator {{.*}} '_Float16' '+'
231//CHECK-NEXT:  |     | | | | | | |-CallExpr {{.*}} '_Float16'
232//CHECK-NEXT:  |     | | | | | | | |-ImplicitCastExpr {{.*}} 'const volatile _Float16 (*)(const _Float16 &)' <FunctionToPointerDecay>
233//CHECK-NEXT:  |     | | | | | | | | `-DeclRefExpr {{.*}} 'const volatile _Float16 (const _Float16 &)' lvalue Function {{.*}} 'func1n' 'const volatile _Float16 (const _Float16 &)'
234//CHECK-NEXT:  |     | | | | | | | `-ImplicitCastExpr {{.*}} 'const _Float16' lvalue <NoOp>
235//CHECK-NEXT:  |     | | | | | | |   `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f1l' '_Float16'
236//CHECK-NEXT:  |     | | | | | | `-CallExpr {{.*}} '_Float16'
237//CHECK-NEXT:  |     | | | | | |   |-ImplicitCastExpr {{.*}} '_Float16 (*)(_Float16)' <FunctionToPointerDecay>
238//CHECK-NEXT:  |     | | | | | |   | `-DeclRefExpr {{.*}} '_Float16 (_Float16)' lvalue Function {{.*}} 'func1f' '_Float16 (_Float16)'
239//CHECK-NEXT:  |     | | | | | |   `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
240//CHECK-NEXT:  |     | | | | | |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f2l' '_Float16'
241//CHECK-NEXT:  |     | | | | | `-CXXMemberCallExpr {{.*}} '_Float16'
242//CHECK-NEXT:  |     | | | | |   |-MemberExpr {{.*}} '<bound member function type>' .func1c {{.*}}
243//CHECK-NEXT:  |     | | | | |   | `-DeclRefExpr {{.*}} 'C1' lvalue Var {{.*}} 'c1' 'C1'
244//CHECK-NEXT:  |     | | | | |   `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
245//CHECK-NEXT:  |     | | | | |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f3l' '_Float16'
246//CHECK-NEXT:  |     | | | | `-CallExpr {{.*}} '_Float16'
247//CHECK-NEXT:  |     | | | |   |-ImplicitCastExpr {{.*}} '_Float16 (*)(_Float16)' <FunctionToPointerDecay>
248//CHECK-NEXT:  |     | | | |   | `-MemberExpr {{.*}} '_Float16 (_Float16)' lvalue .func2c {{.*}}
249//CHECK-NEXT:  |     | | | |   |   `-DeclRefExpr {{.*}} 'C1' lvalue Var {{.*}} 'c1' 'C1'
250//CHECK-NEXT:  |     | | | |   `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
251//CHECK-NEXT:  |     | | | |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f1l' '_Float16'
252//CHECK-NEXT:  |     | | | `-CallExpr {{.*}} '_Float16':'_Float16'
253//CHECK-NEXT:  |     | | |   |-ImplicitCastExpr {{.*}} '_Float16 (*)(_Float16)' <FunctionToPointerDecay>
254//CHECK-NEXT:  |     | | |   | `-DeclRefExpr {{.*}} '_Float16 (_Float16)' lvalue Function {{.*}} 'func1t' '_Float16 (_Float16)' (FunctionTemplate {{.*}} 'func1t')
255//CHECK-NEXT:  |     | | |   `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
256//CHECK-NEXT:  |     | | |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f1l' '_Float16'
257//CHECK-NEXT:  |     | | `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
258//CHECK-NEXT:  |     | |   `-MemberExpr {{.*}} '_Float16' lvalue .mem2 {{.*}}
259//CHECK-NEXT:  |     | |     `-DeclRefExpr {{.*}} 'S1<_Float16>':'S1<_Float16>' lvalue Var {{.*}} 's1' 'S1<_Float16>':'S1<_Float16>'
260//CHECK-NEXT:  |     | `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
261//CHECK-NEXT:  |     |   `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f1n' '_Float16'
262//CHECK-NEXT:  |     `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
263//CHECK-NEXT:  |       `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f2n' '_Float16'
264
265  auto f5l = -1.f16, *f6l = &f2l, f7l = func1t(f3l);
266//CHECK:       | |-VarDecl {{.*}} f5l '_Float16':'_Float16' cinit
267//CHECK-NEXT:  | | `-UnaryOperator {{.*}} '_Float16' prefix '-'
268//CHECK-NEXT:  | |   `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
269//CHECK-NEXT:  | |-VarDecl {{.*}} f6l '_Float16 *' cinit
270//CHECK-NEXT:  | | `-UnaryOperator {{.*}} '_Float16 *' prefix '&'
271//CHECK-NEXT:  | |   `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f2l' '_Float16'
272//CHECK-NEXT:  | `-VarDecl {{.*}} f7l '_Float16':'_Float16' cinit
273//CHECK-NEXT:  |   `-CallExpr {{.*}} '_Float16':'_Float16'
274//CHECK-NEXT:  |     |-ImplicitCastExpr {{.*}} '_Float16 (*)(_Float16)' <FunctionToPointerDecay>
275//CHECK-NEXT:  |     | `-DeclRefExpr {{.*}} '_Float16 (_Float16)' lvalue Function {{.*}} 'func1t' '_Float16 (_Float16)' (FunctionTemplate {{.*}} 'func1t')
276//CHECK-NEXT:  |     `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
277//CHECK-NEXT:  |       `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f3l' '_Float16'
278
279  _Float16 f8l = f4l++;
280//CHECK:       | `-VarDecl {{.*}} f8l '_Float16' cinit
281//CHECK-NEXT:  |   `-UnaryOperator {{.*}} '_Float16' postfix '++'
282//CHECK-NEXT:  |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f4l' '_Float16'
283
284  _Float16 arr1l[] = { -1.f16, -0.f16, -11.f16 };
285//CHECK:       `-VarDecl {{.*}} arr1l '_Float16 [3]' cinit
286//CHECK-NEXT:    `-InitListExpr {{.*}} '_Float16 [3]'
287//CHECK-NEXT:      |-UnaryOperator {{.*}} '_Float16' prefix '-'
288//CHECK-NEXT:      | `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
289//CHECK-NEXT:      |-UnaryOperator {{.*}} '_Float16' prefix '-'
290//CHECK-NEXT:      | `-FloatingLiteral {{.*}} '_Float16' 0.000000e+00
291//CHECK-NEXT:      `-UnaryOperator {{.*}} '_Float16' prefix '-'
292//CHECK-NEXT:        `-FloatingLiteral {{.*}} '_Float16' 1.100000e+01
293
294  float cvtf = f2n;
295//CHECK:       `-VarDecl {{.*}} cvtf 'float' cinit
296//CHECK-NEXT:    `-ImplicitCastExpr {{.*}} 'float' <FloatingCast>
297//CHECK-NEXT:      `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
298//CHECK-NEXT:        `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f2n' '_Float16'
299
300  double cvtd = f2n;
301//CHECK:       `-VarDecl {{.*}} cvtd 'double' cinit
302//CHECK-NEXT:    `-ImplicitCastExpr {{.*}} 'double' <FloatingCast>
303//CHECK-NEXT:      `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
304//CHECK-NEXT:        `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f2n' '_Float16'
305
306  long double cvtld = f2n;
307//CHECK:       `-VarDecl {{.*}} cvtld 'long double' cinit
308//CHECK-NEXT:    `-ImplicitCastExpr {{.*}} 'long double' <FloatingCast>
309//CHECK-NEXT:      `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
310//CHECK-NEXT:        `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f2n' '_Float16'
311
312  _Float16 f2h = 42.0f;
313//CHECK:       `-VarDecl {{.*}} f2h '_Float16' cinit
314//CHECK-NEXT:    `-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
315//CHECK-NEXT:      `-FloatingLiteral {{.*}} 'float' 4.200000e+01
316
317  _Float16 d2h = 42.0;
318//CHECK:       `-VarDecl {{.*}} d2h '_Float16' cinit
319//CHECK-NEXT:    `-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
320//CHECK-NEXT:      `-FloatingLiteral {{.*}} 'double' 4.200000e+01
321
322  _Float16 ld2h = 42.0l;
323//CHECK:       `-VarDecl {{.*}} ld2h '_Float16' cinit
324//CHECK-NEXT:    `-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
325//CHECK-NEXT:      `-FloatingLiteral {{.*}} 'long double' 4.200000e+01
326}
327
CodeThinker, Enjoy your reading code