From: Justin Bogner Date: Sun, 27 Sep 2015 22:38:50 +0000 (+0000) Subject: AsmWriter: Print the argument names in declarations while debugging X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=0adaaa390db908941cf4c7d9c42d8c0109b3e00e;p=oota-llvm.git AsmWriter: Print the argument names in declarations while debugging When llvm declarations have argument names, it's helpful to actually print those names when debugging. Arguably, it'd be nice to print them all the time, but that would mean the IR we output wouldn't round trip through bitcode, which doesn't store the names. Make the varous print() methods in AsmWriter optionally print "for debug" and set that flag in the dump() methods. The only thing this does differently for now is print the argument names in declarations. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@248692 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/IR/Comdat.h b/include/llvm/IR/Comdat.h index 4d4c15fb68c..fb79e13af3a 100644 --- a/include/llvm/IR/Comdat.h +++ b/include/llvm/IR/Comdat.h @@ -42,7 +42,7 @@ public: SelectionKind getSelectionKind() const { return SK; } void setSelectionKind(SelectionKind Val) { SK = Val; } StringRef getName() const; - void print(raw_ostream &OS) const; + void print(raw_ostream &OS, bool IsForDebug = false) const; void dump() const; private: diff --git a/include/llvm/IR/Metadata.h b/include/llvm/IR/Metadata.h index e398043a29a..2f0713c4730 100644 --- a/include/llvm/IR/Metadata.h +++ b/include/llvm/IR/Metadata.h @@ -126,9 +126,10 @@ public: /// If \c M is provided, metadata nodes will be numbered canonically; /// otherwise, pointer addresses are substituted. /// @{ - void print(raw_ostream &OS, const Module *M = nullptr) const; - void print(raw_ostream &OS, ModuleSlotTracker &MST, - const Module *M = nullptr) const; + void print(raw_ostream &OS, const Module *M = nullptr, + bool IsForDebug = false) const; + void print(raw_ostream &OS, ModuleSlotTracker &MST, const Module *M = nullptr, + bool IsForDebug = false) const; /// @} /// \brief Print as operand. @@ -1194,7 +1195,7 @@ public: void addOperand(MDNode *M); void setOperand(unsigned I, MDNode *New); StringRef getName() const; - void print(raw_ostream &ROS) const; + void print(raw_ostream &ROS, bool IsForDebug = false) const; void dump() const; // --------------------------------------------------------------------------- diff --git a/include/llvm/IR/Module.h b/include/llvm/IR/Module.h index 271095155f6..8bb9c21bd35 100644 --- a/include/llvm/IR/Module.h +++ b/include/llvm/IR/Module.h @@ -656,7 +656,8 @@ public: /// uselistorder directives so that use-lists can be recreated when reading /// the assembly. void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW, - bool ShouldPreserveUseListOrder = false) const; + bool ShouldPreserveUseListOrder = false, + bool IsForDebug = false) const; /// Dump the module to stderr (for debugging). void dump() const; diff --git a/include/llvm/IR/Type.h b/include/llvm/IR/Type.h index 97dcd884431..4378709c0c6 100644 --- a/include/llvm/IR/Type.h +++ b/include/llvm/IR/Type.h @@ -109,7 +109,7 @@ protected: Type * const *ContainedTys; public: - void print(raw_ostream &O) const; + void print(raw_ostream &O, bool IsForDebug = false) const; void dump() const; /// getContext - Return the LLVMContext in which this type was uniqued. diff --git a/include/llvm/IR/Value.h b/include/llvm/IR/Value.h index 7c9cf0fae32..9a87a717886 100644 --- a/include/llvm/IR/Value.h +++ b/include/llvm/IR/Value.h @@ -202,8 +202,9 @@ public: /// \brief Implement operator<< on Value. /// @{ - void print(raw_ostream &O) const; - void print(raw_ostream &O, ModuleSlotTracker &MST) const; + void print(raw_ostream &O, bool IsForDebug = false) const; + void print(raw_ostream &O, ModuleSlotTracker &MST, + bool IsForDebug = false) const; /// @} /// \brief Print the name of this Value out to the specified raw_ostream. diff --git a/lib/IR/AsmWriter.cpp b/lib/IR/AsmWriter.cpp index 3387657129c..7731d332a65 100644 --- a/lib/IR/AsmWriter.cpp +++ b/lib/IR/AsmWriter.cpp @@ -2005,6 +2005,7 @@ class AssemblyWriter { TypePrinting TypePrinter; AssemblyAnnotationWriter *AnnotationWriter; SetVector Comdats; + bool IsForDebug; bool ShouldPreserveUseListOrder; UseListOrderStack UseListOrders; SmallVector MDNames; @@ -2012,7 +2013,7 @@ class AssemblyWriter { public: /// Construct an AssemblyWriter with an external SlotTracker AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M, - AssemblyAnnotationWriter *AAW, + AssemblyAnnotationWriter *AAW, bool IsForDebug, bool ShouldPreserveUseListOrder = false); void printMDNodeBody(const MDNode *MD); @@ -2063,8 +2064,9 @@ private: AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M, AssemblyAnnotationWriter *AAW, - bool ShouldPreserveUseListOrder) + bool IsForDebug, bool ShouldPreserveUseListOrder) : Out(o), TheModule(M), Machine(Mac), AnnotationWriter(AAW), + IsForDebug(IsForDebug), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) { if (!TheModule) return; @@ -2565,7 +2567,7 @@ void AssemblyWriter::printFunction(const Function *F) { Machine.incorporateFunction(F); // Loop over the arguments, printing them... - if (F->isDeclaration()) { + if (F->isDeclaration() && !IsForDebug) { // We're only interested in the type here - don't print argument names. for (unsigned I = 0, E = FT->getNumParams(); I != E; ++I) { // Insert commas as we go... the first arg doesn't get a comma @@ -3234,21 +3236,22 @@ void AssemblyWriter::printUseLists(const Function *F) { //===----------------------------------------------------------------------===// void Module::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW, - bool ShouldPreserveUseListOrder) const { + bool ShouldPreserveUseListOrder, bool IsForDebug) const { SlotTracker SlotTable(this); formatted_raw_ostream OS(ROS); - AssemblyWriter W(OS, SlotTable, this, AAW, ShouldPreserveUseListOrder); + AssemblyWriter W(OS, SlotTable, this, AAW, IsForDebug, + ShouldPreserveUseListOrder); W.printModule(this); } -void NamedMDNode::print(raw_ostream &ROS) const { +void NamedMDNode::print(raw_ostream &ROS, bool IsForDebug) const { SlotTracker SlotTable(getParent()); formatted_raw_ostream OS(ROS); - AssemblyWriter W(OS, SlotTable, getParent(), nullptr); + AssemblyWriter W(OS, SlotTable, getParent(), nullptr, IsForDebug); W.printNamedMDNode(this); } -void Comdat::print(raw_ostream &ROS) const { +void Comdat::print(raw_ostream &ROS, bool /*IsForDebug*/) const { PrintLLVMName(ROS, getName(), ComdatPrefix); ROS << " = comdat "; @@ -3273,7 +3276,7 @@ void Comdat::print(raw_ostream &ROS) const { ROS << '\n'; } -void Type::print(raw_ostream &OS) const { +void Type::print(raw_ostream &OS, bool /*IsForDebug*/) const { TypePrinting TP; TP.print(const_cast(this), OS); @@ -3296,7 +3299,7 @@ static bool isReferencingMDNode(const Instruction &I) { return false; } -void Value::print(raw_ostream &ROS) const { +void Value::print(raw_ostream &ROS, bool IsForDebug) const { bool ShouldInitializeAllMetadata = false; if (auto *I = dyn_cast(this)) ShouldInitializeAllMetadata = isReferencingMDNode(*I); @@ -3304,10 +3307,11 @@ void Value::print(raw_ostream &ROS) const { ShouldInitializeAllMetadata = true; ModuleSlotTracker MST(getModuleFromVal(this), ShouldInitializeAllMetadata); - print(ROS, MST); + print(ROS, MST, IsForDebug); } -void Value::print(raw_ostream &ROS, ModuleSlotTracker &MST) const { +void Value::print(raw_ostream &ROS, ModuleSlotTracker &MST, + bool IsForDebug) const { formatted_raw_ostream OS(ROS); SlotTracker EmptySlotTable(static_cast(nullptr)); SlotTracker &SlotTable = @@ -3319,14 +3323,14 @@ void Value::print(raw_ostream &ROS, ModuleSlotTracker &MST) const { if (const Instruction *I = dyn_cast(this)) { incorporateFunction(I->getParent() ? I->getParent()->getParent() : nullptr); - AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr); + AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr, IsForDebug); W.printInstruction(*I); } else if (const BasicBlock *BB = dyn_cast(this)) { incorporateFunction(BB->getParent()); - AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr); + AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr, IsForDebug); W.printBasicBlock(BB); } else if (const GlobalValue *GV = dyn_cast(this)) { - AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr); + AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr, IsForDebug); if (const GlobalVariable *V = dyn_cast(GV)) W.printGlobal(V); else if (const Function *F = dyn_cast(GV)) @@ -3428,41 +3432,45 @@ void Metadata::printAsOperand(raw_ostream &OS, ModuleSlotTracker &MST, printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true); } -void Metadata::print(raw_ostream &OS, const Module *M) const { +void Metadata::print(raw_ostream &OS, const Module *M, + bool /*IsForDebug*/) const { ModuleSlotTracker MST(M, isa(this)); printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false); } void Metadata::print(raw_ostream &OS, ModuleSlotTracker &MST, - const Module *M) const { + const Module *M, bool /*IsForDebug*/) const { printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false); } // Value::dump - allow easy printing of Values from the debugger. LLVM_DUMP_METHOD -void Value::dump() const { print(dbgs()); dbgs() << '\n'; } +void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; } // Type::dump - allow easy printing of Types from the debugger. LLVM_DUMP_METHOD -void Type::dump() const { print(dbgs()); dbgs() << '\n'; } +void Type::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; } // Module::dump() - Allow printing of Modules from the debugger. LLVM_DUMP_METHOD -void Module::dump() const { print(dbgs(), nullptr); } +void Module::dump() const { + print(dbgs(), nullptr, + /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true); +} // \brief Allow printing of Comdats from the debugger. LLVM_DUMP_METHOD -void Comdat::dump() const { print(dbgs()); } +void Comdat::dump() const { print(dbgs(), /*IsForDebug=*/true); } // NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger. LLVM_DUMP_METHOD -void NamedMDNode::dump() const { print(dbgs()); } +void NamedMDNode::dump() const { print(dbgs(), /*IsForDebug=*/true); } LLVM_DUMP_METHOD void Metadata::dump() const { dump(nullptr); } LLVM_DUMP_METHOD void Metadata::dump(const Module *M) const { - print(dbgs(), M); + print(dbgs(), M, /*IsForDebug=*/true); dbgs() << '\n'; }