This is an archive of the discontinued LLVM Phabricator instance.

Differential D67924

[Sema] Fix the atomic expr rebuilding order.
ClosedPublic

Authored by hliao on Sep 23 2019, 10:12 AM.

Details

Reviewers
erichkeane
Commits
rG566b3164c51e: [Sema] Fix the atomic expr rebuilding order.
rL372640: [Sema] Fix the atomic expr rebuilding order.
rC372640: [Sema] Fix the atomic expr rebuilding order.
Summary
  • Rearrange the atomic expr order to the API order when rebuilding atomic expr during template instantiation.

Diff Detail

Event Timeline

hliao created this revision.Sep 23 2019, 10:12 AM
Herald added a project: Restricted Project. · View Herald TranscriptSep 23 2019, 10:12 AM
Herald added subscribers: cfe-commits, jfb. · View Herald Transcript
hliao added a comment.Sep 23 2019, 10:14 AM

The current BuildAtomicExpr expects the arguments to be in the API order instead of the AST order. If RebuildAtomicExpr uses the same BuildAtomicExpr, it needs to ensure the order of arguments are in API order; otherwise, arguments (especially the one with memory order) will be misplaced.

Harbormaster completed remote builds in B38440: Diff 221363.Sep 23 2019, 10:15 AM
erichkeane added a comment.Sep 23 2019, 10:21 AM

Yikes, good catch!

Would we be better off instead to just modify how the other switch loads the value? Presumably something like, "if (NeedsRearrangeArgs) SubExprs.append(Args.begin(), Args.end()); else /*the switch*/.

clang/lib/Sema/TreeTransform.h
3318

When passing a bool, use the comment syntax /*paramname=*/ to make it clear whats happening.

hliao added a comment.Sep 23 2019, 10:29 AM
In D67924#1679409, @erichkeane wrote:

Yikes, good catch!

Would we be better off instead to just modify how the other switch loads the value? Presumably something like, "if (NeedsRearrangeArgs) SubExprs.append(Args.begin(), Args.end()); else /*the switch*/.

Loop from L4762 will check "value" arguments assuming the API order as well. That's why arguments are arranged so that the value checking logic also check the correct arguments.

hliao updated this revision to Diff 221365.Sep 23 2019, 10:33 AM

Add parameter name for that default argument.

hliao marked an inline comment as done.Sep 23 2019, 10:33 AM
Harbormaster completed remote builds in B38441: Diff 221365.Sep 23 2019, 10:36 AM
erichkeane added a comment.Sep 23 2019, 10:45 AM

It kinda stinks that we have to do this at such a late step. I'd have much preferred doing this as a part of the rebuild, but it appears that the 'form' takes quite a bit to calculate. Also, I'd likely have preferred that the initial reordering happened in codegen instead of this early, though perhaps thats too large of a change to do here.

I think then we're stuck with this reordering step.

That said, I'm not a fan at all of doing this parameter as a bool, particularly one with an ambiguous name. Can you introduce an enum like "enum class AtomicArgumentOrder { API, AST}" that makes it more clear?

Additionally, ReArgs is a confusing name, how about APIOrderedArgs?

erichkeane added a comment.Sep 23 2019, 10:59 AM

Also, can you add a test for GNUCmpXchg in both situations (inside a template, and outside)? It is the most complicated, and would best reflect the issue.

hliao updated this revision to Diff 221369.Sep 23 2019, 11:07 AM

revised

Harbormaster completed remote builds in B38444: Diff 221369.Sep 23 2019, 11:09 AM
erichkeane added a comment.Sep 23 2019, 11:12 AM

Seems your test changes have disappeared as well? Otherwise, 1 comment then I'm ok with this.

clang/lib/Sema/TreeTransform.h
3319

The comment is no longer necessary, since the enum describes the purpose.

hliao updated this revision to Diff 221374.Sep 23 2019, 11:31 AM

add test case for compare_exchange.

Harbormaster completed remote builds in B38446: Diff 221374.Sep 23 2019, 11:32 AM
hliao updated this revision to Diff 221375.Sep 23 2019, 11:32 AM

update

