Skip to content
This repository was archived by the owner on Nov 1, 2021. It is now read-only.

Commit 4ee7dc2

Browse files
nlewyckynlewycky
committed
Thread a SourceLocation into the EmitCheck for "load_invalid_value". This occurs
when scalars are loaded / undergo lvalue-to-rvalue conversion. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@191808 91177308-0d34-0410-b5e6-96231b3b80d8
1 parent 7453624 commit 4ee7dc2

15 files changed

+182
-133
lines changed

Diff for: ‎lib/CodeGen/CGAtomic.cpp

+32-21
Original file line numberDiff line numberDiff line change
@@ -106,7 +106,8 @@ namespace {
106106

107107
/// Turn an atomic-layout object into an r-value.
108108
RValue convertTempToRValue(llvm::Value *addr,
109-
AggValueSlot resultSlot) const;
109+
AggValueSlot resultSlot,
110+
SourceLocation loc) const;
110111

111112
/// Copy an atomic r-value into atomic-layout memory.
112113
void emitCopyIntoMemory(RValue rvalue, LValue lvalue) const;
@@ -321,11 +322,12 @@ EmitValToTemp(CodeGenFunction &CGF, Expr *E) {
321322

322323
static void
323324
AddDirectArgument(CodeGenFunction &CGF, CallArgList &Args,
324-
bool UseOptimizedLibcall, llvm::Value *Val, QualType ValTy) {
325+
bool UseOptimizedLibcall, llvm::Value *Val, QualType ValTy,
326+
SourceLocation Loc) {
325327
if (UseOptimizedLibcall) {
326328
// Load value and pass it to the function directly.
327329
unsigned Align = CGF.getContext().getTypeAlignInChars(ValTy).getQuantity();
328-
Val = CGF.EmitLoadOfScalar(Val, false, Align, ValTy);
330+
Val = CGF.EmitLoadOfScalar(Val, false, Align, ValTy, Loc);
329331
Args.add(RValue::get(Val), ValTy);
330332
} else {
331333
// Non-optimized functions always take a reference.
@@ -490,9 +492,9 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) {
490492
LibCallName = "__atomic_compare_exchange";
491493
RetTy = getContext().BoolTy;
492494
HaveRetTy = true;
493-
Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
494-
getContext().VoidPtrTy);
495-
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val2, MemTy);
495+
Args.add(RValue::get(EmitCastToVoidPtr(Val1)), getContext().VoidPtrTy);
496+
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val2, MemTy,
497+
E->getExprLoc());
496498
Args.add(RValue::get(Order), getContext().IntTy);
497499
Order = OrderFail;
498500
break;
@@ -503,7 +505,8 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) {
503505
case AtomicExpr::AO__atomic_exchange_n:
504506
case AtomicExpr::AO__atomic_exchange:
505507
LibCallName = "__atomic_exchange";
506-
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy);
508+
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy,
509+
E->getExprLoc());
507510
break;
508511
// void __atomic_store(size_t size, void *mem, void *val, int order)
509512
// void __atomic_store_N(T *mem, T val, int order)
@@ -513,7 +516,8 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) {
513516
LibCallName = "__atomic_store";
514517
RetTy = getContext().VoidTy;
515518
HaveRetTy = true;
516-
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy);
519+
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy,
520+
E->getExprLoc());
517521
break;
518522
// void __atomic_load(size_t size, void *mem, void *return, int order)
519523
// T __atomic_load_N(T *mem, int order)
@@ -526,31 +530,36 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) {
526530
case AtomicExpr::AO__c11_atomic_fetch_add:
527531
case AtomicExpr::AO__atomic_fetch_add:
528532
LibCallName = "__atomic_fetch_add";
529-
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy);
533+
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy,
534+
E->getExprLoc());
530535
break;
531536
// T __atomic_fetch_and_N(T *mem, T val, int order)
532537
case AtomicExpr::AO__c11_atomic_fetch_and:
533538
case AtomicExpr::AO__atomic_fetch_and:
534539
LibCallName = "__atomic_fetch_and";
535-
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy);
540+
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy,
541+
E->getExprLoc());
536542
break;
537543
// T __atomic_fetch_or_N(T *mem, T val, int order)
538544
case AtomicExpr::AO__c11_atomic_fetch_or:
539545
case AtomicExpr::AO__atomic_fetch_or:
540546
LibCallName = "__atomic_fetch_or";
541-
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy);
547+
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy,
548+
E->getExprLoc());
542549
break;
543550
// T __atomic_fetch_sub_N(T *mem, T val, int order)
544551
case AtomicExpr::AO__c11_atomic_fetch_sub:
545552
case AtomicExpr::AO__atomic_fetch_sub:
546553
LibCallName = "__atomic_fetch_sub";
547-
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy);
554+
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy,
555+
E->getExprLoc());
548556
break;
549557
// T __atomic_fetch_xor_N(T *mem, T val, int order)
550558
case AtomicExpr::AO__c11_atomic_fetch_xor:
551559
case AtomicExpr::AO__atomic_fetch_xor:
552560
LibCallName = "__atomic_fetch_xor";
553-
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy);
561+
AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1, MemTy,
562+
E->getExprLoc());
554563
break;
555564
default: return EmitUnsupportedRValue(E, "atomic library call");
556565
}
@@ -584,7 +593,7 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) {
584593
return Res;
585594
if (E->getType()->isVoidType())
586595
return RValue::get(0);
587-
return convertTempToRValue(Dest, E->getType());
596+
return convertTempToRValue(Dest, E->getType(), E->getExprLoc());
588597
}
589598

