maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Generalize llvm::replaceDbgDeclare and actually support the use-case that 

is mentioned in the documentation (inserting a deref before the plus_uconst).

llvm-svn: 320203
This commit is contained in:
Adrian Prantl 2017-12-08 21:58:18 +00:00
parent 195dfd10a6
commit d13170174c
11 changed files with 56 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
llvm/include/llvm/IR/DebugInfoMetadata.h
View File

@ -2297,8 +2297,9 @@ public:
/// Prepend \p DIExpr with a deref and offset operation and optionally turn it
/// into a stack value.
static DIExpression *prepend(const DIExpression *DIExpr, bool Deref,
int64_t Offset = 0, bool StackValue = false);
static DIExpression *prepend(const DIExpression *DIExpr, bool DerefBefore,
int64_t Offset = 0, bool DerefAfter = false,
bool StackValue = false);
/// Create a DIExpression to describe one part of an aggregate variable that
/// is fragmented across multiple Values. The DW_OP_LLVM_fragment operation

24
llvm/include/llvm/Transforms/Utils/Local.h
View File

@ -335,22 +335,24 @@ TinyPtrVector<DbgInfoIntrinsic *> FindDbgAddrUses(Value *V);
/// Finds the llvm.dbg.value intrinsics describing a value.
void findDbgValues(SmallVectorImpl<DbgValueInst *> &DbgValues, Value *V);
/// Replaces llvm.dbg.declare instruction when the address it describes
/// is replaced with a new value. If Deref is true, an additional DW_OP_deref is
/// prepended to the expression. If Offset is non-zero, a constant displacement
/// is added to the expression (after the optional Deref). Offset can be
/// negative.
/// Replaces llvm.dbg.declare instruction when the address it
/// describes is replaced with a new value. If Deref is true, an
/// additional DW_OP_deref is prepended to the expression. If Offset
/// is non-zero, a constant displacement is added to the expression
/// (between the optional Deref operations). Offset can be negative.
bool replaceDbgDeclare(Value *Address, Value *NewAddress,
Instruction *InsertBefore, DIBuilder &Builder,
bool Deref, int Offset);
bool DerefBefore, int Offset, bool DerefAfter);
/// Replaces llvm.dbg.declare instruction when the alloca it describes
/// is replaced with a new value. If Deref is true, an additional DW_OP_deref is
/// prepended to the expression. If Offset is non-zero, a constant displacement
/// is added to the expression (after the optional Deref). Offset can be
/// negative. New llvm.dbg.declare is inserted immediately before AI.
/// is replaced with a new value. If Deref is true, an additional
/// DW_OP_deref is prepended to the expression. If Offset is non-zero,
/// a constant displacement is added to the expression (between the
/// optional Deref operations). Offset can be negative. The new
/// llvm.dbg.declare is inserted immediately before AI.
bool replaceDbgDeclareForAlloca(AllocaInst *AI, Value *NewAllocaAddress,
DIBuilder &Builder, bool Deref, int Offset = 0);
DIBuilder &Builder, bool DerefBefore,
int Offset, bool DerefAfter);
/// Replaces multiple llvm.dbg.value instructions when the alloca it describes
/// is replaced with a new value. If Offset is non-zero, a constant displacement

8
llvm/lib/CodeGen/SafeStack.cpp
View File