Harbormaster completed remote builds in B38447: Diff 221375.Sep 23 2019, 11:33 AM
hliao marked an inline comment as done.Sep 23 2019, 11:33 AM
erichkeane accepted this revision.Sep 23 2019, 11:34 AM
This revision is now accepted and ready to land.Sep 23 2019, 11:34 AM
Closed by commit rL372640: [Sema] Fix the atomic expr rebuilding order. (authored by hliao). · Explain WhySep 23 2019, 11:51 AM
This revision was automatically updated to reflect the committed changes.
Herald added a project: Restricted Project. · View Herald TranscriptSep 23 2019, 11:51 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript

Revision Contents

PathSize
clang/
include/
clang/
Sema/
9 lines
lib/
Sema/
90 lines
6 lines
test/
AST/
43 lines

Diff 221375

clang/include/clang/Sema/Sema.h

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,631 Lines • ▼ Show 20 Linespublic:
/// locations. /// locations.
ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
MultiExprArg ArgExprs, SourceLocation RParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc,
Expr *ExecConfig = nullptr); Expr *ExecConfig = nullptr);
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
MultiExprArg ArgExprs, SourceLocation RParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc,
Expr *ExecConfig = nullptr, Expr *ExecConfig = nullptr,
bool IsExecConfig = false); bool IsExecConfig = false);
ExprResult BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange, enum class AtomicArgumentOrder { API, AST };
ExprResult
BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
SourceLocation RParenLoc, MultiExprArg Args, SourceLocation RParenLoc, MultiExprArg Args,
AtomicExpr::AtomicOp Op); AtomicExpr::AtomicOp Op,
AtomicArgumentOrder ArgOrder = AtomicArgumentOrder::API);
ExprResult ExprResult
BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc,
ArrayRef<Expr *> Arg, SourceLocation RParenLoc, ArrayRef<Expr *> Arg, SourceLocation RParenLoc,
Expr *Config = nullptr, bool IsExecConfig = false, Expr *Config = nullptr, bool IsExecConfig = false,
ADLCallKind UsesADL = ADLCallKind::NotADL); ADLCallKind UsesADL = ADLCallKind::NotADL);
ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc, ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,
MultiExprArg ExecConfig, MultiExprArg ExecConfig,
▲ Show 20 Lines • Show All 6,818 Lines • Show Last 20 Lines

