[clang] 2930c83 - [OpenMP][FIX] Allow declare variant to work with reference types
Johannes Doerfert via cfe-commits
cfe-commits at lists.llvm.org
Fri Aug 27 11:12:27 PDT 2021
Author: Johannes Doerfert
Date: 2021-08-27T13:12:14-05:00
New Revision: 2930c839a5877356db6966409f4f9f2cdbcf3a07
URL: https://github.com/llvm/llvm-project/commit/2930c839a5877356db6966409f4f9f2cdbcf3a07
DIFF: https://github.com/llvm/llvm-project/commit/2930c839a5877356db6966409f4f9f2cdbcf3a07.diff
LOG: [OpenMP][FIX] Allow declare variant to work with reference types
Reference types in the return or parameter position did cause the OpenMP
declare variant overload reasoning to give up. We should allow them as
we allow any other type.
This should fix the bug reported on the mailing list:
https://lists.llvm.org/pipermail/openmp-dev/2021-August/004094.html
Reviewed By: ABataev, pdhaliwal
Differential Revision: https://reviews.llvm.org/D108774
Added:
clang/test/AST/ast-dump-openmp-begin-declare-variant_reference.cpp
Modified:
clang/lib/AST/ASTContext.cpp
Removed:
################################################################################
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index 591fa87d1878b..12b5d14f35c63 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -9704,11 +9704,19 @@ static QualType mergeEnumWithInteger(ASTContext &Context, const EnumType *ET,
QualType ASTContext::mergeTypes(QualType LHS, QualType RHS,
bool OfBlockPointer,
bool Unqualified, bool BlockReturnType) {
+ // For C++ we will not reach this code with reference types (see below),
+ // for OpenMP variant call overloading we might.
+ //
// C++ [expr]: If an expression initially has the type "reference to T", the
// type is adjusted to "T" prior to any further analysis, the expression
// designates the object or function denoted by the reference, and the
// expression is an lvalue unless the reference is an rvalue reference and
// the expression is a function call (possibly inside parentheses).
+ if (LangOpts.OpenMP && LHS->getAs<ReferenceType>() &&
+ RHS->getAs<ReferenceType>() && LHS->getTypeClass() == RHS->getTypeClass())
+ return mergeTypes(LHS->getAs<ReferenceType>()->getPointeeType(),
+ RHS->getAs<ReferenceType>()->getPointeeType(),
+ OfBlockPointer, Unqualified, BlockReturnType);
if (LHS->getAs<ReferenceType>() || RHS->getAs<ReferenceType>())
return {};
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_reference.cpp b/clang/test/AST/ast-dump-openmp-begin-declare-variant_reference.cpp
new file mode 100644
index 0000000000000..6fa8cdc59bb40
--- /dev/null
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_reference.cpp
@@ -0,0 +1,414 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify -ast-dump %s | FileCheck %s
+// expected-no-diagnostics
+
+// Our very own std::move, copied from libcxx.
+template <class _Tp> struct remove_reference { typedef _Tp type; };
+template <class _Tp> struct remove_reference<_Tp &> { typedef _Tp type; };
+template <class _Tp> struct remove_reference<_Tp &&> { typedef _Tp type; };
+
+template <class _Tp>
+inline typename remove_reference<_Tp>::type &&
+move(_Tp &&__t) {
+ typedef typename remove_reference<_Tp>::type _Up;
+ return static_cast<_Up &&>(__t);
+}
+// ---
+
+int Good, Bad;
+int &also_before() {
+ return Bad;
+}
+int also_before(float &&) {
+ return 0;
+}
+
+#pragma omp begin declare variant match(implementation = {vendor(score(100) \
+ : llvm)})
+int also_after(void) {
+ return 1;
+}
+int also_after(int &) {
+ return 2;
+}
+// This one does overload the int(*)(double&) version!
+int also_after(double &) {
+ return 0;
+}
+int also_after(double &&) {
+ return 3;
+}
+int also_after(short &) {
+ return 5;
+}
+int also_after(short &&) {
+ return 0;
+}
+#pragma omp end declare variant
+#pragma omp begin declare variant match(implementation = {vendor(score(0) \
+ : llvm)})
+// This one does overload the int&(*)(void) version!
+int &also_before() {
+ return Good;
+}
+// This one does *not* overload the int(*)(float&&) version!
+int also_before(float &) {
+ return 6;
+}
+#pragma omp end declare variant
+
+int also_after(void) {
+ return 7;
+}
+int also_after(int) {
+ return 8;
+}
+int also_after(double &) {
+ return 9;
+}
+int also_after(short &&) {
+ return 10;
+}
+
+int test1() {
+ // Should return 0.
+ double d;
+ return also_after(d);
+}
+
+int test2() {
+ // Should return 0.
+ return &also_before() == &Good;
+}
+
+int test3(float &&f) {
+ // Should return 0.
+ return also_before(move(f));
+}
+
+int test4(short &&s) {
+ // Should return 0.
+ return also_after(move(s));
+}
+
+int test(float &&f, short &&s) {
+ // Should return 0.
+ return test1() + test2() + test3(move(f)) + test4(move(s));
+}
+
+// CHECK: |-ClassTemplateDecl [[ADDR_0:0x[a-z0-9]*]] <{{.*}}, col:66> col:29 remove_reference
+// CHECK-NEXT: | |-TemplateTypeParmDecl [[ADDR_1:0x[a-z0-9]*]] <col:11, col:17> col:17 referenced class depth 0 index 0 _Tp
+// CHECK-NEXT: | |-CXXRecordDecl [[ADDR_2:0x[a-z0-9]*]] <col:22, col:66> col:29 struct remove_reference definition
+// CHECK-NEXT: | | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
+// CHECK-NEXT: | | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
+// CHECK-NEXT: | | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
+// CHECK-NEXT: | | | |-MoveConstructor exists simple trivial needs_implicit
+// CHECK-NEXT: | | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
+// CHECK-NEXT: | | | |-MoveAssignment exists simple trivial needs_implicit
+// CHECK-NEXT: | | | `-Destructor simple irrelevant trivial needs_implicit
+// CHECK-NEXT: | | |-CXXRecordDecl [[ADDR_3:0x[a-z0-9]*]] <col:22, col:29> col:29 implicit struct remove_reference
+// CHECK-NEXT: | | `-TypedefDecl [[ADDR_4:0x[a-z0-9]*]] <col:48, col:60> col:60 type '_Tp'
+// CHECK-NEXT: | | `-TemplateTypeParmType [[ADDR_5:0x[a-z0-9]*]] '_Tp' dependent depth 0 index 0
+// CHECK-NEXT: | | `-TemplateTypeParm [[ADDR_1]] '_Tp'
+// CHECK-NEXT: | |-ClassTemplateSpecializationDecl [[ADDR_6:0x[a-z0-9]*]] <line:6:1, col:73> col:29 struct remove_reference definition
+// CHECK-NEXT: | | |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
+// CHECK-NEXT: | | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
+// CHECK-NEXT: | | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
+// CHECK-NEXT: | | | |-MoveConstructor exists simple trivial needs_implicit
+// CHECK-NEXT: | | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
+// CHECK-NEXT: | | | |-MoveAssignment exists simple trivial needs_implicit
+// CHECK-NEXT: | | | `-Destructor simple irrelevant trivial needs_implicit
+// CHECK-NEXT: | | |-TemplateArgument type 'float &'
+// CHECK-NEXT: | | | `-LValueReferenceType [[ADDR_7:0x[a-z0-9]*]] 'float &'
+// CHECK-NEXT: | | | `-BuiltinType [[ADDR_8:0x[a-z0-9]*]] 'float'
+// CHECK-NEXT: | | |-CXXRecordDecl [[ADDR_9:0x[a-z0-9]*]] prev [[ADDR_6]] <col:22, col:29> col:29 implicit struct remove_reference
+// CHECK-NEXT: | | `-TypedefDecl [[ADDR_10:0x[a-z0-9]*]] <col:55, col:67> col:67 referenced type 'float':'float'
+// CHECK-NEXT: | | `-SubstTemplateTypeParmType [[ADDR_11:0x[a-z0-9]*]] 'float' sugar
+// CHECK-NEXT: | | |-TemplateTypeParmType [[ADDR_12:0x[a-z0-9]*]] '_Tp' dependent depth 0 index 0
+// CHECK-NEXT: | | | `-TemplateTypeParm [[ADDR_13:0x[a-z0-9]*]] '_Tp'
+// CHECK-NEXT: | | `-BuiltinType [[ADDR_8]] 'float'
+// CHECK-NEXT: | `-ClassTemplateSpecializationDecl [[ADDR_14:0x[a-z0-9]*]] <col:1, col:73> col:29 struct remove_reference definition
+// CHECK-NEXT: | |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
+// CHECK-NEXT: | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
+// CHECK-NEXT: | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
+// CHECK-NEXT: | | |-MoveConstructor exists simple trivial needs_implicit
+// CHECK-NEXT: | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
+// CHECK-NEXT: | | |-MoveAssignment exists simple trivial needs_implicit
+// CHECK-NEXT: | | `-Destructor simple irrelevant trivial needs_implicit
+// CHECK-NEXT: | |-TemplateArgument type 'short &'
+// CHECK-NEXT: | | `-LValueReferenceType [[ADDR_15:0x[a-z0-9]*]] 'short &'
+// CHECK-NEXT: | | `-BuiltinType [[ADDR_16:0x[a-z0-9]*]] 'short'
+// CHECK-NEXT: | |-CXXRecordDecl [[ADDR_17:0x[a-z0-9]*]] prev [[ADDR_14]] <col:22, col:29> col:29 implicit struct remove_reference
+// CHECK-NEXT: | `-TypedefDecl [[ADDR_18:0x[a-z0-9]*]] <col:55, col:67> col:67 referenced type 'short':'short'
+// CHECK-NEXT: | `-SubstTemplateTypeParmType [[ADDR_19:0x[a-z0-9]*]] 'short' sugar
+// CHECK-NEXT: | |-TemplateTypeParmType [[ADDR_12]] '_Tp' dependent depth 0 index 0
+// CHECK-NEXT: | | `-TemplateTypeParm [[ADDR_13]] '_Tp'
+// CHECK-NEXT: | `-BuiltinType [[ADDR_16]] 'short'
+// CHECK-NEXT: |-ClassTemplatePartialSpecializationDecl [[ADDR_20:0x[a-z0-9]*]] <col:1, col:73> col:29 struct remove_reference definition
+// CHECK-NEXT: | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
+// CHECK-NEXT: | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
+// CHECK-NEXT: | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
+// CHECK-NEXT: | | |-MoveConstructor exists simple trivial needs_implicit
+// CHECK-NEXT: | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
+// CHECK-NEXT: | | |-MoveAssignment exists simple trivial needs_implicit
+// CHECK-NEXT: | | `-Destructor simple irrelevant trivial needs_implicit
+// CHECK-NEXT: | |-TemplateArgument type 'type-parameter-0-0 &'
+// CHECK-NEXT: | | `-LValueReferenceType [[ADDR_21:0x[a-z0-9]*]] 'type-parameter-0-0 &' dependent
+// CHECK-NEXT: | | `-TemplateTypeParmType [[ADDR_22:0x[a-z0-9]*]] 'type-parameter-0-0' dependent depth 0 index 0
+// CHECK-NEXT: | |-TemplateTypeParmDecl [[ADDR_13]] <col:11, col:17> col:17 referenced class depth 0 index 0 _Tp
+// CHECK-NEXT: | |-CXXRecordDecl [[ADDR_23:0x[a-z0-9]*]] <col:22, col:29> col:29 implicit struct remove_reference
+// CHECK-NEXT: | `-TypedefDecl [[ADDR_24:0x[a-z0-9]*]] <col:55, col:67> col:67 type '_Tp'
+// CHECK-NEXT: | `-TemplateTypeParmType [[ADDR_12]] '_Tp' dependent depth 0 index 0
+// CHECK-NEXT: | `-TemplateTypeParm [[ADDR_13]] '_Tp'
+// CHECK-NEXT: |-ClassTemplatePartialSpecializationDecl [[ADDR_25:0x[a-z0-9]*]] <line:7:1, col:74> col:29 struct remove_reference definition
+// CHECK-NEXT: | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
+// CHECK-NEXT: | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
+// CHECK-NEXT: | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
+// CHECK-NEXT: | | |-MoveConstructor exists simple trivial needs_implicit
+// CHECK-NEXT: | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
+// CHECK-NEXT: | | |-MoveAssignment exists simple trivial needs_implicit
+// CHECK-NEXT: | | `-Destructor simple irrelevant trivial needs_implicit
+// CHECK-NEXT: | |-TemplateArgument type 'type-parameter-0-0 &&'
+// CHECK-NEXT: | | `-RValueReferenceType [[ADDR_26:0x[a-z0-9]*]] 'type-parameter-0-0 &&' dependent
+// CHECK-NEXT: | | `-TemplateTypeParmType [[ADDR_22]] 'type-parameter-0-0' dependent depth 0 index 0
+// CHECK-NEXT: | |-TemplateTypeParmDecl [[ADDR_27:0x[a-z0-9]*]] <col:11, col:17> col:17 referenced class depth 0 index 0 _Tp
+// CHECK-NEXT: | |-CXXRecordDecl [[ADDR_28:0x[a-z0-9]*]] <col:22, col:29> col:29 implicit struct remove_reference
+// CHECK-NEXT: | `-TypedefDecl [[ADDR_29:0x[a-z0-9]*]] <col:56, col:68> col:68 type '_Tp'
+// CHECK-NEXT: | `-TemplateTypeParmType [[ADDR_30:0x[a-z0-9]*]] '_Tp' dependent depth 0 index 0
+// CHECK-NEXT: | `-TemplateTypeParm [[ADDR_27]] '_Tp'
+// CHECK-NEXT: |-FunctionTemplateDecl [[ADDR_31:0x[a-z0-9]*]] <line:9:1, line:14:1> line:11:1 move
+// CHECK-NEXT: | |-TemplateTypeParmDecl [[ADDR_32:0x[a-z0-9]*]] <line:9:11, col:17> col:17 referenced class depth 0 index 0 _Tp
+// CHECK-NEXT: | |-FunctionDecl [[ADDR_33:0x[a-z0-9]*]] <line:10:1, line:14:1> line:11:1 move 'typename remove_reference<_Tp>::type &&(_Tp &&)' inline
+// CHECK-NEXT: | | |-ParmVarDecl [[ADDR_34:0x[a-z0-9]*]] <col:6, col:12> col:12 referenced __t '_Tp &&'
+// CHECK-NEXT: | | `-CompoundStmt [[ADDR_35:0x[a-z0-9]*]] <col:17, line:14:1>
+// CHECK-NEXT: | | |-DeclStmt [[ADDR_36:0x[a-z0-9]*]] <line:12:3, col:51>
+// CHECK-NEXT: | | | `-TypedefDecl [[ADDR_37:0x[a-z0-9]*]] <col:3, col:48> col:48 referenced _Up 'typename remove_reference<_Tp>::type'
+// CHECK-NEXT: | | | `-DependentNameType [[ADDR_38:0x[a-z0-9]*]] 'typename remove_reference<_Tp>::type' dependent
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_39:0x[a-z0-9]*]] <line:13:3, col:33>
+// CHECK-NEXT: | | `-CXXStaticCastExpr [[ADDR_40:0x[a-z0-9]*]] <col:10, col:33> '_Up':'typename remove_reference<_Tp>::type' xvalue static_cast<_Up &&> <Dependent>
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_41:0x[a-z0-9]*]] <col:30> '_Tp' {{.*}}ParmVar [[ADDR_34]] '__t' '_Tp &&'
+// CHECK-NEXT: | |-FunctionDecl [[ADDR_42:0x[a-z0-9]*]] <line:10:1, line:14:1> line:11:1 used move 'typename remove_reference<float &>::type &&(float &)' inline
+// CHECK-NEXT: | | |-TemplateArgument type 'float &'
+// CHECK-NEXT: | | | `-LValueReferenceType [[ADDR_7]] 'float &'
+// CHECK-NEXT: | | | `-BuiltinType [[ADDR_8]] 'float'
+// CHECK-NEXT: | | |-ParmVarDecl [[ADDR_43:0x[a-z0-9]*]] <col:6, col:12> col:12 used __t 'float &'
+// CHECK-NEXT: | | `-CompoundStmt [[ADDR_44:0x[a-z0-9]*]] <col:17, line:14:1>
+// CHECK-NEXT: | | |-DeclStmt [[ADDR_45:0x[a-z0-9]*]] <line:12:3, col:51>
+// CHECK-NEXT: | | | `-TypedefDecl [[ADDR_46:0x[a-z0-9]*]] <col:3, col:48> col:48 _Up 'typename remove_reference<float &>::type':'float'
+// CHECK-NEXT: | | | `-ElaboratedType [[ADDR_47:0x[a-z0-9]*]] 'typename remove_reference<float &>::type' sugar
+// CHECK-NEXT: | | | `-TypedefType [[ADDR_48:0x[a-z0-9]*]] 'remove_reference<float &>::type' sugar
+// CHECK-NEXT: | | | |-Typedef [[ADDR_10]] 'type'
+// CHECK-NEXT: | | | `-SubstTemplateTypeParmType [[ADDR_11]] 'float' sugar
+// CHECK-NEXT: | | | |-TemplateTypeParmType [[ADDR_12]] '_Tp' dependent depth 0 index 0
+// CHECK-NEXT: | | | | `-TemplateTypeParm [[ADDR_13]] '_Tp'
+// CHECK-NEXT: | | | `-BuiltinType [[ADDR_8]] 'float'
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_49:0x[a-z0-9]*]] <line:13:3, col:33>
+// CHECK-NEXT: | | `-CXXStaticCastExpr [[ADDR_50:0x[a-z0-9]*]] <col:10, col:33> '_Up':'float' xvalue static_cast<_Up &&> <NoOp>
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_51:0x[a-z0-9]*]] <col:30> 'float' {{.*}}ParmVar [[ADDR_43]] '__t' 'float &'
+// CHECK-NEXT: | `-FunctionDecl [[ADDR_52:0x[a-z0-9]*]] <line:10:1, line:14:1> line:11:1 used move 'typename remove_reference<short &>::type &&(short &)' inline
+// CHECK-NEXT: | |-TemplateArgument type 'short &'
+// CHECK-NEXT: | | `-LValueReferenceType [[ADDR_15]] 'short &'
+// CHECK-NEXT: | | `-BuiltinType [[ADDR_16]] 'short'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_53:0x[a-z0-9]*]] <col:6, col:12> col:12 used __t 'short &'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_54:0x[a-z0-9]*]] <col:17, line:14:1>
+// CHECK-NEXT: | |-DeclStmt [[ADDR_55:0x[a-z0-9]*]] <line:12:3, col:51>
+// CHECK-NEXT: | | `-TypedefDecl [[ADDR_56:0x[a-z0-9]*]] <col:3, col:48> col:48 _Up 'typename remove_reference<short &>::type':'short'
+// CHECK-NEXT: | | `-ElaboratedType [[ADDR_57:0x[a-z0-9]*]] 'typename remove_reference<short &>::type' sugar
+// CHECK-NEXT: | | `-TypedefType [[ADDR_58:0x[a-z0-9]*]] 'remove_reference<short &>::type' sugar
+// CHECK-NEXT: | | |-Typedef [[ADDR_18]] 'type'
+// CHECK-NEXT: | | `-SubstTemplateTypeParmType [[ADDR_19]] 'short' sugar
+// CHECK-NEXT: | | |-TemplateTypeParmType [[ADDR_12]] '_Tp' dependent depth 0 index 0
+// CHECK-NEXT: | | | `-TemplateTypeParm [[ADDR_13]] '_Tp'
+// CHECK-NEXT: | | `-BuiltinType [[ADDR_16]] 'short'
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_59:0x[a-z0-9]*]] <line:13:3, col:33>
+// CHECK-NEXT: | `-CXXStaticCastExpr [[ADDR_60:0x[a-z0-9]*]] <col:10, col:33> '_Up':'short' xvalue static_cast<_Up &&> <NoOp>
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_61:0x[a-z0-9]*]] <col:30> 'short' {{.*}}ParmVar [[ADDR_53]] '__t' 'short &'
+// CHECK-NEXT: |-VarDecl [[ADDR_62:0x[a-z0-9]*]] <line:17:1, col:5> col:5 used Good 'int'
+// CHECK-NEXT: |-VarDecl [[ADDR_63:0x[a-z0-9]*]] <col:1, col:11> col:11 used Bad 'int'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_64:0x[a-z0-9]*]] <line:18:1, line:20:1> line:18:6 used also_before 'int &({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_65:0x[a-z0-9]*]] <col:20, line:20:1>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_66:0x[a-z0-9]*]] <line:19:3, col:10>
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_67:0x[a-z0-9]*]] <col:10> 'int' {{.*}}Var [[ADDR_63]] 'Bad' 'int'
+// CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_68:0x[a-z0-9]*]] <<invalid sloc>> Implicit implementation={vendor(score(0): llvm)}
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_69:0x[a-z0-9]*]] <line:50:1> 'int &({{.*}})' {{.*}}Function [[ADDR_70:0x[a-z0-9]*]] 'also_before[implementation={vendor(llvm)}]' 'int &({{.*}})'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_71:0x[a-z0-9]*]] <line:21:1, line:23:1> line:21:5 used also_before 'int (float &&)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_72:0x[a-z0-9]*]] <col:17, col:23> col:25 'float &&'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_73:0x[a-z0-9]*]] <col:27, line:23:1>
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_74:0x[a-z0-9]*]] <line:22:3, col:10>
+// CHECK-NEXT: | `-IntegerLiteral [[ADDR_75:0x[a-z0-9]*]] <col:10> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_76:0x[a-z0-9]*]] <line:27:1, col:20> col:5 implicit also_after 'int ({{.*}})'
+// CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_77:0x[a-z0-9]*]] <<invalid sloc>> Implicit implementation={vendor(score(100): llvm)}
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_78:0x[a-z0-9]*]] <col:1> 'int ({{.*}})' {{.*}}Function [[ADDR_79:0x[a-z0-9]*]] 'also_after[implementation={vendor(llvm)}]' 'int ({{.*}})'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_79]] <col:1, line:29:1> line:27:1 also_after[implementation={vendor(llvm)}] 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_80:0x[a-z0-9]*]] <col:22, line:29:1>
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_81:0x[a-z0-9]*]] <line:28:3, col:10>
+// CHECK-NEXT: | `-IntegerLiteral [[ADDR_82:0x[a-z0-9]*]] <col:10> 'int' 1
+// CHECK-NEXT: |-FunctionDecl [[ADDR_83:0x[a-z0-9]*]] <line:30:1, col:21> col:5 implicit also_after 'int (int &)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_84:0x[a-z0-9]*]] <col:16, col:20> col:21 'int &'
+// CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_85:0x[a-z0-9]*]] <<invalid sloc>> Implicit implementation={vendor(score(100): llvm)}
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_86:0x[a-z0-9]*]] <col:1> 'int (int &)' {{.*}}Function [[ADDR_87:0x[a-z0-9]*]] 'also_after[implementation={vendor(llvm)}]' 'int (int &)'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_87]] <col:1, line:32:1> line:30:1 also_after[implementation={vendor(llvm)}] 'int (int &)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_84]] <col:16, col:20> col:21 'int &'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_88:0x[a-z0-9]*]] <col:23, line:32:1>
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_89:0x[a-z0-9]*]] <line:31:3, col:10>
+// CHECK-NEXT: | `-IntegerLiteral [[ADDR_90:0x[a-z0-9]*]] <col:10> 'int' 2
+// CHECK-NEXT: |-FunctionDecl [[ADDR_91:0x[a-z0-9]*]] <line:34:1, col:24> col:5 implicit used also_after 'int (double &)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_92:0x[a-z0-9]*]] <col:16, col:23> col:24 'double &'
+// CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_93:0x[a-z0-9]*]] <<invalid sloc>> Implicit implementation={vendor(score(100): llvm)}
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_94:0x[a-z0-9]*]] <col:1> 'int (double &)' {{.*}}Function [[ADDR_95:0x[a-z0-9]*]] 'also_after[implementation={vendor(llvm)}]' 'int (double &)'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_95]] <col:1, line:36:1> line:34:1 also_after[implementation={vendor(llvm)}] 'int (double &)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_92]] <col:16, col:23> col:24 'double &'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_96:0x[a-z0-9]*]] <col:26, line:36:1>
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_97:0x[a-z0-9]*]] <line:35:3, col:10>
+// CHECK-NEXT: | `-IntegerLiteral [[ADDR_98:0x[a-z0-9]*]] <col:10> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_99:0x[a-z0-9]*]] <line:37:1, col:25> col:5 implicit also_after 'int (double &&)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_100:0x[a-z0-9]*]] <col:16, col:23> col:25 'double &&'
+// CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_101:0x[a-z0-9]*]] <<invalid sloc>> Implicit implementation={vendor(score(100): llvm)}
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_102:0x[a-z0-9]*]] <col:1> 'int (double &&)' {{.*}}Function [[ADDR_103:0x[a-z0-9]*]] 'also_after[implementation={vendor(llvm)}]' 'int (double &&)'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_103]] <col:1, line:39:1> line:37:1 also_after[implementation={vendor(llvm)}] 'int (double &&)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_100]] <col:16, col:23> col:25 'double &&'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_104:0x[a-z0-9]*]] <col:27, line:39:1>
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_105:0x[a-z0-9]*]] <line:38:3, col:10>
+// CHECK-NEXT: | `-IntegerLiteral [[ADDR_106:0x[a-z0-9]*]] <col:10> 'int' 3
+// CHECK-NEXT: |-FunctionDecl [[ADDR_107:0x[a-z0-9]*]] <line:40:1, col:23> col:5 implicit also_after 'int (short &)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_108:0x[a-z0-9]*]] <col:16, col:22> col:23 'short &'
+// CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_109:0x[a-z0-9]*]] <<invalid sloc>> Implicit implementation={vendor(score(100): llvm)}
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_110:0x[a-z0-9]*]] <col:1> 'int (short &)' {{.*}}Function [[ADDR_111:0x[a-z0-9]*]] 'also_after[implementation={vendor(llvm)}]' 'int (short &)'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_111]] <col:1, line:42:1> line:40:1 also_after[implementation={vendor(llvm)}] 'int (short &)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_108]] <col:16, col:22> col:23 'short &'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_112:0x[a-z0-9]*]] <col:25, line:42:1>
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_113:0x[a-z0-9]*]] <line:41:3, col:10>
+// CHECK-NEXT: | `-IntegerLiteral [[ADDR_114:0x[a-z0-9]*]] <col:10> 'int' 5
+// CHECK-NEXT: |-FunctionDecl [[ADDR_115:0x[a-z0-9]*]] <line:43:1, col:24> col:5 implicit used also_after 'int (short &&)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_116:0x[a-z0-9]*]] <col:16, col:22> col:24 'short &&'
+// CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_117:0x[a-z0-9]*]] <<invalid sloc>> Implicit implementation={vendor(score(100): llvm)}
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_118:0x[a-z0-9]*]] <col:1> 'int (short &&)' {{.*}}Function [[ADDR_119:0x[a-z0-9]*]] 'also_after[implementation={vendor(llvm)}]' 'int (short &&)'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_119]] <col:1, line:45:1> line:43:1 also_after[implementation={vendor(llvm)}] 'int (short &&)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_116]] <col:16, col:22> col:24 'short &&'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_120:0x[a-z0-9]*]] <col:26, line:45:1>
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_121:0x[a-z0-9]*]] <line:44:3, col:10>
+// CHECK-NEXT: | `-IntegerLiteral [[ADDR_122:0x[a-z0-9]*]] <col:10> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_70]] <line:50:1, line:52:1> line:50:1 also_before[implementation={vendor(llvm)}] 'int &({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_123:0x[a-z0-9]*]] <col:20, line:52:1>
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_124:0x[a-z0-9]*]] <line:51:3, col:10>
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_125:0x[a-z0-9]*]] <col:10> 'int' {{.*}}Var [[ADDR_62]] 'Good' 'int'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_126:0x[a-z0-9]*]] <line:54:1, col:24> col:5 implicit also_before 'int (float &)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_127:0x[a-z0-9]*]] <col:17, col:23> col:24 'float &'
+// CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_128:0x[a-z0-9]*]] <<invalid sloc>> Implicit implementation={vendor(score(0): llvm)}
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_129:0x[a-z0-9]*]] <col:1> 'int (float &)' {{.*}}Function [[ADDR_130:0x[a-z0-9]*]] 'also_before[implementation={vendor(llvm)}]' 'int (float &)'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_130]] <col:1, line:56:1> line:54:1 also_before[implementation={vendor(llvm)}] 'int (float &)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_127]] <col:17, col:23> col:24 'float &'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_131:0x[a-z0-9]*]] <col:26, line:56:1>
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_132:0x[a-z0-9]*]] <line:55:3, col:10>
+// CHECK-NEXT: | `-IntegerLiteral [[ADDR_133:0x[a-z0-9]*]] <col:10> 'int' 6
+// CHECK-NEXT: |-FunctionDecl [[ADDR_134:0x[a-z0-9]*]] prev [[ADDR_76]] <line:59:1, line:61:1> line:59:5 also_after 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_135:0x[a-z0-9]*]] <col:22, line:61:1>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_136:0x[a-z0-9]*]] <line:60:3, col:10>
+// CHECK-NEXT: | | `-IntegerLiteral [[ADDR_137:0x[a-z0-9]*]] <col:10> 'int' 7
+// CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_138:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(score(100): llvm)}
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_78]] <line:27:1> 'int ({{.*}})' {{.*}}Function [[ADDR_79]] 'also_after[implementation={vendor(llvm)}]' 'int ({{.*}})'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_139:0x[a-z0-9]*]] <line:62:1, line:64:1> line:62:5 also_after 'int (int)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_140:0x[a-z0-9]*]] <col:16> col:19 'int'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_141:0x[a-z0-9]*]] <col:21, line:64:1>
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_142:0x[a-z0-9]*]] <line:63:3, col:10>
+// CHECK-NEXT: | `-IntegerLiteral [[ADDR_143:0x[a-z0-9]*]] <col:10> 'int' 8
+// CHECK-NEXT: |-FunctionDecl [[ADDR_144:0x[a-z0-9]*]] prev [[ADDR_91]] <line:65:1, line:67:1> line:65:5 used also_after 'int (double &)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_145:0x[a-z0-9]*]] <col:16, col:23> col:24 'double &'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_146:0x[a-z0-9]*]] <col:26, line:67:1>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_147:0x[a-z0-9]*]] <line:66:3, col:10>
+// CHECK-NEXT: | | `-IntegerLiteral [[ADDR_148:0x[a-z0-9]*]] <col:10> 'int' 9
+// CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_149:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(score(100): llvm)}
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_94]] <line:34:1> 'int (double &)' {{.*}}Function [[ADDR_95]] 'also_after[implementation={vendor(llvm)}]' 'int (double &)'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_150:0x[a-z0-9]*]] prev [[ADDR_115]] <line:68:1, line:70:1> line:68:5 used also_after 'int (short &&)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_151:0x[a-z0-9]*]] <col:16, col:22> col:24 'short &&'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_152:0x[a-z0-9]*]] <col:26, line:70:1>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_153:0x[a-z0-9]*]] <line:69:3, col:10>
+// CHECK-NEXT: | | `-IntegerLiteral [[ADDR_154:0x[a-z0-9]*]] <col:10> 'int' 10
+// CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_155:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(score(100): llvm)}
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_118]] <line:43:1> 'int (short &&)' {{.*}}Function [[ADDR_119]] 'also_after[implementation={vendor(llvm)}]' 'int (short &&)'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_156:0x[a-z0-9]*]] <line:72:1, line:76:1> line:72:5 used test1 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_157:0x[a-z0-9]*]] <col:13, line:76:1>
+// CHECK-NEXT: | |-DeclStmt [[ADDR_158:0x[a-z0-9]*]] <line:74:3, col:11>
+// CHECK-NEXT: | | `-VarDecl [[ADDR_159:0x[a-z0-9]*]] <col:3, col:10> col:10 used d 'double'
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_160:0x[a-z0-9]*]] <line:75:3, col:22>
+// CHECK-NEXT: | `-PseudoObjectExpr [[ADDR_161:0x[a-z0-9]*]] <col:10, col:22> 'int'
+// CHECK-NEXT: | |-CallExpr [[ADDR_162:0x[a-z0-9]*]] <col:10, col:22> 'int'
+// CHECK-NEXT: | | |-ImplicitCastExpr [[ADDR_163:0x[a-z0-9]*]] <col:10> 'int (*)(double &)' <FunctionToPointerDecay>
+// CHECK-NEXT: | | | `-DeclRefExpr [[ADDR_164:0x[a-z0-9]*]] <col:10> 'int (double &)' {{.*}}Function [[ADDR_144]] 'also_after' 'int (double &)'
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_165:0x[a-z0-9]*]] <col:21> 'double' {{.*}}Var [[ADDR_159]] 'd' 'double'
+// CHECK-NEXT: | `-CallExpr [[ADDR_166:0x[a-z0-9]*]] <line:34:1, line:75:22> 'int'
+// CHECK-NEXT: | |-ImplicitCastExpr [[ADDR_167:0x[a-z0-9]*]] <line:34:1> 'int (*)(double &)' <FunctionToPointerDecay>
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_94]] <col:1> 'int (double &)' {{.*}}Function [[ADDR_95]] 'also_after[implementation={vendor(llvm)}]' 'int (double &)'
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_165]] <line:75:21> 'double' {{.*}}Var [[ADDR_159]] 'd' 'double'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_168:0x[a-z0-9]*]] <line:78:1, line:81:1> line:78:5 used test2 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_169:0x[a-z0-9]*]] <col:13, line:81:1>
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_170:0x[a-z0-9]*]] <line:80:3, col:29>
+// CHECK-NEXT: | `-ImplicitCastExpr [[ADDR_171:0x[a-z0-9]*]] <col:10, col:29> 'int' <IntegralCast>
+// CHECK-NEXT: | `-BinaryOperator [[ADDR_172:0x[a-z0-9]*]] <col:10, col:29> 'bool' '=='
+// CHECK-NEXT: | |-UnaryOperator [[ADDR_173:0x[a-z0-9]*]] <col:10, col:23> 'int *' prefix '&' cannot overflow
+// CHECK-NEXT: | | `-PseudoObjectExpr [[ADDR_174:0x[a-z0-9]*]] <col:11, col:23> 'int' lvalue
+// CHECK-NEXT: | | |-CallExpr [[ADDR_175:0x[a-z0-9]*]] <col:11, col:23> 'int' lvalue
+// CHECK-NEXT: | | | `-ImplicitCastExpr [[ADDR_176:0x[a-z0-9]*]] <col:11> 'int &(*)({{.*}})' <FunctionToPointerDecay>
+// CHECK-NEXT: | | | `-DeclRefExpr [[ADDR_177:0x[a-z0-9]*]] <col:11> 'int &({{.*}})' {{.*}}Function [[ADDR_64]] 'also_before' 'int &({{.*}})'
+// CHECK-NEXT: | | `-CallExpr [[ADDR_178:0x[a-z0-9]*]] <line:50:1, line:80:23> 'int' lvalue
+// CHECK-NEXT: | | `-ImplicitCastExpr [[ADDR_179:0x[a-z0-9]*]] <line:50:1> 'int &(*)({{.*}})' <FunctionToPointerDecay>
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_69]] <col:1> 'int &({{.*}})' {{.*}}Function [[ADDR_70]] 'also_before[implementation={vendor(llvm)}]' 'int &({{.*}})'
+// CHECK-NEXT: | `-UnaryOperator [[ADDR_180:0x[a-z0-9]*]] <line:80:28, col:29> 'int *' prefix '&' cannot overflow
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_181:0x[a-z0-9]*]] <col:29> 'int' {{.*}}Var [[ADDR_62]] 'Good' 'int'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_182:0x[a-z0-9]*]] <line:83:1, line:86:1> line:83:5 used test3 'int (float &&)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_183:0x[a-z0-9]*]] <col:11, col:19> col:19 used f 'float &&'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_184:0x[a-z0-9]*]] <col:22, line:86:1>
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_185:0x[a-z0-9]*]] <line:85:3, col:29>
+// CHECK-NEXT: | `-CallExpr [[ADDR_186:0x[a-z0-9]*]] <col:10, col:29> 'int'
+// CHECK-NEXT: | |-ImplicitCastExpr [[ADDR_187:0x[a-z0-9]*]] <col:10> 'int (*)(float &&)' <FunctionToPointerDecay>
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_188:0x[a-z0-9]*]] <col:10> 'int (float &&)' {{.*}}Function [[ADDR_71]] 'also_before' 'int (float &&)'
+// CHECK-NEXT: | `-CallExpr [[ADDR_189:0x[a-z0-9]*]] <col:22, col:28> 'typename remove_reference<float &>::type':'float' xvalue
+// CHECK-NEXT: | |-ImplicitCastExpr [[ADDR_190:0x[a-z0-9]*]] <col:22> 'typename remove_reference<float &>::type &&(*)(float &)' <FunctionToPointerDecay>
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_191:0x[a-z0-9]*]] <col:22> 'typename remove_reference<float &>::type &&(float &)' {{.*}}Function [[ADDR_42]] 'move' 'typename remove_reference<float &>::type &&(float &)' (FunctionTemplate [[ADDR_31]] 'move')
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_192:0x[a-z0-9]*]] <col:27> 'float' {{.*}}ParmVar [[ADDR_183]] 'f' 'float &&'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_193:0x[a-z0-9]*]] <line:88:1, line:91:1> line:88:5 used test4 'int (short &&)'
+// CHECK-NEXT: | |-ParmVarDecl [[ADDR_194:0x[a-z0-9]*]] <col:11, col:19> col:19 used s 'short &&'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_195:0x[a-z0-9]*]] <col:22, line:91:1>
+// CHECK-NEXT: | `-ReturnStmt [[ADDR_196:0x[a-z0-9]*]] <line:90:3, col:28>
+// CHECK-NEXT: | `-PseudoObjectExpr [[ADDR_197:0x[a-z0-9]*]] <col:10, col:28> 'int'
+// CHECK-NEXT: | |-CallExpr [[ADDR_198:0x[a-z0-9]*]] <col:10, col:28> 'int'
+// CHECK-NEXT: | | |-ImplicitCastExpr [[ADDR_199:0x[a-z0-9]*]] <col:10> 'int (*)(short &&)' <FunctionToPointerDecay>
+// CHECK-NEXT: | | | `-DeclRefExpr [[ADDR_200:0x[a-z0-9]*]] <col:10> 'int (short &&)' {{.*}}Function [[ADDR_150]] 'also_after' 'int (short &&)'
+// CHECK-NEXT: | | `-CallExpr [[ADDR_201:0x[a-z0-9]*]] <col:21, col:27> 'typename remove_reference<short &>::type':'short' xvalue
+// CHECK-NEXT: | | |-ImplicitCastExpr [[ADDR_202:0x[a-z0-9]*]] <col:21> 'typename remove_reference<short &>::type &&(*)(short &)' <FunctionToPointerDecay>
+// CHECK-NEXT: | | | `-DeclRefExpr [[ADDR_203:0x[a-z0-9]*]] <col:21> 'typename remove_reference<short &>::type &&(short &)' {{.*}}Function [[ADDR_52]] 'move' 'typename remove_reference<short &>::type &&(short &)' (FunctionTemplate [[ADDR_31]] 'move')
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_204:0x[a-z0-9]*]] <col:26> 'short' {{.*}}ParmVar [[ADDR_194]] 's' 'short &&'
+// CHECK-NEXT: | `-CallExpr [[ADDR_205:0x[a-z0-9]*]] <line:43:1, line:90:28> 'int'
+// CHECK-NEXT: | |-ImplicitCastExpr [[ADDR_206:0x[a-z0-9]*]] <line:43:1> 'int (*)(short &&)' <FunctionToPointerDecay>
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_118]] <col:1> 'int (short &&)' {{.*}}Function [[ADDR_119]] 'also_after[implementation={vendor(llvm)}]' 'int (short &&)'
+// CHECK-NEXT: | `-CallExpr [[ADDR_201]] <line:90:21, col:27> 'typename remove_reference<short &>::type':'short' xvalue
+// CHECK-NEXT: | |-ImplicitCastExpr [[ADDR_202]] <col:21> 'typename remove_reference<short &>::type &&(*)(short &)' <FunctionToPointerDecay>
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_203]] <col:21> 'typename remove_reference<short &>::type &&(short &)' {{.*}}Function [[ADDR_52]] 'move' 'typename remove_reference<short &>::type &&(short &)' (FunctionTemplate [[ADDR_31]] 'move')
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_204]] <col:26> 'short' {{.*}}ParmVar [[ADDR_194]] 's' 'short &&'
+// CHECK-NEXT: `-FunctionDecl [[ADDR_207:0x[a-z0-9]*]] <line:93:1, line:96:1> line:93:5 test 'int (float &&, short &&)'
+// CHECK-NEXT: |-ParmVarDecl [[ADDR_208:0x[a-z0-9]*]] <col:10, col:18> col:18 used f 'float &&'
+// CHECK-NEXT: |-ParmVarDecl [[ADDR_209:0x[a-z0-9]*]] <col:21, col:29> col:29 used s 'short &&'
+// CHECK-NEXT: `-CompoundStmt [[ADDR_210:0x[a-z0-9]*]] <col:32, line:96:1>
+// CHECK-NEXT: `-ReturnStmt [[ADDR_211:0x[a-z0-9]*]] <line:95:3, col:60>
+// CHECK-NEXT: `-BinaryOperator [[ADDR_212:0x[a-z0-9]*]] <col:10, col:60> 'int' '+'
+// CHECK-NEXT: |-BinaryOperator [[ADDR_213:0x[a-z0-9]*]] <col:10, col:43> 'int' '+'
+// CHECK-NEXT: | |-BinaryOperator [[ADDR_214:0x[a-z0-9]*]] <col:10, col:26> 'int' '+'
+// CHECK-NEXT: | | |-CallExpr [[ADDR_215:0x[a-z0-9]*]] <col:10, col:16> 'int'
+// CHECK-NEXT: | | | `-ImplicitCastExpr [[ADDR_216:0x[a-z0-9]*]] <col:10> 'int (*)({{.*}})' <FunctionToPointerDecay>
+// CHECK-NEXT: | | | `-DeclRefExpr [[ADDR_217:0x[a-z0-9]*]] <col:10> 'int ({{.*}})' {{.*}}Function [[ADDR_156]] 'test1' 'int ({{.*}})'
+// CHECK-NEXT: | | `-CallExpr [[ADDR_218:0x[a-z0-9]*]] <col:20, col:26> 'int'
+// CHECK-NEXT: | | `-ImplicitCastExpr [[ADDR_219:0x[a-z0-9]*]] <col:20> 'int (*)({{.*}})' <FunctionToPointerDecay>
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_220:0x[a-z0-9]*]] <col:20> 'int ({{.*}})' {{.*}}Function [[ADDR_168]] 'test2' 'int ({{.*}})'
+// CHECK-NEXT: | `-CallExpr [[ADDR_221:0x[a-z0-9]*]] <col:30, col:43> 'int'
+// CHECK-NEXT: | |-ImplicitCastExpr [[ADDR_222:0x[a-z0-9]*]] <col:30> 'int (*)(float &&)' <FunctionToPointerDecay>
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_223:0x[a-z0-9]*]] <col:30> 'int (float &&)' {{.*}}Function [[ADDR_182]] 'test3' 'int (float &&)'
+// CHECK-NEXT: | `-CallExpr [[ADDR_224:0x[a-z0-9]*]] <col:36, col:42> 'typename remove_reference<float &>::type':'float' xvalue
+// CHECK-NEXT: | |-ImplicitCastExpr [[ADDR_225:0x[a-z0-9]*]] <col:36> 'typename remove_reference<float &>::type &&(*)(float &)' <FunctionToPointerDecay>
+// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_226:0x[a-z0-9]*]] <col:36> 'typename remove_reference<float &>::type &&(float &)' {{.*}}Function [[ADDR_42]] 'move' 'typename remove_reference<float &>::type &&(float &)' (FunctionTemplate [[ADDR_31]] 'move')
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_227:0x[a-z0-9]*]] <col:41> 'float' {{.*}}ParmVar [[ADDR_208]] 'f' 'float &&'
+// CHECK-NEXT: `-CallExpr [[ADDR_228:0x[a-z0-9]*]] <col:47, col:60> 'int'
+// CHECK-NEXT: |-ImplicitCastExpr [[ADDR_229:0x[a-z0-9]*]] <col:47> 'int (*)(short &&)' <FunctionToPointerDecay>
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_230:0x[a-z0-9]*]] <col:47> 'int (short &&)' {{.*}}Function [[ADDR_193]] 'test4' 'int (short &&)'
+// CHECK-NEXT: `-CallExpr [[ADDR_231:0x[a-z0-9]*]] <col:53, col:59> 'typename remove_reference<short &>::type':'short' xvalue
+// CHECK-NEXT: |-ImplicitCastExpr [[ADDR_232:0x[a-z0-9]*]] <col:53> 'typename remove_reference<short &>::type &&(*)(short &)' <FunctionToPointerDecay>
+// CHECK-NEXT: | `-DeclRefExpr [[ADDR_233:0x[a-z0-9]*]] <col:53> 'typename remove_reference<short &>::type &&(short &)' {{.*}}Function [[ADDR_52]] 'move' 'typename remove_reference<short &>::type &&(short &)' (FunctionTemplate [[ADDR_31]] 'move')
+// CHECK-NEXT: `-DeclRefExpr [[ADDR_234:0x[a-z0-9]*]] <col:58> 'short' {{.*}}ParmVar [[ADDR_209]] 's' 'short &&'
More information about the cfe-commits
mailing list