From b9768b0731f8b9a10fd2ee6bd1699ae8c02fc78c Mon Sep 17 00:00:00 2001 From: Victor Hernandez Date: Tue, 26 Jan 2010 02:42:15 +0000 Subject: [PATCH] In mem2reg, for all alloca/stores that get promoted where the alloca has an associated llvm.dbg.declare instrinsic, insert an llvm.dbg.var intrinsic before each store. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@94493 91177308-0d34-0410-b5e6-96231b3b80d8 --- .../Utils/PromoteMemoryToRegister.cpp | 53 ++++++++++++++++++- test/Transforms/Mem2Reg/ConvertDebugInfo.ll | 31 +++++++++++ 2 files changed, 83 insertions(+), 1 deletion(-) create mode 100644 test/Transforms/Mem2Reg/ConvertDebugInfo.ll diff --git a/lib/Transforms/Utils/PromoteMemoryToRegister.cpp b/lib/Transforms/Utils/PromoteMemoryToRegister.cpp index 9fdcfe5ec3d..f6cb71a2233 100644 --- a/lib/Transforms/Utils/PromoteMemoryToRegister.cpp +++ b/lib/Transforms/Utils/PromoteMemoryToRegister.cpp @@ -23,6 +23,8 @@ #include "llvm/Function.h" #include "llvm/Instructions.h" #include "llvm/IntrinsicInst.h" +#include "llvm/Metadata.h" +#include "llvm/Analysis/DebugInfo.h" #include "llvm/Analysis/Dominators.h" #include "llvm/Analysis/AliasSetTracker.h" #include "llvm/ADT/DenseMap.h" @@ -83,6 +85,17 @@ bool llvm::isAllocaPromotable(const AllocaInst *AI) { return true; } +/// Finds the llvm.dbg.declare intrinsic describing V, if any. +static DbgDeclareInst *findDbgDeclare(Value *V) { + if (MDNode *DebugNode = MDNode::getIfExists(V->getContext(), &V, 1)) + for (Value::use_iterator UI = DebugNode->use_begin(), + E = DebugNode->use_end(); UI != E; ++UI) + if (DbgDeclareInst *DDI = dyn_cast(*UI)) + return DDI; + + return 0; +} + namespace { struct AllocaInfo; @@ -163,6 +176,7 @@ namespace { std::vector Allocas; DominatorTree &DT; DominanceFrontier &DF; + DIFactory *DIF; /// AST - An AliasSetTracker object to update. If null, don't update it. /// @@ -186,6 +200,11 @@ namespace { /// std::vector PointerAllocaValues; + /// AllocaDbgDeclares - For each alloca, we keep track of the dbg.declare + /// intrinsic that describes it, if any, so that we can convert it to a + /// dbg.value intrinsic if the alloca gets promoted. + std::vector AllocaDbgDeclares; + /// Visited - The set of basic blocks the renamer has already visited. /// SmallPtrSet Visited; @@ -199,7 +218,7 @@ namespace { public: PromoteMem2Reg(const std::vector &A, DominatorTree &dt, DominanceFrontier &df, AliasSetTracker *ast) - : Allocas(A), DT(dt), DF(df), AST(ast) {} + : Allocas(A), DT(dt), DF(df), DIF(0), AST(ast) {} void run(); @@ -241,6 +260,8 @@ namespace { LargeBlockInfo &LBI); void PromoteSingleBlockAlloca(AllocaInst *AI, AllocaInfo &Info, LargeBlockInfo &LBI); + void ConvertDebugDeclareToDebugValue(DbgDeclareInst *DDI, StoreInst *SI, + uint64_t Offset); void RenamePass(BasicBlock *BB, BasicBlock *Pred, @@ -259,6 +280,7 @@ namespace { bool OnlyUsedInOneBlock; Value *AllocaPointerVal; + DbgDeclareInst *DbgDeclare; void clear() { DefiningBlocks.clear(); @@ -267,6 +289,7 @@ namespace { OnlyBlock = 0; OnlyUsedInOneBlock = true; AllocaPointerVal = 0; + DbgDeclare = 0; } /// AnalyzeAlloca - Scan the uses of the specified alloca, filling in our @@ -301,6 +324,8 @@ namespace { OnlyUsedInOneBlock = false; } } + + DbgDeclare = findDbgDeclare(AI); } }; } // end of anonymous namespace @@ -310,6 +335,7 @@ void PromoteMem2Reg::run() { Function &F = *DF.getRoot()->getParent(); if (AST) PointerAllocaValues.resize(Allocas.size()); + AllocaDbgDeclares.resize(Allocas.size()); AllocaInfo Info; LargeBlockInfo LBI; @@ -344,6 +370,8 @@ void PromoteMem2Reg::run() { // Finally, after the scan, check to see if the store is all that is left. if (Info.UsingBlocks.empty()) { + // Record debuginfo for the store before removing it. + ConvertDebugDeclareToDebugValue(Info.DbgDeclare, Info.OnlyStore, 0); // Remove the (now dead) store and alloca. Info.OnlyStore->eraseFromParent(); LBI.deleteValue(Info.OnlyStore); @@ -372,6 +400,8 @@ void PromoteMem2Reg::run() { // Remove the (now dead) stores and alloca. while (!AI->use_empty()) { StoreInst *SI = cast(AI->use_back()); + // Record debuginfo for the store before removing it. + ConvertDebugDeclareToDebugValue(Info.DbgDeclare, SI, 0); SI->eraseFromParent(); LBI.deleteValue(SI); } @@ -400,6 +430,9 @@ void PromoteMem2Reg::run() { // stored into the alloca. if (AST) PointerAllocaValues[AllocaNum] = Info.AllocaPointerVal; + + // Remember the dbg.declare intrinsic describing this alloca, if any. + if (Info.DbgDeclare) AllocaDbgDeclares[AllocaNum] = Info.DbgDeclare; // Keep the reverse mapping of the 'Allocas' array for the rename pass. AllocaLookup[Allocas[AllocaNum]] = AllocaNum; @@ -833,6 +866,22 @@ void PromoteMem2Reg::PromoteSingleBlockAlloca(AllocaInst *AI, AllocaInfo &Info, } } +// Inserts a llvm.dbg.value instrinsic before the stores to an alloca'd value +// that has an associated llvm.dbg.decl intrinsic. +void PromoteMem2Reg::ConvertDebugDeclareToDebugValue(DbgDeclareInst *DDI, + StoreInst *SI, + uint64_t Offset) { + if (!DDI) + return; + + DIVariable DIVar(DDI->getVariable()); + if (!DIVar.getNode()) + return; + + if (!DIF) + DIF = new DIFactory(*SI->getParent()->getParent()->getParent()); + DIF->InsertDbgValueIntrinsic(SI->getOperand(0), Offset, DIVar, SI); +} // QueuePhiNode - queues a phi-node to be added to a basic-block for a specific // Alloca returns true if there wasn't already a phi-node for that variable @@ -946,6 +995,8 @@ NextIteration: // what value were we writing? IncomingVals[ai->second] = SI->getOperand(0); + // Record debuginfo for the store before removing it. + ConvertDebugDeclareToDebugValue(AllocaDbgDeclares[ai->second], SI, 0); BB->getInstList().erase(SI); } } diff --git a/test/Transforms/Mem2Reg/ConvertDebugInfo.ll b/test/Transforms/Mem2Reg/ConvertDebugInfo.ll new file mode 100644 index 00000000000..8e309c0901e --- /dev/null +++ b/test/Transforms/Mem2Reg/ConvertDebugInfo.ll @@ -0,0 +1,31 @@ +; RUN: opt < %s -mem2reg -S | FileCheck %s + +target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" + +define double @testfunc(i32 %i, double %j) { + %I = alloca i32 ; [#uses=4] + call void @llvm.dbg.declare(metadata !{i32* %I}, metadata !0) + %J = alloca double ; [#uses=2] + call void @llvm.dbg.declare(metadata !{double* %J}, metadata !1) +; CHECK: call void @llvm.dbg.value(metadata !{i32 %i}, i64 0, metadata !0) + store i32 %i, i32* %I +; CHECK: call void @llvm.dbg.value(metadata !{double %j}, i64 0, metadata !1) + store double %j, double* %J + %t1 = load i32* %I ; [#uses=1] + %t2 = add i32 %t1, 1 ; [#uses=1] + store i32 %t2, i32* %I + %t3 = load i32* %I ; [#uses=1] + %t4 = sitofp i32 %t3 to double ; [#uses=1] + %t5 = load double* %J ; [#uses=1] + %t6 = fmul double %t4, %t5 ; [#uses=1] + ret double %t6 +} + +declare void @llvm.dbg.declare(metadata, metadata) nounwind readnone + +!bar = !{!0} +!foo = !{!2} + +!0 = metadata !{i32 459008, metadata !1, metadata !"foo", metadata !2, i32 5, metadata !"foo"} ; [ DW_TAG_auto_variable ] +!1 = metadata !{i32 459008, metadata !1, metadata !"foo", metadata !0, i32 5, metadata !1} ; [ DW_TAG_auto_variable ] +!2 = metadata !{i32 458804, i32 0, metadata !2, metadata !"foo", metadata !"bar", metadata !"bar", metadata !2, i32 3, metadata !0, i1 false, i1 true} ; [ DW_TAG_variable ]