clang/lib/Sema/SemaChecking.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,467 Lines • ▼ Show 20 LinesExprResult Sema::SemaAtomicOpsOverloaded(ExprResult TheCallResult,
MultiExprArg Args{TheCall->getArgs(), TheCall->getNumArgs()}; MultiExprArg Args{TheCall->getArgs(), TheCall->getNumArgs()};
return BuildAtomicExpr({TheCall->getBeginLoc(), TheCall->getEndLoc()}, return BuildAtomicExpr({TheCall->getBeginLoc(), TheCall->getEndLoc()},
DRE->getSourceRange(), TheCall->getRParenLoc(), Args, DRE->getSourceRange(), TheCall->getRParenLoc(), Args,
Op); Op);
} }
ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange, ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
SourceLocation RParenLoc, MultiExprArg Args, SourceLocation RParenLoc, MultiExprArg Args,
AtomicExpr::AtomicOp Op) { AtomicExpr::AtomicOp Op,
AtomicArgumentOrder ArgOrder) {
// All the non-OpenCL operations take one of the following forms. // All the non-OpenCL operations take one of the following forms.
// The OpenCL operations take the __c11 forms with one extra argument for // The OpenCL operations take the __c11 forms with one extra argument for
// synchronization scope. // synchronization scope.
enum { enum {
// C __c11_atomic_init(A *, C) // C __c11_atomic_init(A *, C)
Init, Init,
// C __c11_atomic_load(A *, int) // C __c11_atomic_load(A *, int)
▲ Show 20 Lines • Show All 264 Lines • ▼ Show 20 LinesExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
// arguments are actually passed as pointers. // arguments are actually passed as pointers.
QualType ByValType = ValType; // 'CP' QualType ByValType = ValType; // 'CP'
bool IsPassedByAddress = false; bool IsPassedByAddress = false;
if (!IsC11 && !IsN) { if (!IsC11 && !IsN) {
ByValType = Ptr->getType(); ByValType = Ptr->getType();
IsPassedByAddress = true; IsPassedByAddress = true;
} }
SmallVector<Expr *, 5> APIOrderedArgs;
if (ArgOrder == Sema::AtomicArgumentOrder::AST) {
APIOrderedArgs.push_back(Args[0]);
switch (Form) {
case Init:
case Load:
APIOrderedArgs.push_back(Args[1]); // Val1/Order
break;
case LoadCopy:
case Copy:
case Arithmetic:
case Xchg:
APIOrderedArgs.push_back(Args[2]); // Val1
APIOrderedArgs.push_back(Args[1]); // Order
break;
case GNUXchg:
APIOrderedArgs.push_back(Args[2]); // Val1
APIOrderedArgs.push_back(Args[3]); // Val2
APIOrderedArgs.push_back(Args[1]); // Order
break;
case C11CmpXchg:
APIOrderedArgs.push_back(Args[2]); // Val1
APIOrderedArgs.push_back(Args[4]); // Val2
APIOrderedArgs.push_back(Args[1]); // Order
APIOrderedArgs.push_back(Args[3]); // OrderFail
break;
case GNUCmpXchg:
APIOrderedArgs.push_back(Args[2]); // Val1
APIOrderedArgs.push_back(Args[4]); // Val2
APIOrderedArgs.push_back(Args[5]); // Weak
APIOrderedArgs.push_back(Args[1]); // Order
APIOrderedArgs.push_back(Args[3]); // OrderFail
break;
}
} else
APIOrderedArgs.append(Args.begin(), Args.end());
// The first argument's non-CV pointer type is used to deduce the type of // The first argument's non-CV pointer type is used to deduce the type of
// subsequent arguments, except for: // subsequent arguments, except for:
// - weak flag (always converted to bool) // - weak flag (always converted to bool)
// - memory order (always converted to int) // - memory order (always converted to int)
// - scope (always converted to int) // - scope (always converted to int)
for (unsigned i = 0; i != Args.size(); ++i) { for (unsigned i = 0; i != APIOrderedArgs.size(); ++i) {
QualType Ty; QualType Ty;
if (i < NumVals[Form] + 1) { if (i < NumVals[Form] + 1) {
switch (i) { switch (i) {
case 0: case 0:
// The first argument is always a pointer. It has a fixed type. // The first argument is always a pointer. It has a fixed type.
// It is always dereferenced, a nullptr is undefined. // It is always dereferenced, a nullptr is undefined.
CheckNonNullArgument(*this, Args[i], ExprRange.getBegin()); CheckNonNullArgument(*this, APIOrderedArgs[i], ExprRange.getBegin());
// Nothing else to do: we already know all we want about this pointer. // Nothing else to do: we already know all we want about this pointer.
continue; continue;
case 1: case 1:
// The second argument is the non-atomic operand. For arithmetic, this // The second argument is the non-atomic operand. For arithmetic, this
// is always passed by value, and for a compare_exchange it is always // is always passed by value, and for a compare_exchange it is always
// passed by address. For the rest, GNU uses by-address and C11 uses // passed by address. For the rest, GNU uses by-address and C11 uses
// by-value. // by-value.
assert(Form != Load); assert(Form != Load);
if (Form == Init || (Form == Arithmetic && ValType->isIntegerType())) if (Form == Init || (Form == Arithmetic && ValType->isIntegerType()))
Ty = ValType; Ty = ValType;
else if (Form == Copy || Form == Xchg) { else if (Form == Copy || Form == Xchg) {
if (IsPassedByAddress) if (IsPassedByAddress) {
// The value pointer is always dereferenced, a nullptr is undefined. // The value pointer is always dereferenced, a nullptr is undefined.
CheckNonNullArgument(*this, Args[i], ExprRange.getBegin()); CheckNonNullArgument(*this, APIOrderedArgs[i],
ExprRange.getBegin());
}
Ty = ByValType; Ty = ByValType;
} else if (Form == Arithmetic) } else if (Form == Arithmetic)
Ty = Context.getPointerDiffType(); Ty = Context.getPointerDiffType();
else { else {
Expr *ValArg = Args[i]; Expr *ValArg = APIOrderedArgs[i];
// The value pointer is always dereferenced, a nullptr is undefined. // The value pointer is always dereferenced, a nullptr is undefined.
CheckNonNullArgument(*this, ValArg, ExprRange.getBegin()); CheckNonNullArgument(*this, ValArg, ExprRange.getBegin());
LangAS AS = LangAS::Default; LangAS AS = LangAS::Default;
// Keep address space of non-atomic pointer type. // Keep address space of non-atomic pointer type.
if (const PointerType *PtrTy = if (const PointerType *PtrTy =
ValArg->getType()->getAs<PointerType>()) { ValArg->getType()->getAs<PointerType>()) {
AS = PtrTy->getPointeeType().getAddressSpace(); AS = PtrTy->getPointeeType().getAddressSpace();
} }
Ty = Context.getPointerType( Ty = Context.getPointerType(
Context.getAddrSpaceQualType(ValType.getUnqualifiedType(), AS)); Context.getAddrSpaceQualType(ValType.getUnqualifiedType(), AS));
} }
break; break;
case 2: case 2:
// The third argument to compare_exchange / GNU exchange is the desired // The third argument to compare_exchange / GNU exchange is the desired
// value, either by-value (for the C11 and *_n variant) or as a pointer. // value, either by-value (for the C11 and *_n variant) or as a pointer.
if (IsPassedByAddress) if (IsPassedByAddress)
CheckNonNullArgument(*this, Args[i], ExprRange.getBegin()); CheckNonNullArgument(*this, APIOrderedArgs[i], ExprRange.getBegin());
Ty = ByValType; Ty = ByValType;
break; break;
case 3: case 3:
// The fourth argument to GNU compare_exchange is a 'weak' flag. // The fourth argument to GNU compare_exchange is a 'weak' flag.
Ty = Context.BoolTy; Ty = Context.BoolTy;
break; break;
} }
} else { } else {
// The order(s) and scope are always converted to int. // The order(s) and scope are always converted to int.
Ty = Context.IntTy; Ty = Context.IntTy;
} }
InitializedEntity Entity = InitializedEntity Entity =
InitializedEntity::InitializeParameter(Context, Ty, false); InitializedEntity::InitializeParameter(Context, Ty, false);
ExprResult Arg = Args[i]; ExprResult Arg = APIOrderedArgs[i];
Arg = PerformCopyInitialization(Entity, SourceLocation(), Arg); Arg = PerformCopyInitialization(Entity, SourceLocation(), Arg);
if (Arg.isInvalid()) if (Arg.isInvalid())
return true; return true;
Args[i] = Arg.get(); APIOrderedArgs[i] = Arg.get();
} }
// Permute the arguments into a 'consistent' order. // Permute the arguments into a 'consistent' order.
SmallVector<Expr*, 5> SubExprs; SmallVector<Expr*, 5> SubExprs;
SubExprs.push_back(Ptr); SubExprs.push_back(Ptr);
switch (Form) { switch (Form) {
case Init: case Init:
// Note, AtomicExpr::getVal1() has a special case for this atomic. // Note, AtomicExpr::getVal1() has a special case for this atomic.
SubExprs.push_back(Args[1]); // Val1 SubExprs.push_back(APIOrderedArgs[1]); // Val1
break; break;
case Load: case Load:
SubExprs.push_back(Args[1]); // Order SubExprs.push_back(APIOrderedArgs[1]); // Order
break; break;
case LoadCopy: case LoadCopy:
case Copy: case Copy:
case Arithmetic: case Arithmetic:
case Xchg: case Xchg:
SubExprs.push_back(Args[2]); // Order SubExprs.push_back(APIOrderedArgs[2]); // Order
SubExprs.push_back(Args[1]); // Val1 SubExprs.push_back(APIOrderedArgs[1]); // Val1
break; break;
case GNUXchg: case GNUXchg:
// Note, AtomicExpr::getVal2() has a special case for this atomic. // Note, AtomicExpr::getVal2() has a special case for this atomic.
SubExprs.push_back(Args[3]); // Order SubExprs.push_back(APIOrderedArgs[3]); // Order
SubExprs.push_back(Args[1]); // Val1 SubExprs.push_back(APIOrderedArgs[1]); // Val1
SubExprs.push_back(Args[2]); // Val2 SubExprs.push_back(APIOrderedArgs[2]); // Val2
break; break;
case C11CmpXchg: case C11CmpXchg:
SubExprs.push_back(Args[3]); // Order SubExprs.push_back(APIOrderedArgs[3]); // Order
SubExprs.push_back(Args[1]); // Val1 SubExprs.push_back(APIOrderedArgs[1]); // Val1
SubExprs.push_back(Args[4]); // OrderFail SubExprs.push_back(APIOrderedArgs[4]); // OrderFail
SubExprs.push_back(Args[2]); // Val2 SubExprs.push_back(APIOrderedArgs[2]); // Val2
break; break;
case GNUCmpXchg: case GNUCmpXchg:
SubExprs.push_back(Args[4]); // Order SubExprs.push_back(APIOrderedArgs[4]); // Order
SubExprs.push_back(Args[1]); // Val1 SubExprs.push_back(APIOrderedArgs[1]); // Val1
SubExprs.push_back(Args[5]); // OrderFail SubExprs.push_back(APIOrderedArgs[5]); // OrderFail
SubExprs.push_back(Args[2]); // Val2 SubExprs.push_back(APIOrderedArgs[2]); // Val2
SubExprs.push_back(Args[3]); // Weak SubExprs.push_back(APIOrderedArgs[3]); // Weak
break; break;
} }
if (SubExprs.size() >= 2 && Form != Init) { if (SubExprs.size() >= 2 && Form != Init) {
llvm::APSInt Result(32); llvm::APSInt Result(32);
if (SubExprs[1]->isIntegerConstantExpr(Result, Context) && if (SubExprs[1]->isIntegerConstantExpr(Result, Context) &&
!isValidOrderingForOp(Result.getSExtValue(), Op)) !isValidOrderingForOp(Result.getSExtValue(), Op))
Diag(SubExprs[1]->getBeginLoc(), Diag(SubExprs[1]->getBeginLoc(),
▲ Show 20 Lines • Show All 9,663 Lines • Show Last 20 Lines

clang/lib/Sema/TreeTransform.h

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,302 Lines • ▼ Show 20 Lines ExprResult RebuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
BinaryOperatorKind Operator) { BinaryOperatorKind Operator) {
return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator); return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator);
} }
/// Build a new atomic operation expression. /// Build a new atomic operation expression.
/// ///
/// By default, performs semantic analysis to build the new expression. /// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior. /// Subclasses may override this routine to provide different behavior.
ExprResult RebuildAtomicExpr(SourceLocation BuiltinLoc, ExprResult RebuildAtomicExpr(SourceLocation BuiltinLoc, MultiExprArg SubExprs,
MultiExprArg SubExprs,
AtomicExpr::AtomicOp Op, AtomicExpr::AtomicOp Op,
SourceLocation RParenLoc) { SourceLocation RParenLoc) {
// Use this for all of the locations, since we don't know the difference // Use this for all of the locations, since we don't know the difference
// between the call and the expr at this point. // between the call and the expr at this point.
SourceRange Range{BuiltinLoc, RParenLoc}; SourceRange Range{BuiltinLoc, RParenLoc};
return getSema().BuildAtomicExpr(Range, Range, RParenLoc, SubExprs, Op); return getSema().BuildAtomicExpr(Range, Range, RParenLoc, SubExprs, Op,
Sema::AtomicArgumentOrder::AST);
erichkeaneUnsubmitted
Done
ReplyInline Actions

When passing a bool, use the comment syntax /*paramname=*/ to make it clear whats happening.

erichkeane: When passing a bool, use the comment syntax /*paramname=*/ to make it clear whats happening.
} }
erichkeaneUnsubmitted
Done
ReplyInline Actions

The comment is no longer necessary, since the enum describes the purpose.

erichkeane: The comment is no longer necessary, since the enum describes the purpose.
private: private:
TypeLoc TransformTypeInObjectScope(TypeLoc TL, TypeLoc TransformTypeInObjectScope(TypeLoc TL,
QualType ObjectType, QualType ObjectType,
NamedDecl *FirstQualifierInScope, NamedDecl *FirstQualifierInScope,
CXXScopeSpec &SS); CXXScopeSpec &SS);
TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo, TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
▲ Show 20 Lines • Show All 9,936 Lines • Show Last 20 Lines

clang/test/AST/atomic-expr.cpp

// RUN: %clang_cc1 -ast-dump %s | FileCheck %s // RUN: %clang_cc1 -ast-dump %s | FileCheck %s
template<int N = 0> template<int N = 0>
void pr43370() { void pr43370() {
int arr[2]; int arr[2];
__atomic_store_n(arr, 0, 0); __atomic_store_n(arr, 0, 5);
} }
template<int N = 0>
void foo() {
int arr[2];
(void)__atomic_compare_exchange_n(arr, arr, 1, 0, 3, 4);
}
void useage(){ void useage(){
pr43370(); pr43370();
foo();
} }
// CHECK:FunctionTemplateDecl 0x{{[0-9a-f]+}} <{{[^,]+}}, line:7:1> line:4:6 pr43370 // CHECK:FunctionTemplateDecl 0x{{[0-9a-f]+}} <{{[^,]+}}, line:7:1> line:4:6 pr43370
// CHECK: AtomicExpr // CHECK: AtomicExpr
// CHECK-NEXT: ImplicitCastExpr // CHECK-NEXT: ImplicitCastExpr
// CHECK-SAME: <ArrayToPointerDecay> // CHECK-SAME: <ArrayToPointerDecay>
// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:20> 'int [2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int [2]'
// CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}} <{{[^:]+}}:28> 'int' 5
// CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}} <{{[^:]+}}:25> 'int' 0
// CHECK:FunctionDecl 0x{{[0-9a-f]+}} <line:4:1, line:7:1> line:4:6 used pr43370 // CHECK:FunctionDecl 0x{{[0-9a-f]+}} <line:4:1, line:7:1> line:4:6 used pr43370
// CHECK: AtomicExpr // CHECK: AtomicExpr
// CHECK-NEXT: ImplicitCastExpr // CHECK-NEXT: ImplicitCastExpr
// CHECK-SAME: <ArrayToPointerDecay> // CHECK-SAME: <ArrayToPointerDecay>
// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:20> 'int [2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int [2]'
// CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}} <{{[^:]+}}:28> 'int' 5
// CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}} <{{[^:]+}}:25> 'int' 0
// CHECK:FunctionTemplateDecl 0x{{[0-9a-f]+}} <line:9:1, line:13:1> line:10:6 foo
// CHECK: AtomicExpr
// CHECK-NEXT: ImplicitCastExpr
// CHECK-SAME: <ArrayToPointerDecay>
// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:37> 'int [2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int [2]'
// CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}} <{{[^:]+}}:53> 'int' 3
// CHECK-NEXT: ImplicitCastExpr
// CHECK-SAME: <ArrayToPointerDecay>
// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:42> 'int [2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int [2]'
// CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}} <{{[^:]+}}:56> 'int' 4
// CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}} <{{[^:]+}}:47> 'int' 1
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}} <{{[^:]+}}:50> 'int' 0
// CHECK:FunctionDecl 0x{{[0-9a-f]+}} <line:10:1, line:13:1> line:10:6 used foo
// CHECK: AtomicExpr
// CHECK-NEXT: ImplicitCastExpr
// CHECK-SAME: <ArrayToPointerDecay>
// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:37> 'int [2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int [2]'
// CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}} <{{[^:]+}}:53> 'int' 3
// CHECK-NEXT: ImplicitCastExpr
// CHECK-SAME: <ArrayToPointerDecay>
// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <{{[^:]+}}:42> 'int [2]' lvalue Var 0x{{[0-9a-f]+}} 'arr' 'int [2]'
// CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}} <{{[^:]+}}:56> 'int' 4
// CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}} <{{[^:]+}}:47> 'int' 1
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: IntegerLiteral 0x{{[0-9a-f]+}} <{{[^:]+}}:50> 'int' 0