@ -558,7 +558,7 @@ Value *SafeStack::moveStaticAllocasToUnsafeStack(
// Replace alloc with the new location.
replaceDbgDeclare(Arg, BasePointer, BasePointer->getNextNode(), DIB,
/*Deref=*/false, -Offset);
DIExpression::NoDeref, -Offset, DIExpression::NoDeref);
Arg->replaceAllUsesWith(NewArg);
IRB.SetInsertPoint(cast<Instruction>(NewArg)->getNextNode());
IRB.CreateMemCpy(Off, Arg, Size, Arg->getParamAlignment());
@ -573,7 +573,8 @@ Value *SafeStack::moveStaticAllocasToUnsafeStack(
if (Size == 0)
Size = 1; // Don't create zero-sized stack objects.
replaceDbgDeclareForAlloca(AI, BasePointer, DIB, /*Deref=*/false, -Offset);
replaceDbgDeclareForAlloca(AI, BasePointer, DIB, DIExpression::NoDeref,
-Offset, DIExpression::NoDeref);
replaceDbgValueForAlloca(AI, BasePointer, DIB, -Offset);
// Replace uses of the alloca with the new location.
@ -663,7 +664,8 @@ void SafeStack::moveDynamicAllocasToUnsafeStack(
if (AI->hasName() && isa<Instruction>(NewAI))
NewAI->takeName(AI);
replaceDbgDeclareForAlloca(AI, NewAI, DIB, /*Deref=*/false);
replaceDbgDeclareForAlloca(AI, NewAI, DIB, DIExpression::NoDeref, 0,
DIExpression::NoDeref);
AI->replaceAllUsesWith(NewAI);
AI->eraseFromParent();
}

1
llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
View File

@ -7130,6 +7130,7 @@ void SelectionDAG::salvageDebugInfo(SDNode &N) {
// DW_OP_stack_value.
auto *DIExpr = DV->getExpression();
DIExpr = DIExpression::prepend(DIExpr, DIExpression::NoDeref, Offset,
DIExpression::NoDeref,
DIExpression::WithStackValue);
SDDbgValue *Clone =
getDbgValue(DV->getVariable(), DIExpr, N0.getNode(), N0.getResNo(),

13
llvm/lib/IR/DebugInfoMetadata.cpp
View File

@ -750,12 +750,17 @@ bool DIExpression::extractIfOffset(int64_t &Offset) const {
return false;
}
DIExpression *DIExpression::prepend(const DIExpression *Expr, bool Deref,
int64_t Offset, bool StackValue) {
DIExpression *DIExpression::prepend(const DIExpression *Expr, bool DerefBefore,
int64_t Offset, bool DerefAfter,
bool StackValue) {
SmallVector<uint64_t, 8> Ops;
appendOffset(Ops, Offset);
if (Deref)
if (DerefBefore)
Ops.push_back(dwarf::DW_OP_deref);
appendOffset(Ops, Offset);
if (DerefAfter)
Ops.push_back(dwarf::DW_OP_deref);
if (Expr)
for (auto Op : Expr->expr_ops()) {
// A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment.

1
llvm/lib/Target/X86/X86OptimizeLEAs.cpp
View File

@ -568,6 +568,7 @@ MachineInstr *OptimizeLEAPass::replaceDebugValue(MachineInstr &MI,
if (AddrDispShift != 0)
Expr = DIExpression::prepend(Expr, DIExpression::NoDeref, AddrDispShift,
DIExpression::NoDeref,
DIExpression::WithStackValue);
// Replace DBG_VALUE instruction with modified version.

3
llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp
View File

@ -2918,7 +2918,8 @@ void FunctionStackPoisoner::processStaticAllocas() {
Value *NewAllocaPtr = IRB.CreateIntToPtr(
IRB.CreateAdd(LocalStackBase, ConstantInt::get(IntptrTy, Desc.Offset)),
AI->getType());
replaceDbgDeclareForAlloca(AI, NewAllocaPtr, DIB, DIExpression::NoDeref);
replaceDbgDeclareForAlloca(AI, NewAllocaPtr, DIB, DIExpression::NoDeref,
0, DIExpression::NoDeref);
AI->replaceAllUsesWith(NewAllocaPtr);
}

3
llvm/lib/Transforms/Utils/InlineFunction.cpp
View File

@ -1810,7 +1810,8 @@ bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
// Move any dbg.declares describing the allocas into the entry basic block.
DIBuilder DIB(*Caller->getParent());
for (auto &AI : IFI.StaticAllocas)
replaceDbgDeclareForAlloca(AI, AI, DIB, /*Deref=*/false);
replaceDbgDeclareForAlloca(AI, AI, DIB, DIExpression::NoDeref, 0,
DIExpression::NoDeref);
}
SmallVector<Value*,4> VarArgsToForward;

10
llvm/lib/Transforms/Utils/Local.cpp
View File

@ -1304,14 +1304,14 @@ static void findDbgUsers(SmallVectorImpl<DbgInfoIntrinsic *> &DbgUsers,
bool llvm::replaceDbgDeclare(Value *Address, Value *NewAddress,
Instruction *InsertBefore, DIBuilder &Builder,
bool Deref, int Offset) {
bool DerefBefore, int Offset, bool DerefAfter) {
auto DbgAddrs = FindDbgAddrUses(Address);
for (DbgInfoIntrinsic *DII : DbgAddrs) {
DebugLoc Loc = DII->getDebugLoc();
auto *DIVar = DII->getVariable();
auto *DIExpr = DII->getExpression();
assert(DIVar && "Missing variable");
DIExpr = DIExpression::prepend(DIExpr, Deref, Offset);
DIExpr = DIExpression::prepend(DIExpr, DerefBefore, Offset, DerefAfter);
// Insert llvm.dbg.declare immediately after InsertBefore, and remove old
// llvm.dbg.declare.
Builder.insertDeclare(NewAddress, DIVar, DIExpr, Loc, InsertBefore);
@ -1323,9 +1323,10 @@ bool llvm::replaceDbgDeclare(Value *Address, Value *NewAddress,
}
bool llvm::replaceDbgDeclareForAlloca(AllocaInst *AI, Value *NewAllocaAddress,
DIBuilder &Builder, bool Deref, int Offset) {
DIBuilder &Builder, bool DerefBefore,
int Offset, bool DerefAfter) {
return replaceDbgDeclare(AI, NewAllocaAddress, AI->getNextNode(), Builder,
Deref, Offset);
DerefBefore, Offset, DerefAfter);
}
static void replaceOneDbgValueForAlloca(DbgValueInst *DVI, Value *NewAddress,
@ -1378,6 +1379,7 @@ void llvm::salvageDebugInfo(Instruction &I) {
auto applyOffset = [&](DbgValueInst *DVI, uint64_t Offset) {
auto *DIExpr = DVI->getExpression();
DIExpr = DIExpression::prepend(DIExpr, DIExpression::NoDeref, Offset,
DIExpression::NoDeref,
DIExpression::WithStackValue);
DVI->setOperand(0, wrapMD(I.getOperand(0)));
DVI->setOperand(2, MetadataAsValue::get(I.getContext(), DIExpr));

12
llvm/unittests/IR/MetadataTest.cpp
View File

@ -2031,6 +2031,18 @@ TEST_F(DIExpressionTest, get) {
TempDIExpression Temp = N->clone();
EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
// Test DIExpression::prepend().
uint64_t Elts0[] = {dwarf::DW_OP_LLVM_fragment, 0, 32};
auto *N0 = DIExpression::get(Context, Elts0);
N0 = DIExpression::prepend(N0, true, 64, true, true);
uint64_t Elts1[] = {dwarf::DW_OP_deref,
dwarf::DW_OP_plus_uconst, 64,
dwarf::DW_OP_deref,
dwarf::DW_OP_stack_value,
dwarf::DW_OP_LLVM_fragment, 0, 32};
auto *N1 = DIExpression::get(Context, Elts1);
EXPECT_EQ(N0, N1);
}
TEST_F(DIExpressionTest, isValid) {

3
llvm/unittests/Transforms/Utils/Local.cpp
View File

@ -157,7 +157,8 @@ TEST(Local, ReplaceDbgDeclare) {
ASSERT_TRUE(DII);
Value *NewBase = Constant::getNullValue(Type::getInt32PtrTy(C));
DIBuilder DIB(*M);
replaceDbgDeclare(AI, NewBase, DII, DIB, /*Deref=*/false, /*Offset=*/0);
replaceDbgDeclare(AI, NewBase, DII, DIB, DIExpression::NoDeref, 0,
DIExpression::NoDeref);
// There should be exactly two dbg.declares.
int Declares = 0;