590599
bool IsStore = E->getOp() == AtomicExpr::AO__c11_atomic_store ||
@@ -639,7 +648,7 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) {
639648
}
640649
if (E->getType()->isVoidType())
641650
return RValue::get(0);
642-
return convertTempToRValue(OrigDest, E->getType());
651+
return convertTempToRValue(OrigDest, E->getType(), E->getExprLoc());
643652
}
644653

645654
// Long case, when Order isn't obviously constant.
@@ -701,7 +710,7 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) {
701710
Builder.SetInsertPoint(ContBB);
702711
if (E->getType()->isVoidType())
703712
return RValue::get(0);
704-
return convertTempToRValue(OrigDest, E->getType());
713+
return convertTempToRValue(OrigDest, E->getType(), E->getExprLoc());
705714
}
706715

707716
llvm::Value *AtomicInfo::emitCastToAtomicIntPointer(llvm::Value *addr) const {
@@ -713,7 +722,8 @@ llvm::Value *AtomicInfo::emitCastToAtomicIntPointer(llvm::Value *addr) const {
713722
}
714723

715724
RValue AtomicInfo::convertTempToRValue(llvm::Value *addr,
716-
AggValueSlot resultSlot) const {
725+
AggValueSlot resultSlot,
726+
SourceLocation loc) const {
717727
if (EvaluationKind == TEK_Aggregate)
718728
return resultSlot.asRValue();
719729

@@ -723,12 +733,13 @@ RValue AtomicInfo::convertTempToRValue(llvm::Value *addr,
723733

724734
// Otherwise, just convert the temporary to an r-value using the
725735
// normal conversion routine.
726-
return CGF.convertTempToRValue(addr, getValueType());
736+
return CGF.convertTempToRValue(addr, getValueType(), loc);
727737
}
728738

729739
/// Emit a load from an l-value of atomic type. Note that the r-value
730740
/// we produce is an r-value of the atomic *value* type.
731-
RValue CodeGenFunction::EmitAtomicLoad(LValue src, AggValueSlot resultSlot) {
741+
RValue CodeGenFunction::EmitAtomicLoad(LValue src, SourceLocation loc,
742+
AggValueSlot resultSlot) {
732743
AtomicInfo atomics(*this, src);
733744

734745
// Check whether we should use a library call.
@@ -755,7 +766,7 @@ RValue CodeGenFunction::EmitAtomicLoad(LValue src, AggValueSlot resultSlot) {
755766
emitAtomicLibcall(*this, "__atomic_load", getContext().VoidTy, args);
756767

757768
// Produce the r-value.
758-
return atomics.convertTempToRValue(tempAddr, resultSlot);
769+
return atomics.convertTempToRValue(tempAddr, resultSlot, loc);
759770
}
760771

761772
// Okay, we're doing this natively.
@@ -813,7 +824,7 @@ RValue CodeGenFunction::EmitAtomicLoad(LValue src, AggValueSlot resultSlot) {
813824
Builder.CreateAlignedStore(result, castTemp, tempAlignment.getQuantity())
814825
->setVolatile(tempIsVolatile);
815826

816-
return atomics.convertTempToRValue(temp, resultSlot);
827+
return atomics.convertTempToRValue(temp, resultSlot, loc);
817828
}
818829

819830

Diff for: ‎lib/CodeGen/CGBlocks.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -834,7 +834,7 @@ llvm::Value *CodeGenFunction::EmitBlockLiteral(const CGBlockInfo &blockInfo) {
834834
type->isBlockPointerType()) {
835835
// Load the block and do a simple retain.
836836
LValue srcLV = MakeAddrLValue(src, type, align);
837-
llvm::Value *value = EmitLoadOfScalar(srcLV);
837+
llvm::Value *value = EmitLoadOfScalar(srcLV, SourceLocation());
838838
value = EmitARCRetainNonBlock(value);
839839

840840
// Do a primitive store to the block field.
@@ -931,7 +931,7 @@ llvm::Type *CodeGenModule::getGenericBlockLiteralType() {
931931
}
932932

933933

934-
RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr* E,
934+
RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr *E,
935935
ReturnValueSlot ReturnValue) {
936936
const BlockPointerType *BPT =
937937
E->getCallee()->getType()->getAs<BlockPointerType>();

Diff for: ‎lib/CodeGen/CGCall.cpp

+17-13
Original file line numberDiff line numberDiff line change
@@ -1291,7 +1291,8 @@ void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
12911291
} else {
12921292
// Load scalar value from indirect argument.
12931293
CharUnits Alignment = getContext().getTypeAlignInChars(Ty);
1294-
V = EmitLoadOfScalar(V, false, Alignment.getQuantity(), Ty);
1294+
V = EmitLoadOfScalar(V, false, Alignment.getQuantity(), Ty,
1295+
Arg->getLocStart());
12951296

12961297
if (isPromoted)
12971298
V = emitArgumentDemotion(*this, Arg, V);
@@ -1406,7 +1407,7 @@ void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
14061407

14071408
// Match to what EmitParmDecl is expecting for this type.
14081409
if (CodeGenFunction::hasScalarEvaluationKind(Ty)) {
1409-
V = EmitLoadOfScalar(V, false, AlignmentToUse, Ty);
1410+
V = EmitLoadOfScalar(V, false, AlignmentToUse, Ty, Arg->getLocStart());
14101411
if (isPromoted)
14111412
V = emitArgumentDemotion(*this, Arg, V);
14121413
}
@@ -1645,7 +1646,8 @@ static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) {
16451646
}
16461647

16471648
void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
1648-
bool EmitRetDbgLoc) {
1649+
bool EmitRetDbgLoc,
1650+
SourceLocation EndLoc) {
16491651
// Functions with no result always return void.
16501652
if (ReturnValue == 0) {
16511653
Builder.CreateRetVoid();
@@ -1662,7 +1664,8 @@ void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
16621664
switch (getEvaluationKind(RetTy)) {
16631665
case TEK_Complex: {
16641666
ComplexPairTy RT =
1665-
EmitLoadOfComplex(MakeNaturalAlignAddrLValue(ReturnValue, RetTy));
1667+
EmitLoadOfComplex(MakeNaturalAlignAddrLValue(ReturnValue, RetTy),
1668+
EndLoc);
16661669
EmitStoreOfComplex(RT,
16671670
MakeNaturalAlignAddrLValue(CurFn->arg_begin(), RetTy),
16681671
/*isInit*/ true);
@@ -1746,7 +1749,8 @@ void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
17461749
}
17471750

17481751
void CodeGenFunction::EmitDelegateCallArg(CallArgList &args,
1749-
const VarDecl *param) {
1752+
const VarDecl *param,
1753+
SourceLocation loc) {
17501754
// StartFunction converted the ABI-lowered parameter(s) into a
17511755
// local alloca. We need to turn that into an r-value suitable
17521756
// for EmitCall.
@@ -1767,7 +1771,7 @@ void CodeGenFunction::EmitDelegateCallArg(CallArgList &args,
17671771
return args.add(RValue::get(Builder.CreateLoad(local)), type);
17681772
}
17691773

1770-
args.add(convertTempToRValue(local, type), type);
1774+
args.add(convertTempToRValue(local, type, loc), type);
17711775
}
17721776

17731777
static bool isProvablyNull(llvm::Value *addr) {
@@ -1826,7 +1830,7 @@ static void emitWriteback(CodeGenFunction &CGF,
18261830
CGF.EmitARCIntrinsicUse(writeback.ToUse);
18271831

18281832
// Load the old value (primitively).
1829-
llvm::Value *oldValue = CGF.EmitLoadOfScalar(srcLV);
1833+
llvm::Value *oldValue = CGF.EmitLoadOfScalar(srcLV, SourceLocation());
18301834

18311835
// Put the new value in place (primitively).
18321836
CGF.EmitStoreOfScalar(value, srcLV, /*init*/ false);
@@ -1955,7 +1959,7 @@ static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args,
19551959

19561960
// Perform a copy if necessary.
19571961
if (shouldCopy) {
1958-
RValue srcRV = CGF.EmitLoadOfLValue(srcLV);
1962+
RValue srcRV = CGF.EmitLoadOfLValue(srcLV, SourceLocation());
19591963
assert(srcRV.isScalar());
19601964

19611965
llvm::Value *src = srcRV.getScalarVal();
@@ -2191,7 +2195,7 @@ void CodeGenFunction::ExpandTypeToArgs(QualType Ty, RValue RV,
21912195
llvm::Value *Addr = RV.getAggregateAddr();
21922196
for (unsigned Elt = 0; Elt < NumElts; ++Elt) {
21932197
llvm::Value *EltAddr = Builder.CreateConstGEP2_32(Addr, 0, Elt);
2194-
RValue EltRV = convertTempToRValue(EltAddr, EltTy);
2198+
RValue EltRV = convertTempToRValue(EltAddr, EltTy, SourceLocation());
21952199
ExpandTypeToArgs(EltTy, EltRV, Args, IRFuncTy);
21962200
}
21972201
} else if (const RecordType *RT = Ty->getAs<RecordType>()) {
@@ -2215,15 +2219,15 @@ void CodeGenFunction::ExpandTypeToArgs(QualType Ty, RValue RV,
22152219
}
22162220
}
22172221
if (LargestFD) {
2218-
RValue FldRV = EmitRValueForField(LV, LargestFD);
2222+
RValue FldRV = EmitRValueForField(LV, LargestFD, SourceLocation());
22192223
ExpandTypeToArgs(LargestFD->getType(), FldRV, Args, IRFuncTy);
22202224
}
22212225
} else {
22222226
for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
22232227
i != e; ++i) {
22242228
FieldDecl *FD = *i;
22252229

2226-
RValue FldRV = EmitRValueForField(LV, FD);
2230+
RValue FldRV = EmitRValueForField(LV, FD, SourceLocation());
22272231
ExpandTypeToArgs(FD->getType(), FldRV, Args, IRFuncTy);
22282232
}
22292233
}
@@ -2541,7 +2545,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
25412545

25422546
switch (RetAI.getKind()) {
25432547
case ABIArgInfo::Indirect:
2544-
return convertTempToRValue(Args[0], RetTy);
2548+
return convertTempToRValue(Args[0], RetTy, SourceLocation());
25452549

25462550
case ABIArgInfo::Ignore:
25472551
// If we are ignoring an argument that had a result, make sure to
@@ -2599,7 +2603,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
25992603
}
26002604
CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this);
26012605

2602-
return convertTempToRValue(DestPtr, RetTy);
2606+
return convertTempToRValue(DestPtr, RetTy, SourceLocation());
26032607
}
26042608

26052609
case ABIArgInfo::Expand:

Diff for: ‎lib/CodeGen/CGClass.cpp

+7-5
Original file line numberDiff line numberDiff line change
@@ -704,7 +704,7 @@ void CodeGenFunction::EmitConstructorBody(FunctionArgList &Args) {
704704
CGM.getTarget().getCXXABI().hasConstructorVariants()) {
705705
if (CGDebugInfo *DI = getDebugInfo())
706706
DI->EmitLocation(Builder, Ctor->getLocEnd());
707-
EmitDelegateCXXConstructorCall(Ctor, Ctor_Base, Args);
707+
EmitDelegateCXXConstructorCall(Ctor, Ctor_Base, Args, Ctor->getLocEnd());
708708
return;
709709
}
710710

@@ -1742,7 +1742,8 @@ CodeGenFunction::EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D,
17421742
void
17431743
CodeGenFunction::EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor,
17441744
CXXCtorType CtorType,
1745-
const FunctionArgList &Args) {
1745+
const FunctionArgList &Args,
1746+
SourceLocation Loc) {
17461747
CallArgList DelegateArgs;
17471748

17481749
FunctionArgList::const_iterator I = Args.begin(), E = Args.end();
@@ -1769,7 +1770,8 @@ CodeGenFunction::EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor,
17691770
// Explicit arguments.
17701771
for (; I != E; ++I) {
17711772
const VarDecl *param = *I;
1772-
EmitDelegateCallArg(DelegateArgs, param);
1773+
// FIXME: per-argument source location
1774+
EmitDelegateCallArg(DelegateArgs, param, Loc);
17731775
}
17741776

17751777
llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(Ctor, CtorType);
@@ -2156,7 +2158,7 @@ void CodeGenFunction::EmitLambdaBlockInvokeBody() {
21562158
for (BlockDecl::param_const_iterator I = BD->param_begin(),
21572159
E = BD->param_end(); I != E; ++I) {
21582160
ParmVarDecl *param = *I;
2159-
EmitDelegateCallArg(CallArgs, param);
2161+
EmitDelegateCallArg(CallArgs, param, param->getLocStart());
21602162
}
21612163
assert(!Lambda->isGenericLambda() &&
21622164
"generic lambda interconversion to block not implemented");
@@ -2188,7 +2190,7 @@ void CodeGenFunction::EmitLambdaDelegatingInvokeBody(const CXXMethodDecl *MD) {
21882190
for (FunctionDecl::param_const_iterator I = MD->param_begin(),
21892191
E = MD->param_end(); I != E; ++I) {
21902192
ParmVarDecl *param = *I;
2191-
EmitDelegateCallArg(CallArgs, param);
2193+
EmitDelegateCallArg(CallArgs, param, param->getLocStart());
21922194
}
21932195
const CXXMethodDecl *CallOp = Lambda->getLambdaCallOperator();
21942196
// For a generic lambda, find the corresponding call operator specialization

Diff for: ‎lib/CodeGen/CGDecl.cpp

+4-3
Original file line numberDiff line numberDiff line change
@@ -425,7 +425,8 @@ namespace {
425425
// byref or something.
426426
DeclRefExpr DRE(const_cast<VarDecl*>(&Var), false,
427427
Var.getType(), VK_LValue, SourceLocation());
428-
llvm::Value *value = CGF.EmitLoadOfScalar(CGF.EmitDeclRefLValue(&DRE));
428+
llvm::Value *value = CGF.EmitLoadOfScalar(CGF.EmitDeclRefLValue(&DRE),
429+
SourceLocation());
429430
CGF.EmitExtendGCLifetime(value);
430431
}
431432
};
@@ -652,7 +653,7 @@ void CodeGenFunction::EmitScalarInit(const Expr *init,
652653
// might have to initialize with a barrier. We have to do this for
653654
// both __weak and __strong, but __weak got filtered out above.
654655
if (accessedByInit && lifetime == Qualifiers::OCL_Strong) {
655-
llvm::Value *oldValue = EmitLoadOfScalar(lvalue);
656+
llvm::Value *oldValue = EmitLoadOfScalar(lvalue, init->getExprLoc());
656657
EmitStoreOfScalar(value, lvalue, /* isInitialization */ true);
657658
EmitARCRelease(oldValue, ARCImpreciseLifetime);
658659
return;
@@ -1688,7 +1689,7 @@ void CodeGenFunction::EmitParmDecl(const VarDecl &D, llvm::Value *Arg,
16881689
// use objc_storeStrong(&dest, value) for retaining the
16891690
// object. But first, store a null into 'dest' because
16901691
// objc_storeStrong attempts to release its old value.
1691-
llvm::Value * Null = CGM.EmitNullConstant(D.getType());
1692+
llvm::Value *Null = CGM.EmitNullConstant(D.getType());
16921693
EmitStoreOfScalar(Null, lv, /* isInitialization */ true);
16931694
EmitARCStoreStrongCall(lv.getAddress(), Arg, true);
16941695
doStore = false;

0 commit comments

Comments
 (0)