From cd26ec5f3c089b3b24f80ff200e94e681eb9e1ee Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Wed, 23 Sep 2009 01:33:16 +0000 Subject: [PATCH] Give MachineMemOperand an operator<<, factoring out code from two different places for printing MachineMemOperands. Drop the virtual from Value::dump and instead give Value a protected virtual hook that can be overridden by subclasses to implement custom printing. This lets printing be more consistent, and simplifies printing of PseudoSourceValue values. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@82599 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/MachineMemOperand.h | 3 + include/llvm/CodeGen/PseudoSourceValue.h | 14 ++--- include/llvm/Value.h | 7 ++- lib/CodeGen/MachineInstr.cpp | 68 ++++++++++++++--------- lib/CodeGen/PseudoSourceValue.cpp | 10 +--- lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 5 +- lib/VMCore/AsmWriter.cpp | 14 ++++- 7 files changed, 74 insertions(+), 47 deletions(-) diff --git a/include/llvm/CodeGen/MachineMemOperand.h b/include/llvm/CodeGen/MachineMemOperand.h index 1b01c4893ef..d52d7a6be89 100644 --- a/include/llvm/CodeGen/MachineMemOperand.h +++ b/include/llvm/CodeGen/MachineMemOperand.h @@ -22,6 +22,7 @@ namespace llvm { class Value; class FoldingSetNodeID; +class raw_ostream; //===----------------------------------------------------------------------===// /// MachineMemOperand - A description of a memory reference used in the backend. @@ -92,6 +93,8 @@ public: void Profile(FoldingSetNodeID &ID) const; }; +raw_ostream &operator<<(raw_ostream &OS, const MachineMemOperand &MRO); + } // End llvm namespace #endif diff --git a/include/llvm/CodeGen/PseudoSourceValue.h b/include/llvm/CodeGen/PseudoSourceValue.h index 3ad2502fe08..49eb5a3dc51 100644 --- a/include/llvm/CodeGen/PseudoSourceValue.h +++ b/include/llvm/CodeGen/PseudoSourceValue.h @@ -25,17 +25,15 @@ namespace llvm { /// stack frame (e.g., a spill slot), below the stack frame (e.g., argument /// space), or constant pool. class PseudoSourceValue : public Value { + private: + /// printCustom - Implement printing for PseudoSourceValue. This is called + /// from Value::print or Value's operator<<. + /// + virtual void printCustom(raw_ostream &O) const; + public: PseudoSourceValue(); - /// dump - Support for debugging, callable in GDB: V->dump() - // - virtual void dump() const; - - /// print - Implement operator<< on PseudoSourceValue. - /// - virtual void print(raw_ostream &OS) const; - /// isConstant - Test whether this PseudoSourceValue has a constant value. /// virtual bool isConstant(const MachineFrameInfo *) const; diff --git a/include/llvm/Value.h b/include/llvm/Value.h index 87c4dc2df30..864d4904c8f 100644 --- a/include/llvm/Value.h +++ b/include/llvm/Value.h @@ -90,13 +90,18 @@ private: void operator=(const Value &); // Do not implement Value(const Value &); // Do not implement +protected: + /// printCustom - Value subclasses can override this to implement custom + /// printing behavior. + virtual void printCustom(raw_ostream &O) const; + public: Value(const Type *Ty, unsigned scid); virtual ~Value(); /// dump - Support for debugging, callable in GDB: V->dump() // - virtual void dump() const; + void dump() const; /// print - Implement operator<< on Value. /// diff --git a/lib/CodeGen/MachineInstr.cpp b/lib/CodeGen/MachineInstr.cpp index 2f5964f1408..baab1203df0 100644 --- a/lib/CodeGen/MachineInstr.cpp +++ b/lib/CodeGen/MachineInstr.cpp @@ -15,6 +15,7 @@ #include "llvm/Constants.h" #include "llvm/InlineAsm.h" #include "llvm/Value.h" +#include "llvm/Assembly/Writer.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineRegisterInfo.h" #include "llvm/CodeGen/PseudoSourceValue.h" @@ -297,6 +298,44 @@ void MachineMemOperand::Profile(FoldingSetNodeID &ID) const { ID.AddInteger(Flags); } +raw_ostream &llvm::operator<<(raw_ostream &OS, const MachineMemOperand &MRO) { + assert((MRO.isLoad() || MRO.isStore()) && + "SV has to be a load, store or both."); + + if (MRO.isVolatile()) + OS << "Volatile "; + + if (MRO.isLoad()) + OS << "LD"; + if (MRO.isStore()) + OS << "ST"; + OS << MRO.getSize(); + + // Print the address information. + OS << "["; + if (!MRO.getValue()) + OS << ""; + else + WriteAsOperand(OS, MRO.getValue(), /*PrintType=*/false); + + // If the alignment of the memory reference itself differs from the alignment + // of the base pointer, print the base alignment explicitly, next to the base + // pointer. + if (MRO.getBaseAlignment() != MRO.getAlignment()) + OS << "(align=" << MRO.getBaseAlignment() << ")"; + + if (MRO.getOffset() != 0) + OS << "+" << MRO.getOffset(); + OS << "]"; + + // Print the alignment of the reference. + if (MRO.getBaseAlignment() != MRO.getAlignment() || + MRO.getBaseAlignment() != MRO.getSize()) + OS << "(align=" << MRO.getAlignment() << ")"; + + return OS; +} + //===----------------------------------------------------------------------===// // MachineInstr Implementation //===----------------------------------------------------------------------===// @@ -967,32 +1006,9 @@ void MachineInstr::print(raw_ostream &OS, const TargetMachine *TM) const { OS << ", Mem:"; for (std::list::const_iterator i = memoperands_begin(), e = memoperands_end(); i != e; ++i) { - const MachineMemOperand &MRO = *i; - const Value *V = MRO.getValue(); - - assert((MRO.isLoad() || MRO.isStore()) && - "SV has to be a load, store or both."); - - if (MRO.isVolatile()) - OS << "Volatile "; - - if (MRO.isLoad()) - OS << "LD"; - if (MRO.isStore()) - OS << "ST"; - - OS << "(" << MRO.getSize() << "," << MRO.getAlignment() << ") ["; - - if (!V) - OS << ""; - else if (!V->getName().empty()) - OS << V->getName(); - else if (const PseudoSourceValue *PSV = dyn_cast(V)) { - PSV->print(OS); - } else - OS << V; - - OS << " + " << MRO.getOffset() << "]"; + OS << *i; + if (next(i) != e) + OS << " "; } } diff --git a/lib/CodeGen/PseudoSourceValue.cpp b/lib/CodeGen/PseudoSourceValue.cpp index c44093606e3..3728b7fe445 100644 --- a/lib/CodeGen/PseudoSourceValue.cpp +++ b/lib/CodeGen/PseudoSourceValue.cpp @@ -47,12 +47,8 @@ PseudoSourceValue::PseudoSourceValue() : Value(PointerType::getUnqual(Type::getInt8Ty(getGlobalContext())), PseudoSourceValueVal) {} -void PseudoSourceValue::dump() const { - print(errs()); errs() << '\n'; -} - -void PseudoSourceValue::print(raw_ostream &OS) const { - OS << PSVNames[this - *PSVs]; +void PseudoSourceValue::printCustom(raw_ostream &O) const { + O << PSVNames[this - *PSVs]; } namespace { @@ -67,7 +63,7 @@ namespace { virtual bool isConstant(const MachineFrameInfo *MFI) const; - virtual void print(raw_ostream &OS) const { + virtual void printCustom(raw_ostream &OS) const { OS << "FixedStack" << FI; } }; diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp index 87ea19be869..e238b6e82d3 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -5580,10 +5580,7 @@ void SDNode::print_details(raw_ostream &OS, const SelectionDAG *G) const { else OS << ""; } else if (const MemOperandSDNode *M = dyn_cast(this)) { - if (M->MO.getValue()) - OS << "<" << M->MO.getValue() << ":" << M->MO.getOffset() << ">"; - else - OS << "MO.getOffset() << ">"; + OS << ": " << M->MO; } else if (const VTSDNode *N = dyn_cast(this)) { OS << ":" << N->getVT().getEVTString(); } diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp index 0d52e1fc7fa..219fe0974d5 100644 --- a/lib/VMCore/AsmWriter.cpp +++ b/lib/VMCore/AsmWriter.cpp @@ -1198,6 +1198,11 @@ static void WriteAsOperandInternal(raw_ostream &Out, const Value *V, return; } + if (V->getValueID() == Value::PseudoSourceValueVal) { + V->print(Out); + return; + } + char Prefix = '%'; int Slot; if (Machine) { @@ -2076,10 +2081,17 @@ void Value::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW) const { } else if (isa(this)) { WriteAsOperand(OS, this, true, 0); } else { - llvm_unreachable("Unknown value to print out!"); + // Otherwise we don't know what it is. Call the virtual function to + // allow a subclass to print itself. + printCustom(OS); } } +// Value::printCustom - subclasses should override this to implement printing. +void Value::printCustom(raw_ostream &OS) const { + llvm_unreachable("Unknown value to print out!"); +} + // Value::dump - allow easy printing of Values from the debugger. void Value::dump() const { print(errs()); errs() << '\n'; }