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
SelectionKind getSelectionKind() const { return SK; }
void setSelectionKind(SelectionKind Val) { SK = Val; }
StringRef getName() const;
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:
void dump() const;
private:
/// If \c M is provided, metadata nodes will be numbered canonically;
/// otherwise, pointer addresses are substituted.
/// @{
/// 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.
/// @}
/// \brief Print as operand.
void addOperand(MDNode *M);
void setOperand(unsigned I, MDNode *New);
StringRef getName() const;
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;
// ---------------------------------------------------------------------------
void dump() const;
// ---------------------------------------------------------------------------
/// uselistorder directives so that use-lists can be recreated when reading
/// the assembly.
void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW,
/// 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;
/// Dump the module to stderr (for debugging).
void dump() const;
Type * const *ContainedTys;
public:
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.
void dump() const;
/// getContext - Return the LLVMContext in which this type was uniqued.
/// \brief Implement operator<< on Value.
/// @{
/// \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.
/// @}
/// \brief Print the name of this Value out to the specified raw_ostream.
TypePrinting TypePrinter;
AssemblyAnnotationWriter *AnnotationWriter;
SetVector<const Comdat *> Comdats;
TypePrinting TypePrinter;
AssemblyAnnotationWriter *AnnotationWriter;
SetVector<const Comdat *> Comdats;
bool ShouldPreserveUseListOrder;
UseListOrderStack UseListOrders;
SmallVector<StringRef, 8> MDNames;
bool ShouldPreserveUseListOrder;
UseListOrderStack UseListOrders;
SmallVector<StringRef, 8> MDNames;
public:
/// Construct an AssemblyWriter with an external SlotTracker
AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,
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);
bool ShouldPreserveUseListOrder = false);
void printMDNodeBody(const MDNode *MD);
AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
const Module *M, AssemblyAnnotationWriter *AAW,
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),
: Out(o), TheModule(M), Machine(Mac), AnnotationWriter(AAW),
+ IsForDebug(IsForDebug),
ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
if (!TheModule)
return;
ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
if (!TheModule)
return;
Machine.incorporateFunction(F);
// Loop over the arguments, printing them...
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
// 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
//===----------------------------------------------------------------------===//
void Module::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW,
//===----------------------------------------------------------------------===//
void Module::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW,
- bool ShouldPreserveUseListOrder) const {
+ bool ShouldPreserveUseListOrder, bool IsForDebug) const {
SlotTracker SlotTable(this);
formatted_raw_ostream OS(ROS);
SlotTracker SlotTable(this);
formatted_raw_ostream OS(ROS);
- AssemblyWriter W(OS, SlotTable, this, AAW, ShouldPreserveUseListOrder);
+ AssemblyWriter W(OS, SlotTable, this, AAW, IsForDebug,
+ ShouldPreserveUseListOrder);
-void NamedMDNode::print(raw_ostream &ROS) const {
+void NamedMDNode::print(raw_ostream &ROS, bool IsForDebug) const {
SlotTracker SlotTable(getParent());
formatted_raw_ostream OS(ROS);
SlotTracker SlotTable(getParent());
formatted_raw_ostream OS(ROS);
- AssemblyWriter W(OS, SlotTable, getParent(), nullptr);
+ AssemblyWriter W(OS, SlotTable, getParent(), nullptr, IsForDebug);
W.printNamedMDNode(this);
}
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 ";
PrintLLVMName(ROS, getName(), ComdatPrefix);
ROS << " = comdat ";
-void Type::print(raw_ostream &OS) const {
+void Type::print(raw_ostream &OS, bool /*IsForDebug*/) const {
TypePrinting TP;
TP.print(const_cast<Type*>(this), OS);
TypePrinting TP;
TP.print(const_cast<Type*>(this), OS);
-void Value::print(raw_ostream &ROS) const {
+void Value::print(raw_ostream &ROS, bool IsForDebug) const {
bool ShouldInitializeAllMetadata = false;
if (auto *I = dyn_cast<Instruction>(this))
ShouldInitializeAllMetadata = isReferencingMDNode(*I);
bool ShouldInitializeAllMetadata = false;
if (auto *I = dyn_cast<Instruction>(this))
ShouldInitializeAllMetadata = isReferencingMDNode(*I);
ShouldInitializeAllMetadata = true;
ModuleSlotTracker MST(getModuleFromVal(this), ShouldInitializeAllMetadata);
ShouldInitializeAllMetadata = true;
ModuleSlotTracker MST(getModuleFromVal(this), ShouldInitializeAllMetadata);
+ 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<const Module *>(nullptr));
SlotTracker &SlotTable =
formatted_raw_ostream OS(ROS);
SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
SlotTracker &SlotTable =
if (const Instruction *I = dyn_cast<Instruction>(this)) {
incorporateFunction(I->getParent() ? I->getParent()->getParent() : nullptr);
if (const Instruction *I = dyn_cast<Instruction>(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<BasicBlock>(this)) {
incorporateFunction(BB->getParent());
W.printInstruction(*I);
} else if (const BasicBlock *BB = dyn_cast<BasicBlock>(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<GlobalValue>(this)) {
W.printBasicBlock(BB);
} else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
- AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr);
+ AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr, IsForDebug);
if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
W.printGlobal(V);
else if (const Function *F = dyn_cast<Function>(GV))
if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
W.printGlobal(V);
else if (const Function *F = dyn_cast<Function>(GV))
printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
}
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<MDNode>(this));
printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
}
void Metadata::print(raw_ostream &OS, ModuleSlotTracker &MST,
ModuleSlotTracker MST(M, isa<MDNode>(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
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
// 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
// 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
// \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
// 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 {
LLVM_DUMP_METHOD
void Metadata::dump() const { dump(nullptr); }
LLVM_DUMP_METHOD
void Metadata::dump(const Module *M) const {
+ print(dbgs(), M, /*IsForDebug=*/true);