mirror of
https://github.com/RPCS3/llvm.git
synced 2024-11-30 15:10:30 +00:00
Cleanup dump() functions.
We had various variants of defining dump() functions in LLVM. Normalize them (this should just consistently implement the things discussed in http://lists.llvm.org/pipermail/cfe-dev/2014-January/034323.html For reference: - Public headers should just declare the dump() method but not use LLVM_DUMP_METHOD or #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) - The definition of a dump method should look like this: #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) LLVM_DUMP_METHOD void MyClass::dump() { // print stuff to dbgs()... } #endif git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@293359 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
92cf58ee36
commit
88d207542b
@ -229,7 +229,7 @@ public:
|
||||
void print(raw_ostream &os, ModuleSlotTracker &MST,
|
||||
const TargetRegisterInfo *TRI = nullptr,
|
||||
const TargetIntrinsicInfo *IntrinsicInfo = nullptr) const;
|
||||
LLVM_DUMP_METHOD void dump() const;
|
||||
void dump() const;
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Accessors that tell you what kind of MachineOperand you're looking at.
|
||||
|
@ -146,7 +146,7 @@ public:
|
||||
void addPressureChange(unsigned RegUnit, bool IsDec,
|
||||
const MachineRegisterInfo *MRI);
|
||||
|
||||
LLVM_DUMP_METHOD void dump(const TargetRegisterInfo &TRI) const;
|
||||
void dump(const TargetRegisterInfo &TRI) const;
|
||||
};
|
||||
|
||||
/// List of registers defined and used by a machine instruction.
|
||||
|
@ -445,6 +445,9 @@ void AnnotateIgnoreWritesEnd(const char *file, int line);
|
||||
|
||||
/// \brief Mark debug helper function definitions like dump() that should not be
|
||||
/// stripped from debug builds.
|
||||
/// Note that you should also surround dump() functions with
|
||||
/// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always
|
||||
/// get stripped in release builds.
|
||||
// FIXME: Move this to a private config.h as it's not usable in public headers.
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
|
||||
|
@ -248,6 +248,7 @@ public:
|
||||
bool readGCNO(GCOVBuffer &Buffer);
|
||||
bool readGCDA(GCOVBuffer &Buffer);
|
||||
uint32_t getChecksum() const { return Checksum; }
|
||||
void print(raw_ostream &OS) const;
|
||||
void dump() const;
|
||||
void collectLineCounts(FileInfo &FI);
|
||||
|
||||
@ -290,6 +291,7 @@ public:
|
||||
return make_range(block_begin(), block_end());
|
||||
}
|
||||
|
||||
void print(raw_ostream &OS) const;
|
||||
void dump() const;
|
||||
void collectLineCounts(FileInfo &FI);
|
||||
|
||||
@ -361,6 +363,7 @@ public:
|
||||
return make_range(dst_begin(), dst_end());
|
||||
}
|
||||
|
||||
void print(raw_ostream &OS) const;
|
||||
void dump() const;
|
||||
void collectLineCounts(FileInfo &FI);
|
||||
|
||||
|
@ -1462,6 +1462,7 @@ public:
|
||||
ResolveFirst = b;
|
||||
}
|
||||
|
||||
void print(raw_ostream &OS) const;
|
||||
void dump() const;
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
@ -28,7 +28,9 @@ ScaledNumber<uint64_t> BlockMass::toScaled() const {
|
||||
return ScaledNumber<uint64_t>(getMass() + 1, -64);
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void BlockMass::dump() const { print(dbgs()); }
|
||||
#endif
|
||||
|
||||
static char getHexDigit(int N) {
|
||||
assert(N < 16);
|
||||
|
@ -125,8 +125,9 @@ void CallGraph::print(raw_ostream &OS) const {
|
||||
CN->print(OS);
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void CallGraph::dump() const { print(dbgs()); }
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void CallGraph::dump() const { print(dbgs()); }
|
||||
#endif
|
||||
|
||||
// removeFunctionFromModule - Unlink the function from this module, returning
|
||||
// it. Because this removes the function from the module, the call graph node
|
||||
@ -194,8 +195,9 @@ void CallGraphNode::print(raw_ostream &OS) const {
|
||||
OS << '\n';
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void CallGraphNode::dump() const { print(dbgs()); }
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void CallGraphNode::dump() const { print(dbgs()); }
|
||||
#endif
|
||||
|
||||
/// removeCallEdgeFor - This method removes the edge in the node for the
|
||||
/// specified call site. Note that this method takes linear time, so it
|
||||
@ -307,8 +309,10 @@ void CallGraphWrapperPass::print(raw_ostream &OS, const Module *) const {
|
||||
G->print(OS);
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD
|
||||
void CallGraphWrapperPass::dump() const { print(dbgs(), nullptr); }
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
struct CallGraphPrinterLegacyPass : public ModulePass {
|
||||
|
@ -385,9 +385,9 @@ void DependenceInfo::Constraint::setAny(ScalarEvolution *NewSE) {
|
||||
Kind = Any;
|
||||
}
|
||||
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
// For debugging purposes. Dumps the constraint out to OS.
|
||||
void DependenceInfo::Constraint::dump(raw_ostream &OS) const {
|
||||
LLVM_DUMP_METHOD void DependenceInfo::Constraint::dump(raw_ostream &OS) const {
|
||||
if (isEmpty())
|
||||
OS << " Empty\n";
|
||||
else if (isAny())
|
||||
@ -403,6 +403,7 @@ void DependenceInfo::Constraint::dump(raw_ostream &OS) const {
|
||||
else
|
||||
llvm_unreachable("unknown constraint type in Constraint::dump");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
// Updates X with the intersection
|
||||
|
@ -108,9 +108,11 @@ void LazyCallGraph::Node::removeEdgeInternal(Function &Target) {
|
||||
EdgeIndexMap.erase(IndexMapI);
|
||||
}
|
||||
|
||||
void LazyCallGraph::Node::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LazyCallGraph::Node::dump() const {
|
||||
dbgs() << *this << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
LazyCallGraph::LazyCallGraph(Module &M) : NextDFSNumber(0) {
|
||||
DEBUG(dbgs() << "Building CG for module: " << M.getModuleIdentifier()
|
||||
@ -167,9 +169,11 @@ LazyCallGraph &LazyCallGraph::operator=(LazyCallGraph &&G) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
void LazyCallGraph::SCC::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LazyCallGraph::SCC::dump() const {
|
||||
dbgs() << *this << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef NDEBUG
|
||||
void LazyCallGraph::SCC::verify() {
|
||||
@ -243,9 +247,11 @@ bool LazyCallGraph::SCC::isAncestorOf(const SCC &TargetC) const {
|
||||
|
||||
LazyCallGraph::RefSCC::RefSCC(LazyCallGraph &G) : G(&G) {}
|
||||
|
||||
void LazyCallGraph::RefSCC::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LazyCallGraph::RefSCC::dump() const {
|
||||
dbgs() << *this << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef NDEBUG
|
||||
void LazyCallGraph::RefSCC::verify() {
|
||||
|
@ -149,11 +149,12 @@ static cl::opt<unsigned> MaxConstantEvolvingDepth(
|
||||
// Implementation of the SCEV class.
|
||||
//
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void SCEV::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void SCEV::dump() const {
|
||||
print(dbgs());
|
||||
dbgs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
void SCEV::print(raw_ostream &OS) const {
|
||||
switch (static_cast<SCEVTypes>(getSCEVType())) {
|
||||
|
@ -432,12 +432,14 @@ unsigned ValueEnumerator::getValueID(const Value *V) const {
|
||||
return I->second-1;
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void ValueEnumerator::dump() const {
|
||||
print(dbgs(), ValueMap, "Default");
|
||||
dbgs() << '\n';
|
||||
print(dbgs(), MetadataMap, "MetaData");
|
||||
dbgs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
void ValueEnumerator::print(raw_ostream &OS, const ValueMapType &Map,
|
||||
const char *Name) const {
|
||||
@ -452,7 +454,8 @@ void ValueEnumerator::print(raw_ostream &OS, const ValueMapType &Map,
|
||||
OS << "Value: " << V->getName();
|
||||
else
|
||||
OS << "Value: [null]\n";
|
||||
V->dump();
|
||||
V->print(errs());
|
||||
errs() << '\n';
|
||||
|
||||
OS << " Uses(" << std::distance(V->use_begin(),V->use_end()) << "):";
|
||||
for (const Use &U : V->uses()) {
|
||||
|
@ -112,8 +112,11 @@ void DIEAbbrev::print(raw_ostream &O) {
|
||||
}
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void DIEAbbrev::dump() { print(dbgs()); }
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void DIEAbbrev::dump() {
|
||||
print(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// DIEAbbrevSet Implementation
|
||||
@ -249,10 +252,11 @@ void DIE::print(raw_ostream &O, unsigned IndentCount) const {
|
||||
O << "\n";
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void DIE::dump() {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void DIE::dump() {
|
||||
print(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
||||
unsigned DIE::computeOffsetsAndAbbrevs(const AsmPrinter *AP,
|
||||
DIEAbbrevSet &AbbrevSet,
|
||||
@ -340,10 +344,11 @@ void DIEValue::print(raw_ostream &O) const {
|
||||
}
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void DIEValue::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void DIEValue::dump() const {
|
||||
print(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// DIEInteger Implementation
|
||||
|
@ -126,14 +126,16 @@ void BranchRelaxation::verify() {
|
||||
#endif
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
/// print block size and offset information - debugging
|
||||
void BranchRelaxation::dumpBBs() {
|
||||
LLVM_DUMP_METHOD void BranchRelaxation::dumpBBs() {
|
||||
for (auto &MBB : *MF) {
|
||||
const BasicBlockInfo &BBI = BlockInfo[MBB.getNumber()];
|
||||
dbgs() << format("BB#%u\toffset=%08x\t", MBB.getNumber(), BBI.Offset)
|
||||
<< format("size=%#x\n", BBI.Size);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/// scanFunction - Do the initial scan of the function, building up
|
||||
/// information about each block.
|
||||
|
@ -968,10 +968,12 @@ bool RegBankSelect::MappingCost::operator==(const MappingCost &Cost) const {
|
||||
LocalFreq == Cost.LocalFreq;
|
||||
}
|
||||
|
||||
void RegBankSelect::MappingCost::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void RegBankSelect::MappingCost::dump() const {
|
||||
print(dbgs());
|
||||
dbgs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
void RegBankSelect::MappingCost::print(raw_ostream &OS) const {
|
||||
if (*this == ImpossibleCost()) {
|
||||
|
@ -76,9 +76,11 @@ bool RegisterBank::operator==(const RegisterBank &OtherRB) const {
|
||||
return &OtherRB == this;
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void RegisterBank::dump(const TargetRegisterInfo *TRI) const {
|
||||
print(dbgs(), /* IsForDebug */ true, TRI);
|
||||
}
|
||||
#endif
|
||||
|
||||
void RegisterBank::print(raw_ostream &OS, bool IsForDebug,
|
||||
const TargetRegisterInfo *TRI) const {
|
||||
|
@ -402,10 +402,12 @@ unsigned RegisterBankInfo::getSizeInBits(unsigned Reg,
|
||||
//------------------------------------------------------------------------------
|
||||
// Helper classes implementation.
|
||||
//------------------------------------------------------------------------------
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void RegisterBankInfo::PartialMapping::dump() const {
|
||||
print(dbgs());
|
||||
dbgs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
bool RegisterBankInfo::PartialMapping::verify() const {
|
||||
assert(RegBank && "Register bank not set");
|
||||
@ -453,10 +455,12 @@ bool RegisterBankInfo::ValueMapping::verify(unsigned MeaningfulBitWidth) const {
|
||||
return true;
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void RegisterBankInfo::ValueMapping::dump() const {
|
||||
print(dbgs());
|
||||
dbgs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
void RegisterBankInfo::ValueMapping::print(raw_ostream &OS) const {
|
||||
OS << "#BreakDown: " << NumBreakDowns << " ";
|
||||
@ -505,10 +509,12 @@ bool RegisterBankInfo::InstructionMapping::verify(
|
||||
return true;
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void RegisterBankInfo::InstructionMapping::dump() const {
|
||||
print(dbgs());
|
||||
dbgs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
void RegisterBankInfo::InstructionMapping::print(raw_ostream &OS) const {
|
||||
OS << "ID: " << getID() << " Cost: " << getCost() << " Mapping: ";
|
||||
@ -621,10 +627,12 @@ RegisterBankInfo::OperandsMapper::getVRegs(unsigned OpIdx,
|
||||
return Res;
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void RegisterBankInfo::OperandsMapper::dump() const {
|
||||
print(dbgs(), true);
|
||||
dbgs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
void RegisterBankInfo::OperandsMapper::print(raw_ostream &OS,
|
||||
bool ForDebug) const {
|
||||
|
@ -299,9 +299,8 @@ bool LexicalScopes::dominates(const DILocation *DL, MachineBasicBlock *MBB) {
|
||||
return Result;
|
||||
}
|
||||
|
||||
/// dump - Print data structures.
|
||||
void LexicalScope::dump(unsigned Indent) const {
|
||||
#ifndef NDEBUG
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LexicalScope::dump(unsigned Indent) const {
|
||||
raw_ostream &err = dbgs();
|
||||
err.indent(Indent);
|
||||
err << "DFSIn: " << DFSIn << " DFSOut: " << DFSOut << "\n";
|
||||
@ -316,5 +315,5 @@ void LexicalScope::dump(unsigned Indent) const {
|
||||
for (unsigned i = 0, e = Children.size(); i != e; ++i)
|
||||
if (Children[i] != this)
|
||||
Children[i]->dump(Indent + 2);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
@ -1005,7 +1005,7 @@ bool LiveDebugVariables::doInitialization(Module &M) {
|
||||
return Pass::doInitialization(M);
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LiveDebugVariables::dump() {
|
||||
if (pImpl)
|
||||
static_cast<LDVImpl*>(pImpl)->print(dbgs());
|
||||
|
@ -1032,6 +1032,7 @@ void LiveInterval::verify(const MachineRegisterInfo *MRI) const {
|
||||
// When they exist, Spills.back().start <= LastStart,
|
||||
// and WriteI[-1].start <= LastStart.
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
void LiveRangeUpdater::print(raw_ostream &OS) const {
|
||||
if (!isDirty()) {
|
||||
if (LR)
|
||||
@ -1058,6 +1059,7 @@ void LiveRangeUpdater::print(raw_ostream &OS) const {
|
||||
LLVM_DUMP_METHOD void LiveRangeUpdater::dump() const {
|
||||
print(errs());
|
||||
}
|
||||
#endif
|
||||
|
||||
// Determine if A and B should be coalesced.
|
||||
static inline bool coalescable(const LiveRange::Segment &A,
|
||||
|
@ -162,7 +162,7 @@ void LiveIntervals::printInstrs(raw_ostream &OS) const {
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
void LiveIntervals::dumpInstrs() const {
|
||||
LLVM_DUMP_METHOD void LiveIntervals::dumpInstrs() const {
|
||||
printInstrs(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
@ -120,12 +120,11 @@ void LivePhysRegs::print(raw_ostream &OS) const {
|
||||
OS << "\n";
|
||||
}
|
||||
|
||||
/// Dumps the currently live registers to the debug output.
|
||||
LLVM_DUMP_METHOD void LivePhysRegs::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LivePhysRegs::dump() const {
|
||||
dbgs() << " " << *this;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
bool LivePhysRegs::available(const MachineRegisterInfo &MRI,
|
||||
unsigned Reg) const {
|
||||
|
@ -64,8 +64,8 @@ LiveVariables::VarInfo::findKill(const MachineBasicBlock *MBB) const {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD void LiveVariables::VarInfo::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LiveVariables::VarInfo::dump() const {
|
||||
dbgs() << " Alive in blocks: ";
|
||||
for (SparseBitVector<>::iterator I = AliveBlocks.begin(),
|
||||
E = AliveBlocks.end(); I != E; ++I)
|
||||
@ -78,8 +78,8 @@ LLVM_DUMP_METHOD void LiveVariables::VarInfo::dump() const {
|
||||
dbgs() << "\n #" << i << ": " << *Kills[i];
|
||||
dbgs() << "\n";
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
/// getVarInfo - Get (possibly creating) a VarInfo object for the given vreg.
|
||||
LiveVariables::VarInfo &LiveVariables::getVarInfo(unsigned RegIdx) {
|
||||
|
@ -956,7 +956,7 @@ void MachineFrameInfo::print(const MachineFunction &MF, raw_ostream &OS) const{
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
void MachineFrameInfo::dump(const MachineFunction &MF) const {
|
||||
LLVM_DUMP_METHOD void MachineFrameInfo::dump(const MachineFunction &MF) const {
|
||||
print(MF, dbgs());
|
||||
}
|
||||
#endif
|
||||
|
@ -1692,12 +1692,12 @@ void MachineInstr::copyImplicitOps(MachineFunction &MF,
|
||||
}
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD void MachineInstr::dump(const TargetInstrInfo *TII) const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void MachineInstr::dump(const TargetInstrInfo *TII) const {
|
||||
dbgs() << " ";
|
||||
print(dbgs(), false /* SkipOpers */, TII);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
void MachineInstr::print(raw_ostream &OS, bool SkipOpers,
|
||||
const TargetInstrInfo *TII) const {
|
||||
|
@ -552,7 +552,9 @@ public:
|
||||
os << "\n";
|
||||
}
|
||||
|
||||
void dump() const { print(dbgs()); }
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
|
||||
#endif
|
||||
};
|
||||
|
||||
/// This class repesents the scheduled code. The main data structure is a
|
||||
@ -3980,5 +3982,7 @@ void SMSchedule::print(raw_ostream &os) const {
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
/// Utility function used for debugging to print the schedule.
|
||||
void SMSchedule::dump() const { print(dbgs()); }
|
||||
LLVM_DUMP_METHOD void SMSchedule::dump() const { print(dbgs()); }
|
||||
#endif
|
||||
|
@ -444,8 +444,8 @@ LaneBitmask MachineRegisterInfo::getMaxLaneMaskForVReg(unsigned Reg) const {
|
||||
return TRC.getLaneMask();
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
void MachineRegisterInfo::dumpUses(unsigned Reg) const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void MachineRegisterInfo::dumpUses(unsigned Reg) const {
|
||||
for (MachineInstr &I : use_instructions(Reg))
|
||||
I.dump();
|
||||
}
|
||||
|
@ -504,13 +504,14 @@ void MachineSchedulerBase::print(raw_ostream &O, const Module* m) const {
|
||||
// unimplemented
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void ReadyQueue::dump() {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void ReadyQueue::dump() {
|
||||
dbgs() << "Queue " << Name << ": ";
|
||||
for (unsigned i = 0, e = Queue.size(); i < e; ++i)
|
||||
dbgs() << Queue[i]->NodeNum << " ";
|
||||
dbgs() << "\n";
|
||||
}
|
||||
#endif
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// ScheduleDAGMI - Basic machine instruction scheduling. This is
|
||||
@ -841,7 +842,7 @@ void ScheduleDAGMI::placeDebugValues() {
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
void ScheduleDAGMI::dumpSchedule() const {
|
||||
LLVM_DUMP_METHOD void ScheduleDAGMI::dumpSchedule() const {
|
||||
for (MachineBasicBlock::iterator MI = begin(), ME = end(); MI != ME; ++MI) {
|
||||
if (SUnit *SU = getSUnit(&(*MI)))
|
||||
SU->dump(this);
|
||||
@ -2323,10 +2324,10 @@ SUnit *SchedBoundary::pickOnlyChoice() {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
// This is useful information to dump after bumpNode.
|
||||
// Note that the Queue contents are more useful before pickNodeFromQueue.
|
||||
void SchedBoundary::dumpScheduledState() {
|
||||
LLVM_DUMP_METHOD void SchedBoundary::dumpScheduledState() {
|
||||
unsigned ResFactor;
|
||||
unsigned ResCount;
|
||||
if (ZoneCritResIdx) {
|
||||
@ -2666,11 +2667,14 @@ void GenericScheduler::initPolicy(MachineBasicBlock::iterator Begin,
|
||||
}
|
||||
|
||||
void GenericScheduler::dumpPolicy() {
|
||||
// Cannot completely remove virtual function even in release mode.
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
dbgs() << "GenericScheduler RegionPolicy: "
|
||||
<< " ShouldTrackPressure=" << RegionPolicy.ShouldTrackPressure
|
||||
<< " OnlyTopDown=" << RegionPolicy.OnlyTopDown
|
||||
<< " OnlyBottomUp=" << RegionPolicy.OnlyBottomUp
|
||||
<< "\n";
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Set IsAcyclicLatencyLimited if the acyclic path is longer than the cyclic
|
||||
|
@ -253,7 +253,7 @@ void SchedulePostRATDList::exitRegion() {
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
/// dumpSchedule - dump the scheduled Sequence.
|
||||
void SchedulePostRATDList::dumpSchedule() const {
|
||||
LLVM_DUMP_METHOD void SchedulePostRATDList::dumpSchedule() const {
|
||||
for (unsigned i = 0, e = Sequence.size(); i != e; i++) {
|
||||
if (SUnit *SU = Sequence[i])
|
||||
SU->dump(this);
|
||||
|
@ -840,7 +840,8 @@ static Printable PrintNodeInfo(PBQP::RegAlloc::PBQPRAGraph::NodeId NId,
|
||||
});
|
||||
}
|
||||
|
||||
void PBQP::RegAlloc::PBQPRAGraph::dump(raw_ostream &OS) const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void PBQP::RegAlloc::PBQPRAGraph::dump(raw_ostream &OS) const {
|
||||
for (auto NId : nodeIds()) {
|
||||
const Vector &Costs = getNodeCosts(NId);
|
||||
assert(Costs.getLength() != 0 && "Empty vector in graph.");
|
||||
@ -861,7 +862,10 @@ void PBQP::RegAlloc::PBQPRAGraph::dump(raw_ostream &OS) const {
|
||||
}
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD void PBQP::RegAlloc::PBQPRAGraph::dump() const { dump(dbgs()); }
|
||||
LLVM_DUMP_METHOD void PBQP::RegAlloc::PBQPRAGraph::dump() const {
|
||||
dump(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
||||
void PBQP::RegAlloc::PBQPRAGraph::printDot(raw_ostream &OS) const {
|
||||
OS << "graph {\n";
|
||||
|
@ -52,6 +52,7 @@ static void decreaseSetPressure(std::vector<unsigned> &CurrSetPressure,
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD
|
||||
void llvm::dumpRegSetPressure(ArrayRef<unsigned> SetPressure,
|
||||
const TargetRegisterInfo *TRI) {
|
||||
@ -97,6 +98,7 @@ void RegPressureTracker::dump() const {
|
||||
P.dump(TRI);
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void PressureDiff::dump(const TargetRegisterInfo &TRI) const {
|
||||
const char *sep = "";
|
||||
for (const PressureChange &Change : *this) {
|
||||
@ -108,6 +110,7 @@ void PressureDiff::dump(const TargetRegisterInfo &TRI) const {
|
||||
}
|
||||
dbgs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
void RegPressureTracker::increaseRegPressure(unsigned RegUnit,
|
||||
LaneBitmask PreviousMask,
|
||||
|
@ -236,6 +236,7 @@ void StackColoring::calculateLiveIntervals() {
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void StackColoring::dumpAllocas() {
|
||||
dbgs() << "Allocas:\n";
|
||||
for (unsigned AllocaNo = 0; AllocaNo < NumAllocas; ++AllocaNo)
|
||||
@ -262,6 +263,7 @@ LLVM_DUMP_METHOD void StackColoring::dumpLiveRanges() {
|
||||
dbgs() << " " << AllocaNo << ": " << Range << "\n";
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void StackColoring::run() {
|
||||
DEBUG(dumpAllocas());
|
||||
|
@ -310,6 +310,7 @@ void SUnit::biasCriticalPath() {
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD
|
||||
void SUnit::print(raw_ostream &OS, const ScheduleDAG *DAG) const {
|
||||
if (this == &DAG->ExitSU)
|
||||
OS << "ExitSU";
|
||||
@ -321,13 +322,13 @@ void SUnit::print(raw_ostream &OS, const ScheduleDAG *DAG) const {
|
||||
|
||||
/// SUnit - Scheduling unit. It's an wrapper around either a single SDNode or
|
||||
/// a group of nodes flagged together.
|
||||
void SUnit::dump(const ScheduleDAG *G) const {
|
||||
LLVM_DUMP_METHOD void SUnit::dump(const ScheduleDAG *G) const {
|
||||
print(dbgs(), G);
|
||||
dbgs() << ": ";
|
||||
G->dumpNode(this);
|
||||
}
|
||||
|
||||
void SUnit::dumpAll(const ScheduleDAG *G) const {
|
||||
LLVM_DUMP_METHOD void SUnit::dumpAll(const ScheduleDAG *G) const {
|
||||
dump(G);
|
||||
|
||||
dbgs() << " # preds left : " << NumPredsLeft << "\n";
|
||||
|
@ -1297,6 +1297,7 @@ void ScheduleDAGInstrs::fixupKills(MachineBasicBlock *MBB) {
|
||||
}
|
||||
|
||||
void ScheduleDAGInstrs::dumpNode(const SUnit *SU) const {
|
||||
// Cannot completely remove virtual function even in release mode.
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
SU->getInstr()->dump();
|
||||
#endif
|
||||
@ -1604,8 +1605,8 @@ void SchedDFSResult::scheduleTree(unsigned SubtreeID) {
|
||||
}
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void ILPValue::print(raw_ostream &OS) const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void ILPValue::print(raw_ostream &OS) const {
|
||||
OS << InstrCount << " / " << Length << " = ";
|
||||
if (!Length)
|
||||
OS << "BADILP";
|
||||
@ -1613,8 +1614,7 @@ void ILPValue::print(raw_ostream &OS) const {
|
||||
OS << format("%g", ((double)InstrCount / Length));
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void ILPValue::dump() const {
|
||||
LLVM_DUMP_METHOD void ILPValue::dump() const {
|
||||
dbgs() << *this << '\n';
|
||||
}
|
||||
|
||||
@ -1627,3 +1627,4 @@ raw_ostream &operator<<(raw_ostream &OS, const ILPValue &Val) {
|
||||
}
|
||||
|
||||
} // end namespace llvm
|
||||
#endif
|
||||
|
@ -1787,7 +1787,7 @@ public:
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
void dump(ScheduleDAG *DAG) const override {
|
||||
LLVM_DUMP_METHOD void dump(ScheduleDAG *DAG) const override {
|
||||
// Emulate pop() without clobbering NodeQueueIds.
|
||||
std::vector<SUnit*> DumpQueue = Queue;
|
||||
SF DumpPicker = Picker;
|
||||
@ -1923,8 +1923,8 @@ unsigned RegReductionPQBase::getNodePriority(const SUnit *SU) const {
|
||||
// Register Pressure Tracking
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
void RegReductionPQBase::dumpRegPressure() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void RegReductionPQBase::dumpRegPressure() const {
|
||||
for (const TargetRegisterClass *RC : TRI->regclasses()) {
|
||||
unsigned Id = RC->getID();
|
||||
unsigned RP = RegPressure[Id];
|
||||
@ -1932,8 +1932,8 @@ void RegReductionPQBase::dumpRegPressure() const {
|
||||
DEBUG(dbgs() << TRI->getRegClassName(RC) << ": " << RP << " / "
|
||||
<< RegLimit[Id] << '\n');
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
bool RegReductionPQBase::HighRegPressure(const SUnit *SU) const {
|
||||
if (!TLI)
|
||||
@ -2089,7 +2089,7 @@ void RegReductionPQBase::scheduledNode(SUnit *SU) {
|
||||
RegPressure[RCId] -= Cost;
|
||||
}
|
||||
}
|
||||
dumpRegPressure();
|
||||
DEBUG(dumpRegPressure());
|
||||
}
|
||||
|
||||
void RegReductionPQBase::unscheduledNode(SUnit *SU) {
|
||||
@ -2169,7 +2169,7 @@ void RegReductionPQBase::unscheduledNode(SUnit *SU) {
|
||||
}
|
||||
}
|
||||
|
||||
dumpRegPressure();
|
||||
DEBUG(dumpRegPressure());
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
@ -650,6 +650,7 @@ void ScheduleDAGSDNodes::computeOperandLatency(SDNode *Def, SDNode *Use,
|
||||
}
|
||||
|
||||
void ScheduleDAGSDNodes::dumpNode(const SUnit *SU) const {
|
||||
// Cannot completely remove virtual function even in release mode.
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
if (!SU->getNode()) {
|
||||
dbgs() << "PHYS REG COPY\n";
|
||||
|
@ -366,11 +366,13 @@ static Printable PrintNodeId(const SDNode &Node) {
|
||||
});
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void SDNode::dump() const { dump(nullptr); }
|
||||
void SDNode::dump(const SelectionDAG *G) const {
|
||||
LLVM_DUMP_METHOD void SDNode::dump(const SelectionDAG *G) const {
|
||||
print(dbgs(), G);
|
||||
dbgs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
void SDNode::print_types(raw_ostream &OS, const SelectionDAG *G) const {
|
||||
for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
|
||||
@ -416,7 +418,7 @@ void SDNode::print_details(raw_ostream &OS, const SelectionDAG *G) const {
|
||||
OS << '<' << CSDN->getValueAPF().convertToDouble() << '>';
|
||||
else {
|
||||
OS << "<APFloat(";
|
||||
CSDN->getValueAPF().bitcastToAPInt().dump();
|
||||
CSDN->getValueAPF().bitcastToAPInt().print(OS, false);
|
||||
OS << ")>";
|
||||
}
|
||||
} else if (const GlobalAddressSDNode *GADN =
|
||||
@ -566,6 +568,7 @@ static bool shouldPrintInline(const SDNode &Node) {
|
||||
return Node.getNumOperands() == 0;
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
static void DumpNodes(const SDNode *N, unsigned indent, const SelectionDAG *G) {
|
||||
for (const SDValue &Op : N->op_values()) {
|
||||
if (shouldPrintInline(*Op.getNode()))
|
||||
@ -592,6 +595,7 @@ LLVM_DUMP_METHOD void SelectionDAG::dump() const {
|
||||
if (getRoot().getNode()) DumpNodes(getRoot().getNode(), 2, this);
|
||||
dbgs() << "\n\n";
|
||||
}
|
||||
#endif
|
||||
|
||||
void SDNode::printr(raw_ostream &OS, const SelectionDAG *G) const {
|
||||
OS << PrintNodeId(*this) << ": ";
|
||||
@ -618,6 +622,7 @@ static bool printOperand(raw_ostream &OS, const SelectionDAG *G,
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
typedef SmallPtrSet<const SDNode *, 32> VisitedSDNodeSet;
|
||||
static void DumpNodesr(raw_ostream &OS, const SDNode *N, unsigned indent,
|
||||
const SelectionDAG *G, VisitedSDNodeSet &once) {
|
||||
@ -646,15 +651,16 @@ static void DumpNodesr(raw_ostream &OS, const SDNode *N, unsigned indent,
|
||||
DumpNodesr(OS, Op.getNode(), indent+2, G, once);
|
||||
}
|
||||
|
||||
void SDNode::dumpr() const {
|
||||
LLVM_DUMP_METHOD void SDNode::dumpr() const {
|
||||
VisitedSDNodeSet once;
|
||||
DumpNodesr(dbgs(), this, 0, nullptr, once);
|
||||
}
|
||||
|
||||
void SDNode::dumpr(const SelectionDAG *G) const {
|
||||
LLVM_DUMP_METHOD void SDNode::dumpr(const SelectionDAG *G) const {
|
||||
VisitedSDNodeSet once;
|
||||
DumpNodesr(dbgs(), this, 0, G, once);
|
||||
}
|
||||
#endif
|
||||
|
||||
static void printrWithDepthHelper(raw_ostream &OS, const SDNode *N,
|
||||
const SelectionDAG *G, unsigned depth,
|
||||
@ -688,14 +694,17 @@ void SDNode::printrFull(raw_ostream &OS, const SelectionDAG *G) const {
|
||||
printrWithDepth(OS, G, 10);
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD
|
||||
void SDNode::dumprWithDepth(const SelectionDAG *G, unsigned depth) const {
|
||||
printrWithDepth(dbgs(), G, depth);
|
||||
}
|
||||
|
||||
void SDNode::dumprFull(const SelectionDAG *G) const {
|
||||
LLVM_DUMP_METHOD void SDNode::dumprFull(const SelectionDAG *G) const {
|
||||
// Don't print impossibly deep things.
|
||||
dumprWithDepth(G, 10);
|
||||
}
|
||||
#endif
|
||||
|
||||
void SDNode::print(raw_ostream &OS, const SelectionDAG *G) const {
|
||||
printr(OS, G);
|
||||
|
@ -1535,7 +1535,7 @@ void SelectionDAGISel::SelectAllBasicBlocks(const Function &Fn) {
|
||||
|
||||
if (EnableFastISelVerbose || EnableFastISelAbort) {
|
||||
dbgs() << "FastISel missed call: ";
|
||||
Inst->dump();
|
||||
Inst->print(dbgs());
|
||||
}
|
||||
if (EnableFastISelAbort > 2)
|
||||
// FastISel selector couldn't handle something and bailed.
|
||||
@ -1579,7 +1579,7 @@ void SelectionDAGISel::SelectAllBasicBlocks(const Function &Fn) {
|
||||
} else {
|
||||
dbgs() << "FastISel miss: ";
|
||||
}
|
||||
Inst->dump();
|
||||
Inst->print(dbgs());
|
||||
}
|
||||
if (ShouldAbort)
|
||||
// FastISel selector couldn't handle something and bailed.
|
||||
|
@ -385,14 +385,13 @@ void StackColoring::getAnalysisUsage(AnalysisUsage &AU) const {
|
||||
MachineFunctionPass::getAnalysisUsage(AU);
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void StackColoring::dumpBV(const char *tag,
|
||||
const BitVector &BV) const {
|
||||
DEBUG(dbgs() << tag << " : { ");
|
||||
dbgs() << tag << " : { ";
|
||||
for (unsigned I = 0, E = BV.size(); I != E; ++I)
|
||||
DEBUG(dbgs() << BV.test(I) << " ");
|
||||
DEBUG(dbgs() << "}\n");
|
||||
dbgs() << BV.test(I) << " ";
|
||||
dbgs() << "}\n";
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD void StackColoring::dumpBB(MachineBasicBlock *MBB) const {
|
||||
@ -408,20 +407,19 @@ LLVM_DUMP_METHOD void StackColoring::dumpBB(MachineBasicBlock *MBB) const {
|
||||
|
||||
LLVM_DUMP_METHOD void StackColoring::dump() const {
|
||||
for (MachineBasicBlock *MBB : depth_first(MF)) {
|
||||
DEBUG(dbgs() << "Inspecting block #" << MBB->getNumber() << " ["
|
||||
<< MBB->getName() << "]\n");
|
||||
DEBUG(dumpBB(MBB));
|
||||
dbgs() << "Inspecting block #" << MBB->getNumber() << " ["
|
||||
<< MBB->getName() << "]\n";
|
||||
dumpBB(MBB);
|
||||
}
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD void StackColoring::dumpIntervals() const {
|
||||
for (unsigned I = 0, E = Intervals.size(); I != E; ++I) {
|
||||
DEBUG(dbgs() << "Interval[" << I << "]:\n");
|
||||
DEBUG(Intervals[I]->dump());
|
||||
dbgs() << "Interval[" << I << "]:\n";
|
||||
Intervals[I]->dump();
|
||||
}
|
||||
}
|
||||
|
||||
#endif // not NDEBUG
|
||||
#endif
|
||||
|
||||
static inline int getStartOrEndSlot(const MachineInstr &MI)
|
||||
{
|
||||
|
@ -413,9 +413,9 @@ bool TargetRegisterInfo::regmaskSubsetEqual(const uint32_t *mask0,
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
void
|
||||
TargetRegisterInfo::dumpReg(unsigned Reg, unsigned SubRegIndex,
|
||||
const TargetRegisterInfo *TRI) {
|
||||
LLVM_DUMP_METHOD
|
||||
void TargetRegisterInfo::dumpReg(unsigned Reg, unsigned SubRegIndex,
|
||||
const TargetRegisterInfo *TRI) {
|
||||
dbgs() << PrintReg(Reg, TRI, SubRegIndex) << "\n";
|
||||
}
|
||||
#endif
|
||||
|
@ -46,7 +46,7 @@ bool DWARFAcceleratorTable::extract() {
|
||||
return true;
|
||||
}
|
||||
|
||||
void DWARFAcceleratorTable::dump(raw_ostream &OS) const {
|
||||
LLVM_DUMP_METHOD void DWARFAcceleratorTable::dump(raw_ostream &OS) const {
|
||||
// Dump the header.
|
||||
OS << "Magic = " << format("0x%08x", Hdr.Magic) << '\n'
|
||||
<< "Version = " << format("0x%04x", Hdr.Version) << '\n'
|
||||
|
@ -3535,6 +3535,7 @@ void Metadata::print(raw_ostream &OS, ModuleSlotTracker &MST,
|
||||
printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
// Value::dump - allow easy printing of Values from the debugger.
|
||||
LLVM_DUMP_METHOD
|
||||
void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
|
||||
@ -3566,3 +3567,4 @@ void Metadata::dump(const Module *M) const {
|
||||
print(dbgs(), M, /*IsForDebug=*/true);
|
||||
dbgs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
@ -581,9 +581,11 @@ std::string AttributeSetNode::getAsString(bool InAttrGrp) const {
|
||||
// AttributeSetImpl Definition
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void AttributeSetImpl::dump() const {
|
||||
AttributeSet(const_cast<AttributeSetImpl *>(this)).dump();
|
||||
}
|
||||
#endif
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// AttributeSet Construction and Mutation Methods
|
||||
@ -1115,6 +1117,7 @@ AttributeSet AttributeSet::getSlotAttributes(unsigned Slot) const {
|
||||
return pImpl->getSlotAttributes(Slot);
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void AttributeSet::dump() const {
|
||||
dbgs() << "PAL[\n";
|
||||
|
||||
@ -1130,6 +1133,7 @@ LLVM_DUMP_METHOD void AttributeSet::dump() const {
|
||||
|
||||
dbgs() << "]\n";
|
||||
}
|
||||
#endif
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// AttrBuilder Method Implementations
|
||||
|
@ -996,11 +996,13 @@ void ConstantRange::print(raw_ostream &OS) const {
|
||||
OS << "[" << Lower << "," << Upper << ")";
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
/// dump - Allow printing from a debugger easily...
|
||||
///
|
||||
LLVM_DUMP_METHOD void ConstantRange::dump() const {
|
||||
print(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
||||
ConstantRange llvm::getConstantRangeFromMetadata(const MDNode &Ranges) {
|
||||
const unsigned NumRanges = Ranges.getNumOperands() / 2;
|
||||
|
@ -258,9 +258,11 @@ void LLVMSetTarget(LLVMModuleRef M, const char *Triple) {
|
||||
unwrap(M)->setTargetTriple(Triple);
|
||||
}
|
||||
|
||||
void LLVMDumpModule(LLVMModuleRef M) {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LLVMDumpModule(LLVMModuleRef M) {
|
||||
unwrap(M)->dump();
|
||||
}
|
||||
#endif
|
||||
|
||||
LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename,
|
||||
char **ErrorMessage) {
|
||||
@ -358,9 +360,11 @@ LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty) {
|
||||
return wrap(&unwrap(Ty)->getContext());
|
||||
}
|
||||
|
||||
void LLVMDumpType(LLVMTypeRef Ty) {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LLVMDumpType(LLVMTypeRef Ty) {
|
||||
return unwrap(Ty)->dump();
|
||||
}
|
||||
#endif
|
||||
|
||||
char *LLVMPrintTypeToString(LLVMTypeRef Ty) {
|
||||
std::string buf;
|
||||
@ -640,9 +644,11 @@ void LLVMSetValueName(LLVMValueRef Val, const char *Name) {
|
||||
unwrap(Val)->setName(Name);
|
||||
}
|
||||
|
||||
void LLVMDumpValue(LLVMValueRef Val) {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LLVMDumpValue(LLVMValueRef Val) {
|
||||
unwrap(Val)->dump();
|
||||
}
|
||||
#endif
|
||||
|
||||
char* LLVMPrintValueToString(LLVMValueRef Val) {
|
||||
std::string buf;
|
||||
|
@ -66,8 +66,8 @@ DebugLoc DebugLoc::get(unsigned Line, unsigned Col, const MDNode *Scope,
|
||||
const_cast<MDNode *>(InlinedAt));
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void DebugLoc::dump() const {
|
||||
#ifndef NDEBUG
|
||||
if (!Loc)
|
||||
return;
|
||||
|
||||
@ -79,8 +79,8 @@ LLVM_DUMP_METHOD void DebugLoc::dump() const {
|
||||
InlinedAtDL.dump();
|
||||
} else
|
||||
dbgs() << "\n";
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
void DebugLoc::print(raw_ostream &OS) const {
|
||||
if (!Loc)
|
||||
|
@ -103,11 +103,17 @@ bool GCOVFile::readGCDA(GCOVBuffer &Buffer) {
|
||||
return true;
|
||||
}
|
||||
|
||||
void GCOVFile::print(raw_ostream &OS) const {
|
||||
for (const auto &FPtr : Functions)
|
||||
FPtr->print(OS);
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
/// dump - Dump GCOVFile content to dbgs() for debugging purposes.
|
||||
LLVM_DUMP_METHOD void GCOVFile::dump() const {
|
||||
for (const auto &FPtr : Functions)
|
||||
FPtr->dump();
|
||||
print(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
||||
/// collectLineCounts - Collect line counts. This must be used after
|
||||
/// reading .gcno and .gcda files.
|
||||
@ -343,13 +349,19 @@ uint64_t GCOVFunction::getExitCount() const {
|
||||
return Blocks.back()->getCount();
|
||||
}
|
||||
|
||||
void GCOVFunction::print(raw_ostream &OS) const {
|
||||
OS << "===== " << Name << " (" << Ident << ") @ " << Filename << ":"
|
||||
<< LineNumber << "\n";
|
||||
for (const auto &Block : Blocks)
|
||||
Block->print(OS);
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
/// dump - Dump GCOVFunction content to dbgs() for debugging purposes.
|
||||
LLVM_DUMP_METHOD void GCOVFunction::dump() const {
|
||||
dbgs() << "===== " << Name << " (" << Ident << ") @ " << Filename << ":"
|
||||
<< LineNumber << "\n";
|
||||
for (const auto &Block : Blocks)
|
||||
Block->dump();
|
||||
print(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
||||
/// collectLineCounts - Collect line counts. This must be used after
|
||||
/// reading .gcno and .gcda files.
|
||||
@ -400,29 +412,35 @@ void GCOVBlock::collectLineCounts(FileInfo &FI) {
|
||||
FI.addBlockLine(Parent.getFilename(), N, this);
|
||||
}
|
||||
|
||||
/// dump - Dump GCOVBlock content to dbgs() for debugging purposes.
|
||||
LLVM_DUMP_METHOD void GCOVBlock::dump() const {
|
||||
dbgs() << "Block : " << Number << " Counter : " << Counter << "\n";
|
||||
void GCOVBlock::print(raw_ostream &OS) const {
|
||||
OS << "Block : " << Number << " Counter : " << Counter << "\n";
|
||||
if (!SrcEdges.empty()) {
|
||||
dbgs() << "\tSource Edges : ";
|
||||
OS << "\tSource Edges : ";
|
||||
for (const GCOVEdge *Edge : SrcEdges)
|
||||
dbgs() << Edge->Src.Number << " (" << Edge->Count << "), ";
|
||||
dbgs() << "\n";
|
||||
OS << Edge->Src.Number << " (" << Edge->Count << "), ";
|
||||
OS << "\n";
|
||||
}
|
||||
if (!DstEdges.empty()) {
|
||||
dbgs() << "\tDestination Edges : ";
|
||||
OS << "\tDestination Edges : ";
|
||||
for (const GCOVEdge *Edge : DstEdges)
|
||||
dbgs() << Edge->Dst.Number << " (" << Edge->Count << "), ";
|
||||
dbgs() << "\n";
|
||||
OS << Edge->Dst.Number << " (" << Edge->Count << "), ";
|
||||
OS << "\n";
|
||||
}
|
||||
if (!Lines.empty()) {
|
||||
dbgs() << "\tLines : ";
|
||||
OS << "\tLines : ";
|
||||
for (uint32_t N : Lines)
|
||||
dbgs() << (N) << ",";
|
||||
dbgs() << "\n";
|
||||
OS << (N) << ",";
|
||||
OS << "\n";
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
/// dump - Dump GCOVBlock content to dbgs() for debugging purposes.
|
||||
LLVM_DUMP_METHOD void GCOVBlock::dump() const {
|
||||
print(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// FileInfo implementation.
|
||||
|
||||
|
@ -118,10 +118,12 @@ void Pass::print(raw_ostream &O,const Module*) const {
|
||||
O << "Pass::print not implemented for pass: '" << getPassName() << "'!\n";
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
// dump - call print(cerr);
|
||||
LLVM_DUMP_METHOD void Pass::dump() const {
|
||||
print(dbgs(), nullptr);
|
||||
}
|
||||
#endif
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// ImmutablePass Implementation
|
||||
|
@ -99,13 +99,15 @@ ValueName *ValueSymbolTable::createValueName(StringRef Name, Value *V) {
|
||||
return makeUniqueName(V, UniqueName);
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
// dump - print out the symbol table
|
||||
//
|
||||
LLVM_DUMP_METHOD void ValueSymbolTable::dump() const {
|
||||
//DEBUG(dbgs() << "ValueSymbolTable:\n");
|
||||
//dbgs() << "ValueSymbolTable:\n";
|
||||
for (const auto &I : *this) {
|
||||
//DEBUG(dbgs() << " '" << I->getKeyData() << "' = ");
|
||||
//dbgs() << " '" << I->getKeyData() << "' = ";
|
||||
I.getValue()->dump();
|
||||
//DEBUG(dbgs() << "\n");
|
||||
//dbgs() << "\n";
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
@ -129,10 +129,12 @@ void MCExpr::print(raw_ostream &OS, const MCAsmInfo *MAI, bool InParens) const {
|
||||
llvm_unreachable("Invalid expression kind!");
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void MCExpr::dump() const {
|
||||
dbgs() << *this;
|
||||
dbgs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
/* *** */
|
||||
|
||||
|
@ -309,6 +309,7 @@ raw_ostream &operator<<(raw_ostream &OS, const MCFixup &AF) {
|
||||
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void MCFragment::dump() {
|
||||
raw_ostream &OS = llvm::errs();
|
||||
|
||||
@ -468,3 +469,4 @@ LLVM_DUMP_METHOD void MCAssembler::dump() {
|
||||
}
|
||||
OS << "]>\n";
|
||||
}
|
||||
#endif
|
||||
|
@ -34,10 +34,12 @@ void MCOperand::print(raw_ostream &OS) const {
|
||||
OS << ">";
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void MCOperand::dump() const {
|
||||
print(dbgs());
|
||||
dbgs() << "\n";
|
||||
}
|
||||
#endif
|
||||
|
||||
void MCInst::print(raw_ostream &OS) const {
|
||||
OS << "<MCInst " << getOpcode();
|
||||
@ -63,7 +65,9 @@ void MCInst::dump_pretty(raw_ostream &OS, const MCInstPrinter *Printer,
|
||||
OS << ">";
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void MCInst::dump() const {
|
||||
print(dbgs());
|
||||
dbgs() << "\n";
|
||||
}
|
||||
#endif
|
||||
|
@ -16,6 +16,8 @@ void MCLabel::print(raw_ostream &OS) const {
|
||||
OS << '"' << getInstance() << '"';
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void MCLabel::dump() const {
|
||||
print(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
@ -137,6 +137,9 @@ bool MCAsmParser::parseExpression(const MCExpr *&Res) {
|
||||
return parseExpression(Res, L);
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD void MCParsedAsmOperand::dump() const {
|
||||
void MCParsedAsmOperand::dump() const {
|
||||
// Cannot completely remove virtual function even in release mode.
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
dbgs() << " " << *this;
|
||||
#endif
|
||||
}
|
||||
|
@ -85,6 +85,7 @@ MCSection::getSubsectionInsertionPoint(unsigned Subsection) {
|
||||
return IP;
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void MCSection::dump() {
|
||||
raw_ostream &OS = llvm::errs();
|
||||
|
||||
@ -97,3 +98,4 @@ LLVM_DUMP_METHOD void MCSection::dump() {
|
||||
}
|
||||
OS << "]>";
|
||||
}
|
||||
#endif
|
||||
|
@ -75,4 +75,8 @@ void MCSymbol::print(raw_ostream &OS, const MCAsmInfo *MAI) const {
|
||||
OS << '"';
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD void MCSymbol::dump() const { dbgs() << *this; }
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void MCSymbol::dump() const {
|
||||
dbgs() << *this;
|
||||
}
|
||||
#endif
|
||||
|
@ -37,9 +37,11 @@ void MCValue::print(raw_ostream &OS) const {
|
||||
OS << " + " << getConstant();
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void MCValue::dump() const {
|
||||
print(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
||||
MCSymbolRefExpr::VariantKind MCValue::getAccessVariant() const {
|
||||
const MCSymbolRefExpr *B = getSymB();
|
||||
|
@ -282,11 +282,13 @@ void SubtargetFeatures::print(raw_ostream &OS) const {
|
||||
OS << "\n";
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
/// dump - Dump feature info.
|
||||
///
|
||||
LLVM_DUMP_METHOD void SubtargetFeatures::dump() const {
|
||||
print(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Adds the default features for the specified target triple.
|
||||
///
|
||||
|
@ -61,7 +61,9 @@ void Arg::print(raw_ostream& O) const {
|
||||
O << "]>\n";
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void Arg::dump() const { print(dbgs()); }
|
||||
#endif
|
||||
|
||||
std::string Arg::getAsString(const ArgList &Args) const {
|
||||
SmallString<256> Res;
|
||||
|
@ -353,7 +353,9 @@ void ArgList::print(raw_ostream &O) const {
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void ArgList::dump() const { print(dbgs()); }
|
||||
#endif
|
||||
|
||||
//
|
||||
|
||||
|
@ -83,7 +83,9 @@ void Option::print(raw_ostream &O) const {
|
||||
O << ">\n";
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void Option::dump() const { print(dbgs()); }
|
||||
#endif
|
||||
|
||||
bool Option::matches(OptSpecifier Opt) const {
|
||||
// Aliases are never considered in matching, look through them.
|
||||
|
@ -74,7 +74,9 @@ raw_ostream &llvm::sampleprof::operator<<(raw_ostream &OS,
|
||||
return OS;
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LineLocation::dump() const { print(dbgs()); }
|
||||
#endif
|
||||
|
||||
/// \brief Print the sample record to the stream \p OS indented by \p Indent.
|
||||
void SampleRecord::print(raw_ostream &OS, unsigned Indent) const {
|
||||
@ -87,7 +89,9 @@ void SampleRecord::print(raw_ostream &OS, unsigned Indent) const {
|
||||
OS << "\n";
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void SampleRecord::dump() const { print(dbgs(), 0); }
|
||||
#endif
|
||||
|
||||
raw_ostream &llvm::sampleprof::operator<<(raw_ostream &OS,
|
||||
const SampleRecord &Sample) {
|
||||
@ -136,4 +140,6 @@ raw_ostream &llvm::sampleprof::operator<<(raw_ostream &OS,
|
||||
return OS;
|
||||
}
|
||||
|
||||
void FunctionSamples::dump(void) const { print(dbgs(), 0); }
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void FunctionSamples::dump(void) const { print(dbgs(), 0); }
|
||||
#endif
|
||||
|
@ -4494,7 +4494,9 @@ void APFloat::print(raw_ostream &OS) const {
|
||||
OS << Buffer << "\n";
|
||||
}
|
||||
|
||||
void APFloat::dump() const { print(dbgs()); }
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void APFloat::dump() const { print(dbgs()); }
|
||||
#endif
|
||||
|
||||
void APFloat::Profile(FoldingSetNodeID &NID) const {
|
||||
NID.Add(bitcastToAPInt());
|
||||
|
@ -2241,7 +2241,7 @@ std::string APInt::toString(unsigned Radix = 10, bool Signed = true) const {
|
||||
return S.str();
|
||||
}
|
||||
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void APInt::dump() const {
|
||||
SmallString<40> S, U;
|
||||
this->toStringUnsigned(U);
|
||||
@ -2249,6 +2249,7 @@ LLVM_DUMP_METHOD void APInt::dump() const {
|
||||
dbgs() << "APInt(" << BitWidth << "b, "
|
||||
<< U << "u " << S << "s)";
|
||||
}
|
||||
#endif
|
||||
|
||||
void APInt::print(raw_ostream &OS, bool isSigned) const {
|
||||
SmallString<40> S;
|
||||
|
@ -32,7 +32,9 @@ raw_ostream &BranchProbability::print(raw_ostream &OS) const {
|
||||
Percent);
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void BranchProbability::dump() const { print(dbgs()) << '\n'; }
|
||||
#endif
|
||||
|
||||
BranchProbability::BranchProbability(uint32_t Numerator, uint32_t Denominator) {
|
||||
assert(Denominator > 0 && "Denominator cannot be 0!");
|
||||
|
@ -173,10 +173,12 @@ void Twine::printRepr(raw_ostream &OS) const {
|
||||
OS << ")";
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void Twine::dump() const {
|
||||
print(dbgs());
|
||||
}
|
||||
|
||||
void Twine::dumpRepr() const {
|
||||
LLVM_DUMP_METHOD void Twine::dumpRepr() const {
|
||||
printRepr(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
@ -40,7 +40,9 @@ IntRecTy IntRecTy::Shared;
|
||||
StringRecTy StringRecTy::Shared;
|
||||
DagRecTy DagRecTy::Shared;
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void RecTy::dump() const { print(errs()); }
|
||||
#endif
|
||||
|
||||
ListRecTy *RecTy::getListTy() {
|
||||
if (!ListTy)
|
||||
@ -161,7 +163,9 @@ RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
void Init::anchor() { }
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void Init::dump() const { return print(errs()); }
|
||||
#endif
|
||||
|
||||
UnsetInit *UnsetInit::get() {
|
||||
static UnsetInit TheInit;
|
||||
@ -1591,7 +1595,9 @@ StringRef RecordVal::getName() const {
|
||||
return cast<StringInit>(getNameInit())->getValue();
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void RecordVal::dump() const { errs() << *this; }
|
||||
#endif
|
||||
|
||||
void RecordVal::print(raw_ostream &OS, bool PrintSem) const {
|
||||
if (getPrefix()) OS << "field ";
|
||||
@ -1673,7 +1679,9 @@ void Record::resolveReferencesTo(const RecordVal *RV) {
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void Record::dump() const { errs() << *this; }
|
||||
#endif
|
||||
|
||||
raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) {
|
||||
OS << R.getNameInitAsString();
|
||||
@ -1865,6 +1873,7 @@ DagInit *Record::getValueAsDag(StringRef FieldName) const {
|
||||
FieldName + "' does not have a dag initializer!");
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void MultiClass::dump() const {
|
||||
errs() << "Record:\n";
|
||||
Rec.dump();
|
||||
@ -1875,6 +1884,7 @@ LLVM_DUMP_METHOD void MultiClass::dump() const {
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD void RecordKeeper::dump() const { errs() << *this; }
|
||||
#endif
|
||||
|
||||
raw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) {
|
||||
OS << "------------- Classes -----------------\n";
|
||||
|
@ -945,7 +945,7 @@ Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
|
||||
else if (ListInit *Arg0 = dyn_cast<ListInit>(InitList[0]))
|
||||
Type = Arg0->getType();
|
||||
else {
|
||||
InitList[0]->dump();
|
||||
InitList[0]->print(errs());
|
||||
Error(OpLoc, "expected a list");
|
||||
return nullptr;
|
||||
}
|
||||
|
@ -832,7 +832,7 @@ SDValue AMDGPUTargetLowering::LowerOperation(SDValue Op,
|
||||
SelectionDAG &DAG) const {
|
||||
switch (Op.getOpcode()) {
|
||||
default:
|
||||
Op->dump(&DAG);
|
||||
Op->print(errs(), &DAG);
|
||||
llvm_unreachable("Custom lowering code for this"
|
||||
"instruction is not implemented yet!");
|
||||
break;
|
||||
|
@ -162,7 +162,7 @@ void AMDGPUAsmPrinter::EmitInstruction(const MachineInstr *MI) {
|
||||
if (!STI.getInstrInfo()->verifyInstruction(*MI, Err)) {
|
||||
LLVMContext &C = MI->getParent()->getParent()->getFunction()->getContext();
|
||||
C.emitError("Illegal instruction detected: " + Err);
|
||||
MI->dump();
|
||||
MI->print(errs());
|
||||
}
|
||||
|
||||
if (MI->isBundle()) {
|
||||
|
@ -861,7 +861,7 @@ void AMDGPUPromoteAlloca::handleAlloca(AllocaInst &I) {
|
||||
continue;
|
||||
}
|
||||
default:
|
||||
Intr->dump();
|
||||
Intr->print(errs());
|
||||
llvm_unreachable("Don't know how to promote alloca intrinsic use.");
|
||||
}
|
||||
}
|
||||
|
@ -1255,7 +1255,7 @@ void ARMAsmPrinter::EmitUnwindingInstruction(const MachineInstr *MI) {
|
||||
|
||||
switch (Opc) {
|
||||
default:
|
||||
MI->dump();
|
||||
MI->print(errs());
|
||||
llvm_unreachable("Unsupported opcode for unwinding information");
|
||||
case ARM::tPUSH:
|
||||
// Special case here: no src & dst reg, but two extra imp ops.
|
||||
@ -1291,7 +1291,7 @@ void ARMAsmPrinter::EmitUnwindingInstruction(const MachineInstr *MI) {
|
||||
int64_t Offset = 0;
|
||||
switch (Opc) {
|
||||
default:
|
||||
MI->dump();
|
||||
MI->print(errs());
|
||||
llvm_unreachable("Unsupported opcode for unwinding information");
|
||||
case ARM::MOVr:
|
||||
case ARM::tMOVr:
|
||||
@ -1346,11 +1346,11 @@ void ARMAsmPrinter::EmitUnwindingInstruction(const MachineInstr *MI) {
|
||||
}
|
||||
}
|
||||
} else if (DstReg == ARM::SP) {
|
||||
MI->dump();
|
||||
MI->print(errs());
|
||||
llvm_unreachable("Unsupported opcode for unwinding information");
|
||||
}
|
||||
else {
|
||||
MI->dump();
|
||||
MI->print(errs());
|
||||
llvm_unreachable("Unsupported opcode for unwinding information");
|
||||
}
|
||||
}
|
||||
|
@ -320,8 +320,9 @@ void ARMConstantIslands::verify() {
|
||||
#endif
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
/// print block size and offset information - debugging
|
||||
void ARMConstantIslands::dumpBBs() {
|
||||
LLVM_DUMP_METHOD void ARMConstantIslands::dumpBBs() {
|
||||
DEBUG({
|
||||
for (unsigned J = 0, E = BBInfo.size(); J !=E; ++J) {
|
||||
const BasicBlockInfo &BBI = BBInfo[J];
|
||||
@ -333,6 +334,7 @@ void ARMConstantIslands::dumpBBs() {
|
||||
}
|
||||
});
|
||||
}
|
||||
#endif
|
||||
|
||||
bool ARMConstantIslands::runOnMachineFunction(MachineFunction &mf) {
|
||||
MF = &mf;
|
||||
|
@ -98,9 +98,11 @@ ARMConstantPoolValue::hasSameValue(ARMConstantPoolValue *ACPV) {
|
||||
return false;
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void ARMConstantPoolValue::dump() const {
|
||||
errs() << " " << *this;
|
||||
}
|
||||
#endif
|
||||
|
||||
void ARMConstantPoolValue::print(raw_ostream &O) const {
|
||||
if (Modifier) O << "(" << getModifierText() << ")";
|
||||
|
@ -8729,7 +8729,7 @@ ARMTargetLowering::EmitInstrWithCustomInserter(MachineInstr &MI,
|
||||
bool isThumb2 = Subtarget->isThumb2();
|
||||
switch (MI.getOpcode()) {
|
||||
default: {
|
||||
MI.dump();
|
||||
MI.print(errs());
|
||||
llvm_unreachable("Unexpected instr type to insert");
|
||||
}
|
||||
|
||||
|
@ -138,7 +138,7 @@ void BPFDAGToDAGISel::Select(SDNode *Node) {
|
||||
else
|
||||
errs() << "Error: ";
|
||||
errs() << "Unsupport signed division for DAG: ";
|
||||
Node->dump(CurDAG);
|
||||
Node->print(errs(), CurDAG);
|
||||
errs() << "Please convert to unsigned div/mod.\n";
|
||||
break;
|
||||
}
|
||||
|
@ -54,7 +54,7 @@ void BPFMCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const {
|
||||
MCOperand MCOp;
|
||||
switch (MO.getType()) {
|
||||
default:
|
||||
MI->dump();
|
||||
MI->print(errs());
|
||||
llvm_unreachable("unknown operand type");
|
||||
case MachineOperand::MO_Register:
|
||||
// Ignore all implicit register operands.
|
||||
|
@ -109,7 +109,7 @@ void llvm::HexagonLowerToMC(const MCInstrInfo &MCII, const MachineInstr *MI,
|
||||
|
||||
switch (MO.getType()) {
|
||||
default:
|
||||
MI->dump();
|
||||
MI->print(errs());
|
||||
llvm_unreachable("unknown operand type");
|
||||
case MachineOperand::MO_Register:
|
||||
// Ignore all implicit register operands.
|
||||
|
@ -131,13 +131,15 @@ namespace {
|
||||
INITIALIZE_PASS(HexagonSplitDoubleRegs, "hexagon-split-double",
|
||||
"Hexagon Split Double Registers", false, false)
|
||||
|
||||
void HexagonSplitDoubleRegs::dump_partition(raw_ostream &os,
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void HexagonSplitDoubleRegs::dump_partition(raw_ostream &os,
|
||||
const USet &Part, const TargetRegisterInfo &TRI) {
|
||||
dbgs() << '{';
|
||||
for (auto I : Part)
|
||||
dbgs() << ' ' << PrintReg(I, &TRI);
|
||||
dbgs() << " }";
|
||||
}
|
||||
#endif
|
||||
|
||||
bool HexagonSplitDoubleRegs::isInduction(unsigned Reg, LoopRegMap &IRM) const {
|
||||
for (auto I : IRM) {
|
||||
|
@ -130,7 +130,7 @@ void LanaiMCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const {
|
||||
MCOp = LowerSymbolOperand(MO, GetConstantPoolIndexSymbol(MO));
|
||||
break;
|
||||
default:
|
||||
MI->dump();
|
||||
MI->print(errs());
|
||||
llvm_unreachable("unknown operand type");
|
||||
}
|
||||
|
||||
|
@ -119,7 +119,7 @@ void MSP430MCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const {
|
||||
MCOperand MCOp;
|
||||
switch (MO.getType()) {
|
||||
default:
|
||||
MI->dump();
|
||||
MI->print(errs());
|
||||
llvm_unreachable("unknown operand type");
|
||||
case MachineOperand::MO_Register:
|
||||
// Ignore all implicit register operands.
|
||||
|
@ -417,16 +417,16 @@ bool MipsConstantIslands::isOffsetInRange
|
||||
return isOffsetInRange(UserOffset, TrialOffset,
|
||||
U.getMaxDisp(), U.NegOk);
|
||||
}
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
/// print block size and offset information - debugging
|
||||
void MipsConstantIslands::dumpBBs() {
|
||||
DEBUG({
|
||||
for (unsigned J = 0, E = BBInfo.size(); J !=E; ++J) {
|
||||
const BasicBlockInfo &BBI = BBInfo[J];
|
||||
dbgs() << format("%08x BB#%u\t", BBI.Offset, J)
|
||||
<< format(" size=%#x\n", BBInfo[J].Size);
|
||||
}
|
||||
});
|
||||
LLVM_DUMP_METHOD void MipsConstantIslands::dumpBBs() {
|
||||
for (unsigned J = 0, E = BBInfo.size(); J !=E; ++J) {
|
||||
const BasicBlockInfo &BBI = BBInfo[J];
|
||||
dbgs() << format("%08x BB#%u\t", BBI.Offset, J)
|
||||
<< format(" size=%#x\n", BBInfo[J].Size);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
/// Returns a pass that converts branches to long branches.
|
||||
FunctionPass *llvm::createMipsConstantIslandPass() {
|
||||
return new MipsConstantIslands();
|
||||
|
@ -148,7 +148,7 @@ void llvm::LowerPPCMachineInstrToMCInst(const MachineInstr *MI, MCInst &OutMI,
|
||||
MCOperand MCOp;
|
||||
switch (MO.getType()) {
|
||||
default:
|
||||
MI->dump();
|
||||
MI->print(errs());
|
||||
llvm_unreachable("unknown operand type");
|
||||
case MachineOperand::MO_Register:
|
||||
assert(!MO.getSubReg() && "Subregs should be eliminated!");
|
||||
|
@ -522,7 +522,7 @@ bool PPCVSXSwapRemoval::gatherVectorInstructions() {
|
||||
|
||||
if (RelevantFunction) {
|
||||
DEBUG(dbgs() << "Swap vector when first built\n\n");
|
||||
dumpSwapVector();
|
||||
DEBUG(dumpSwapVector());
|
||||
}
|
||||
|
||||
return RelevantFunction;
|
||||
@ -731,7 +731,7 @@ void PPCVSXSwapRemoval::recordUnoptimizableWebs() {
|
||||
}
|
||||
|
||||
DEBUG(dbgs() << "Swap vector after web analysis:\n\n");
|
||||
dumpSwapVector();
|
||||
DEBUG(dumpSwapVector());
|
||||
}
|
||||
|
||||
// Walk the swap vector entries looking for swaps fed by permuting loads
|
||||
@ -951,77 +951,78 @@ bool PPCVSXSwapRemoval::removeSwaps() {
|
||||
return Changed;
|
||||
}
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
// For debug purposes, dump the contents of the swap vector.
|
||||
void PPCVSXSwapRemoval::dumpSwapVector() {
|
||||
LLVM_DUMP_METHOD void PPCVSXSwapRemoval::dumpSwapVector() {
|
||||
|
||||
for (unsigned EntryIdx = 0; EntryIdx < SwapVector.size(); ++EntryIdx) {
|
||||
|
||||
MachineInstr *MI = SwapVector[EntryIdx].VSEMI;
|
||||
int ID = SwapVector[EntryIdx].VSEId;
|
||||
|
||||
DEBUG(dbgs() << format("%6d", ID));
|
||||
DEBUG(dbgs() << format("%6d", EC->getLeaderValue(ID)));
|
||||
DEBUG(dbgs() << format(" BB#%3d", MI->getParent()->getNumber()));
|
||||
DEBUG(dbgs() << format(" %14s ",
|
||||
TII->getName(MI->getOpcode()).str().c_str()));
|
||||
dbgs() << format("%6d", ID);
|
||||
dbgs() << format("%6d", EC->getLeaderValue(ID));
|
||||
dbgs() << format(" BB#%3d", MI->getParent()->getNumber());
|
||||
dbgs() << format(" %14s ", TII->getName(MI->getOpcode()).str().c_str());
|
||||
|
||||
if (SwapVector[EntryIdx].IsLoad)
|
||||
DEBUG(dbgs() << "load ");
|
||||
dbgs() << "load ";
|
||||
if (SwapVector[EntryIdx].IsStore)
|
||||
DEBUG(dbgs() << "store ");
|
||||
dbgs() << "store ";
|
||||
if (SwapVector[EntryIdx].IsSwap)
|
||||
DEBUG(dbgs() << "swap ");
|
||||
dbgs() << "swap ";
|
||||
if (SwapVector[EntryIdx].MentionsPhysVR)
|
||||
DEBUG(dbgs() << "physreg ");
|
||||
dbgs() << "physreg ";
|
||||
if (SwapVector[EntryIdx].MentionsPartialVR)
|
||||
DEBUG(dbgs() << "partialreg ");
|
||||
dbgs() << "partialreg ";
|
||||
|
||||
if (SwapVector[EntryIdx].IsSwappable) {
|
||||
DEBUG(dbgs() << "swappable ");
|
||||
dbgs() << "swappable ";
|
||||
switch(SwapVector[EntryIdx].SpecialHandling) {
|
||||
default:
|
||||
DEBUG(dbgs() << "special:**unknown**");
|
||||
dbgs() << "special:**unknown**";
|
||||
break;
|
||||
case SH_NONE:
|
||||
break;
|
||||
case SH_EXTRACT:
|
||||
DEBUG(dbgs() << "special:extract ");
|
||||
dbgs() << "special:extract ";
|
||||
break;
|
||||
case SH_INSERT:
|
||||
DEBUG(dbgs() << "special:insert ");
|
||||
dbgs() << "special:insert ";
|
||||
break;
|
||||
case SH_NOSWAP_LD:
|
||||
DEBUG(dbgs() << "special:load ");
|
||||
dbgs() << "special:load ";
|
||||
break;
|
||||
case SH_NOSWAP_ST:
|
||||
DEBUG(dbgs() << "special:store ");
|
||||
dbgs() << "special:store ";
|
||||
break;
|
||||
case SH_SPLAT:
|
||||
DEBUG(dbgs() << "special:splat ");
|
||||
dbgs() << "special:splat ";
|
||||
break;
|
||||
case SH_XXPERMDI:
|
||||
DEBUG(dbgs() << "special:xxpermdi ");
|
||||
dbgs() << "special:xxpermdi ";
|
||||
break;
|
||||
case SH_COPYWIDEN:
|
||||
DEBUG(dbgs() << "special:copywiden ");
|
||||
dbgs() << "special:copywiden ";
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (SwapVector[EntryIdx].WebRejected)
|
||||
DEBUG(dbgs() << "rejected ");
|
||||
dbgs() << "rejected ";
|
||||
if (SwapVector[EntryIdx].WillRemove)
|
||||
DEBUG(dbgs() << "remove ");
|
||||
dbgs() << "remove ";
|
||||
|
||||
DEBUG(dbgs() << "\n");
|
||||
dbgs() << "\n";
|
||||
|
||||
// For no-asserts builds.
|
||||
(void)MI;
|
||||
(void)ID;
|
||||
}
|
||||
|
||||
DEBUG(dbgs() << "\n");
|
||||
dbgs() << "\n";
|
||||
}
|
||||
#endif
|
||||
|
||||
} // end default namespace
|
||||
|
||||
|
@ -357,7 +357,7 @@ X86MCInstLower::LowerMachineOperand(const MachineInstr *MI,
|
||||
const MachineOperand &MO) const {
|
||||
switch (MO.getType()) {
|
||||
default:
|
||||
MI->dump();
|
||||
MI->print(errs());
|
||||
llvm_unreachable("unknown operand type");
|
||||
case MachineOperand::MO_Register:
|
||||
// Ignore all implicit register operands.
|
||||
|
@ -133,6 +133,7 @@ struct SuspendCrossingInfo {
|
||||
};
|
||||
} // end anonymous namespace
|
||||
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void SuspendCrossingInfo::dump(StringRef Label,
|
||||
BitVector const &BV) const {
|
||||
dbgs() << Label << ":";
|
||||
@ -151,6 +152,7 @@ LLVM_DUMP_METHOD void SuspendCrossingInfo::dump() const {
|
||||
}
|
||||
dbgs() << "\n";
|
||||
}
|
||||
#endif
|
||||
|
||||
SuspendCrossingInfo::SuspendCrossingInfo(Function &F, coro::Shape &Shape)
|
||||
: Mapping(F) {
|
||||
|
@ -598,8 +598,8 @@ PreservedAnalyses GVN::run(Function &F, FunctionAnalysisManager &AM) {
|
||||
return PA;
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void GVN::dump(DenseMap<uint32_t, Value*>& d) {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void GVN::dump(DenseMap<uint32_t, Value*>& d) {
|
||||
errs() << "{\n";
|
||||
for (DenseMap<uint32_t, Value*>::iterator I = d.begin(),
|
||||
E = d.end(); I != E; ++I) {
|
||||
@ -608,6 +608,7 @@ void GVN::dump(DenseMap<uint32_t, Value*>& d) {
|
||||
}
|
||||
errs() << "}\n";
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Return true if we can prove that the value
|
||||
/// we're analyzing is fully available in the specified block. As we go, keep
|
||||
|
@ -180,10 +180,11 @@ void RegSortData::print(raw_ostream &OS) const {
|
||||
OS << "[NumUses=" << UsedByIndices.count() << ']';
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void RegSortData::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void RegSortData::dump() const {
|
||||
print(errs()); errs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
|
||||
@ -533,10 +534,11 @@ void Formula::print(raw_ostream &OS) const {
|
||||
}
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void Formula::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void Formula::dump() const {
|
||||
print(errs()); errs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Return true if the given addrec can be sign-extended without changing its
|
||||
/// value.
|
||||
@ -1238,10 +1240,11 @@ void Cost::print(raw_ostream &OS) const {
|
||||
OS << ", plus " << SetupCost << " setup cost";
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void Cost::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void Cost::dump() const {
|
||||
print(errs()); errs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
LSRFixup::LSRFixup()
|
||||
: UserInst(nullptr), OperandValToReplace(nullptr),
|
||||
@ -1284,10 +1287,11 @@ void LSRFixup::print(raw_ostream &OS) const {
|
||||
OS << ", Offset=" << Offset;
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void LSRFixup::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LSRFixup::dump() const {
|
||||
print(errs()); errs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Test whether this use as a formula which has the same registers as the given
|
||||
/// formula.
|
||||
@ -1390,10 +1394,11 @@ void LSRUse::print(raw_ostream &OS) const {
|
||||
OS << ", widest fixup type: " << *WidestFixupType;
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void LSRUse::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LSRUse::dump() const {
|
||||
print(errs()); errs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
static bool isAMCompletelyFolded(const TargetTransformInfo &TTI,
|
||||
LSRUse::KindType Kind, MemAccessTy AccessTy,
|
||||
@ -3696,10 +3701,11 @@ void WorkItem::print(raw_ostream &OS) const {
|
||||
<< " , add offset " << Imm;
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void WorkItem::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void WorkItem::dump() const {
|
||||
print(errs()); errs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Look for registers which are a constant distance apart and try to form reuse
|
||||
/// opportunities between them.
|
||||
@ -4974,10 +4980,11 @@ void LSRInstance::print(raw_ostream &OS) const {
|
||||
print_uses(OS);
|
||||
}
|
||||
|
||||
LLVM_DUMP_METHOD
|
||||
void LSRInstance::dump() const {
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void LSRInstance::dump() const {
|
||||
print(errs()); errs() << '\n';
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
|
||||
|
@ -1888,10 +1888,11 @@ void MemorySSA::print(raw_ostream &OS) const {
|
||||
F.print(OS, &Writer);
|
||||
}
|
||||
|
||||
void MemorySSA::dump() const {
|
||||
MemorySSAAnnotatedWriter Writer(this);
|
||||
F.print(dbgs(), &Writer);
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
LLVM_DUMP_METHOD void MemorySSA::dump() const {
|
||||
print(dbgs());
|
||||
}
|
||||
#endif
|
||||
|
||||
void MemorySSA::verifyMemorySSA() const {
|
||||
verifyDefUses(F);
|
||||
@ -2161,8 +2162,11 @@ void MemoryUse::print(raw_ostream &OS) const {
|
||||
}
|
||||
|
||||
void MemoryAccess::dump() const {
|
||||
// Cannot completely remove virtual function even in release mode.
|
||||
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
||||
print(dbgs());
|
||||
dbgs() << "\n";
|
||||
#endif
|
||||
}
|
||||
|
||||
char MemorySSAPrinterLegacyPass::ID = 0;
|
||||
|
@ -130,7 +130,8 @@ void llvm::appendToCompilerUsed(Module &M, ArrayRef<GlobalValue *> Values) {
|
||||
Function *llvm::checkSanitizerInterfaceFunction(Constant *FuncOrBitcast) {
|
||||
if (isa<Function>(FuncOrBitcast))
|
||||
return cast<Function>(FuncOrBitcast);
|
||||
FuncOrBitcast->dump();
|
||||
FuncOrBitcast->print(errs());
|
||||
errs() << '\n';
|
||||
std::string Err;
|
||||
raw_string_ostream Stream(Err);
|
||||
Stream << "Sanitizer interface function redefined: " << *FuncOrBitcast;
|
||||
|
@ -74,7 +74,7 @@ static void reportCoverage(StringRef SourceFile, StringRef ObjectDir,
|
||||
}
|
||||
|
||||
if (DumpGCOV)
|
||||
GF.dump();
|
||||
GF.print(errs());
|
||||
|
||||
FileInfo FI(Options);
|
||||
GF.collectLineCounts(FI);
|
||||
|
@ -15,6 +15,7 @@
|
||||
#include "llvm/IR/Instructions.h"
|
||||
#include "llvm/IR/Module.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include "llvm/Support/Debug.h"
|
||||
|
||||
using namespace llvm;
|
||||
|
||||
@ -195,17 +196,17 @@ void DiffConsumer::logd(const DiffLogBuilder &Log) {
|
||||
switch (Log.getLineKind(I)) {
|
||||
case DC_match:
|
||||
out << " ";
|
||||
Log.getLeft(I)->dump();
|
||||
Log.getLeft(I)->print(dbgs()); dbgs() << '\n';
|
||||
//printValue(Log.getLeft(I), true);
|
||||
break;
|
||||
case DC_left:
|
||||
out << "< ";
|
||||
Log.getLeft(I)->dump();
|
||||
Log.getLeft(I)->print(dbgs()); dbgs() << '\n';
|
||||
//printValue(Log.getLeft(I), true);
|
||||
break;
|
||||
case DC_right:
|
||||
out << "> ";
|
||||
Log.getRight(I)->dump();
|
||||
Log.getRight(I)->print(dbgs()); dbgs() << '\n';
|
||||
//printValue(Log.getRight(I), false);
|
||||
break;
|
||||
}
|
||||
|
@ -35,7 +35,7 @@ namespace {
|
||||
}
|
||||
|
||||
bool runOnFunction(Function &F) override {
|
||||
getAnalysis<DominatorTreeWrapperPass>().dump();
|
||||
getAnalysis<DominatorTreeWrapperPass>().print(dbgs());
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
@ -96,7 +96,7 @@ void CallingConvEmitter::EmitAction(Record *Action,
|
||||
} else if (Action->isSubClassOf("CCIf")) {
|
||||
O << Action->getValueAsString("Predicate");
|
||||
} else {
|
||||
Action->dump();
|
||||
errs() << *Action;
|
||||
PrintFatalError("Unknown CCPredicateAction!");
|
||||
}
|
||||
|
||||
@ -268,7 +268,7 @@ void CallingConvEmitter::EmitAction(Record *Action,
|
||||
<< "LocVT, LocInfo, ArgFlags, State))\n";
|
||||
O << IndentStr << IndentStr << "return false;\n";
|
||||
} else {
|
||||
Action->dump();
|
||||
errs() << *Action;
|
||||
PrintFatalError("Unknown CCAction!");
|
||||
}
|
||||
}
|
||||
|
@ -1248,7 +1248,7 @@ static unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) {
|
||||
if (Operator->isSubClassOf("ComplexPattern"))
|
||||
return 1;
|
||||
|
||||
Operator->dump();
|
||||
errs() << *Operator;
|
||||
PrintFatalError("Unhandled node in GetNumNodeResults");
|
||||
}
|
||||
|
||||
@ -2114,7 +2114,7 @@ TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){
|
||||
|
||||
DagInit *Dag = dyn_cast<DagInit>(TheInit);
|
||||
if (!Dag) {
|
||||
TheInit->dump();
|
||||
TheInit->print(errs());
|
||||
error("Pattern has unexpected init kind!");
|
||||
}
|
||||
DefInit *OpDef = dyn_cast<DefInit>(Dag->getOperator());
|
||||
|
Loading…
Reference in New Issue
Block a user