From 0a7baafe6489b8973a26377f38da7a8fd8ee65b6 Mon Sep 17 00:00:00 2001 From: Dehao Chen Date: Thu, 19 Nov 2015 19:53:05 +0000 Subject: [PATCH] Reimplement discriminator assignment algorithm. Summary: The new algorithm is more efficient (O(n), n is number of basic blocks). And it is guaranteed to cover all cases of multiple BB mapped to same line. Reviewers: dblaikie, davidxl, dnovillo Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D14738 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@253594 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/Utils/AddDiscriminators.cpp | 89 ++++++++------------ test/Transforms/AddDiscriminators/diamond.ll | 72 ++++++++++++++++ test/Transforms/AddDiscriminators/oneline.ll | 8 +- 3 files changed, 113 insertions(+), 56 deletions(-) create mode 100644 test/Transforms/AddDiscriminators/diamond.ll diff --git a/lib/Transforms/Utils/AddDiscriminators.cpp b/lib/Transforms/Utils/AddDiscriminators.cpp index db2bf6a2a9f..ed9ff5a96c4 100644 --- a/lib/Transforms/Utils/AddDiscriminators.cpp +++ b/lib/Transforms/Utils/AddDiscriminators.cpp @@ -52,7 +52,7 @@ // http://wiki.dwarfstd.org/index.php?title=Path_Discriminators //===----------------------------------------------------------------------===// -#include "llvm/Transforms/Scalar.h" +#include "llvm/ADT/DenseMap.h" #include "llvm/IR/BasicBlock.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DIBuilder.h" @@ -65,6 +65,7 @@ #include "llvm/Support/CommandLine.h" #include "llvm/Support/Debug.h" #include "llvm/Support/raw_ostream.h" +#include "llvm/Transforms/Scalar.h" using namespace llvm; @@ -169,60 +170,44 @@ bool AddDiscriminators::runOnFunction(Function &F) { LLVMContext &Ctx = M->getContext(); DIBuilder Builder(*M, /*AllowUnresolved*/ false); - // Traverse all the blocks looking for instructions in different - // blocks that are at the same file:line location. - for (BasicBlock &B : F) { - TerminatorInst *Last = B.getTerminator(); - const DILocation *LastDIL = Last->getDebugLoc(); - if (!LastDIL) - continue; - - for (unsigned I = 0; I < Last->getNumSuccessors(); ++I) { - BasicBlock *Succ = Last->getSuccessor(I); - Instruction *First = Succ->getFirstNonPHIOrDbgOrLifetime(); - const DILocation *FirstDIL = First->getDebugLoc(); - if (!FirstDIL || FirstDIL->getDiscriminator()) - continue; - - // If the first instruction (First) of Succ is at the same file - // location as B's last instruction (Last), add a new - // discriminator for First's location and all the instructions - // in Succ that share the same location with First. - if (!FirstDIL->canDiscriminate(*LastDIL)) { - // Create a new lexical scope and compute a new discriminator - // number for it. - StringRef Filename = FirstDIL->getFilename(); - auto *Scope = FirstDIL->getScope(); - auto *File = Builder.createFile(Filename, Scope->getDirectory()); + typedef std::pair Location; + typedef DenseMap BBScopeMap; + typedef DenseMap LocationBBMap; - // FIXME: Calculate the discriminator here, based on local information, - // and delete DILocation::computeNewDiscriminator(). The current - // solution gives different results depending on other modules in the - // same context. All we really need is to discriminate between - // FirstDIL and LastDIL -- a local map would suffice. - unsigned Discriminator = FirstDIL->computeNewDiscriminator(); - auto *NewScope = - Builder.createLexicalBlockFile(Scope, File, Discriminator); + LocationBBMap LBM; - // Attach this new debug location to First and every - // instruction following First that shares the same location. - for (BasicBlock::iterator I1(*First), E1 = Succ->end(); I1 != E1; - ++I1) { - const DILocation *CurrentDIL = I1->getDebugLoc(); - if (CurrentDIL && CurrentDIL->getLine() == FirstDIL->getLine() && - CurrentDIL->getFilename() == FirstDIL->getFilename()) { - I1->setDebugLoc(DILocation::get(Ctx, CurrentDIL->getLine(), - CurrentDIL->getColumn(), NewScope, - CurrentDIL->getInlinedAt())); - DEBUG(dbgs() << CurrentDIL->getFilename() << ":" - << CurrentDIL->getLine() << ":" - << CurrentDIL->getColumn() << ":" - << CurrentDIL->getDiscriminator() << *I1 << "\n"); - } - } - DEBUG(dbgs() << "\n"); - Changed = true; + // Traverse all instructions in the function. If the source line location + // of the instruction appears in other basic block, assign a new + // discriminator for this instruction. + for (BasicBlock &B : F) { + for (auto &I : B.getInstList()) { + if (isa(&I)) + continue; + const DILocation *DIL = I.getDebugLoc(); + if (!DIL) + continue; + Location L = std::make_pair(DIL->getFilename(), DIL->getLine()); + auto &BBMap = LBM[L]; + auto R = BBMap.insert(std::make_pair(&B, (Metadata *)nullptr)); + if (BBMap.size() == 1) + continue; + bool InsertSuccess = R.second; + Metadata *&NewScope = R.first->second; + // If we could insert a different block in the same location, a + // discriminator is needed to distinguish both instructions. + if (InsertSuccess) { + auto *Scope = DIL->getScope(); + auto *File = + Builder.createFile(DIL->getFilename(), Scope->getDirectory()); + NewScope = Builder.createLexicalBlockFile( + Scope, File, DIL->computeNewDiscriminator()); } + I.setDebugLoc(DILocation::get(Ctx, DIL->getLine(), DIL->getColumn(), + NewScope, DIL->getInlinedAt())); + DEBUG(dbgs() << DIL->getFilename() << ":" << DIL->getLine() << ":" + << DIL->getColumn() << ":" << NewScope->getDiscriminator() + << I << "\n"); + Changed = true; } } diff --git a/test/Transforms/AddDiscriminators/diamond.ll b/test/Transforms/AddDiscriminators/diamond.ll new file mode 100644 index 00000000000..2ca638a83ec --- /dev/null +++ b/test/Transforms/AddDiscriminators/diamond.ll @@ -0,0 +1,72 @@ +; RUN: opt < %s -add-discriminators -S | FileCheck %s + +; Discriminator support for diamond-shaped CFG.: +; #1 void bar(int); +; #2 +; #3 void foo(int i) { +; #4 if (i > 10) +; #5 bar(5); else bar(3); +; #6 } + +; bar(5): discriminator 0 +; bar(3): discriminator 1 + +; Function Attrs: uwtable +define void @_Z3fooi(i32 %i) #0 !dbg !4 { + %1 = alloca i32, align 4 + store i32 %i, i32* %1, align 4 + call void @llvm.dbg.declare(metadata i32* %1, metadata !11, metadata !12), !dbg !13 + %2 = load i32, i32* %1, align 4, !dbg !14 + %3 = icmp sgt i32 %2, 10, !dbg !16 + br i1 %3, label %4, label %5, !dbg !17 + +;