6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-25 16:31:33 +00:00
Code Issues Projects Releases Wiki Activity

remove a few DOUTs here and there.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79832 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2009-08-23 06:35:02 +00:00
parent 8142ce568d
commit bbbfa99d3d
19 changed files with 195 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/ADT/SCCIterator.h
View File

@ -71,7 +71,7 @@ class scc_iterator
SCCNodeStack.push_back(N);
MinVisitNumStack.push_back(visitNum);
VisitStack.push_back(std::make_pair(N, GT::child_begin(N)));
//DOUT << "TarjanSCC: Node " << N <<
//errs() << "TarjanSCC: Node " << N <<
// " : visitNum = " << visitNum << "\n";
}
@ -106,7 +106,7 @@ class scc_iterator
if (!MinVisitNumStack.empty() && MinVisitNumStack.back() > minVisitNum)
MinVisitNumStack.back() = minVisitNum;
//DOUT << "TarjanSCC: Popped node " << visitingN <<
//errs() << "TarjanSCC: Popped node " << visitingN <<
// " : minVisitNum = " << minVisitNum << "; Node visit num = " <<
// nodeVisitNumbers[visitingN] << "\n";

50
lib/Analysis/IPA/Andersens.cpp
View File

@ -1419,7 +1419,7 @@ void Andersens::ClumpAddressTaken() {
unsigned Pos = NewPos++;
Translate[i] = Pos;
NewGraphNodes.push_back(GraphNodes[i]);
DOUT << "Renumbering node " << i << " to node " << Pos << "\n";
DEBUG(errs() << "Renumbering node " << i << " to node " << Pos << "\n");
}
// I believe this ends up being faster than making two vectors and splicing
@ -1429,7 +1429,7 @@ void Andersens::ClumpAddressTaken() {
unsigned Pos = NewPos++;
Translate[i] = Pos;
NewGraphNodes.push_back(GraphNodes[i]);
DOUT << "Renumbering node " << i << " to node " << Pos << "\n";
DEBUG(errs() << "Renumbering node " << i << " to node " << Pos << "\n");
}
}
@ -1438,7 +1438,7 @@ void Andersens::ClumpAddressTaken() {
unsigned Pos = NewPos++;
Translate[i] = Pos;
NewGraphNodes.push_back(GraphNodes[i]);
DOUT << "Renumbering node " << i << " to node " << Pos << "\n";
DEBUG(errs() << "Renumbering node " << i << " to node " << Pos << "\n");
}
}
@ -1510,7 +1510,7 @@ void Andersens::ClumpAddressTaken() {
/// receive &D from E anyway.
void Andersens::HVN() {
DOUT << "Beginning HVN\n";
DEBUG(errs() << "Beginning HVN\n");
// Build a predecessor graph. This is like our constraint graph with the
// edges going in the opposite direction, and there are edges for all the
// constraints, instead of just copy constraints. We also build implicit
@ -1581,7 +1581,7 @@ void Andersens::HVN() {
Node2DFS.clear();
Node2Deleted.clear();
Node2Visited.clear();
DOUT << "Finished HVN\n";
DEBUG(errs() << "Finished HVN\n");
}
@ -1705,7 +1705,7 @@ void Andersens::HVNValNum(unsigned NodeIndex) {
/// and is equivalent to value numbering the collapsed constraint graph
/// including evaluating unions.
void Andersens::HU() {
DOUT << "Beginning HU\n";
DEBUG(errs() << "Beginning HU\n");
// Build a predecessor graph. This is like our constraint graph with the
// edges going in the opposite direction, and there are edges for all the
// constraints, instead of just copy constraints. We also build implicit
@ -1785,7 +1785,7 @@ void Andersens::HU() {
}
// PEClass nodes will be deleted by the deleting of N->PointsTo in our caller.
Set2PEClass.clear();
DOUT << "Finished HU\n";
DEBUG(errs() << "Finished HU\n");
}
@ -1963,12 +1963,12 @@ void Andersens::RewriteConstraints() {
// to anything.
if (LHSLabel == 0) {
DEBUG(PrintNode(&GraphNodes[LHSNode]));
DOUT << " is a non-pointer, ignoring constraint.\n";
DEBUG(errs() << " is a non-pointer, ignoring constraint.\n");
continue;
}
if (RHSLabel == 0) {
DEBUG(PrintNode(&GraphNodes[RHSNode]));
DOUT << " is a non-pointer, ignoring constraint.\n";
DEBUG(errs() << " is a non-pointer, ignoring constraint.\n");
continue;
}
// This constraint may be useless, and it may become useless as we translate
@ -2016,19 +2016,19 @@ void Andersens::PrintLabels() const {
if (i < FirstRefNode) {
PrintNode(&GraphNodes[i]);
} else if (i < FirstAdrNode) {
DOUT << "REF(";
DEBUG(errs() << "REF(");
PrintNode(&GraphNodes[i-FirstRefNode]);
DOUT <<")";
DEBUG(errs() <<")");
} else {
DOUT << "ADR(";
DEBUG(errs() << "ADR(");
PrintNode(&GraphNodes[i-FirstAdrNode]);
DOUT <<")";
DEBUG(errs() <<")");
}
DOUT << " has pointer label " << GraphNodes[i].PointerEquivLabel
DEBUG(errs() << " has pointer label " << GraphNodes[i].PointerEquivLabel
<< " and SCC rep " << VSSCCRep[i]
<< " and is " << (GraphNodes[i].Direct ? "Direct" : "Not direct")
<< "\n";
<< "\n");
}
}
@ -2042,7 +2042,7 @@ void Andersens::PrintLabels() const {
/// operation are stored in SDT and are later used in SolveContraints()
/// and UniteNodes().
void Andersens::HCD() {
DOUT << "Starting HCD.\n";
DEBUG(errs() << "Starting HCD.\n");
HCDSCCRep.resize(GraphNodes.size());
for (unsigned i = 0; i < GraphNodes.size(); ++i) {
@ -2091,7 +2091,7 @@ void Andersens::HCD() {
Node2Visited.clear();
Node2Deleted.clear();
HCDSCCRep.clear();
DOUT << "HCD complete.\n";
DEBUG(errs() << "HCD complete.\n");
}
// Component of HCD:
@ -2163,7 +2163,7 @@ void Andersens::Search(unsigned Node) {
/// Optimize the constraints by performing offline variable substitution and
/// other optimizations.
void Andersens::OptimizeConstraints() {
DOUT << "Beginning constraint optimization\n";
DEBUG(errs() << "Beginning constraint optimization\n");
SDTActive = false;
@ -2247,7 +2247,7 @@ void Andersens::OptimizeConstraints() {
// HCD complete.
DOUT << "Finished constraint optimization\n";
DEBUG(errs() << "Finished constraint optimization\n");
FirstRefNode = 0;
FirstAdrNode = 0;
}
@ -2255,7 +2255,7 @@ void Andersens::OptimizeConstraints() {
/// Unite pointer but not location equivalent variables, now that the constraint
/// graph is built.
void Andersens::UnitePointerEquivalences() {
DOUT << "Uniting remaining pointer equivalences\n";
DEBUG(errs() << "Uniting remaining pointer equivalences\n");
for (unsigned i = 0; i < GraphNodes.size(); ++i) {
if (GraphNodes[i].AddressTaken && GraphNodes[i].isRep()) {
unsigned Label = GraphNodes[i].PointerEquivLabel;
@ -2264,7 +2264,7 @@ void Andersens::UnitePointerEquivalences() {
UniteNodes(i, PENLEClass2Node[Label]);
}
}
DOUT << "Finished remaining pointer equivalences\n";
DEBUG(errs() << "Finished remaining pointer equivalences\n");
PENLEClass2Node.clear();
}
@ -2420,7 +2420,7 @@ void Andersens::SolveConstraints() {
std::vector<unsigned int> RSV;
#endif
while( !CurrWL->empty() ) {
DOUT << "Starting iteration #" << ++NumIters << "\n";
DEBUG(errs() << "Starting iteration #" << ++NumIters << "\n");
Node* CurrNode;
unsigned CurrNodeIndex;
@ -2723,11 +2723,11 @@ unsigned Andersens::UniteNodes(unsigned First, unsigned Second,
SecondNode->OldPointsTo = NULL;
NumUnified++;
DOUT << "Unified Node ";
DEBUG(errs() << "Unified Node ");
DEBUG(PrintNode(FirstNode));
DOUT << " and Node ";
DEBUG(errs() << " and Node ");
DEBUG(PrintNode(SecondNode));
DOUT << "\n";
DEBUG(errs() << "\n");
if (SDTActive)
if (SDT[Second] >= 0) {

2
lib/Analysis/IVUsers.cpp
View File

@ -257,7 +257,7 @@ bool IVUsers::AddUsersIfInteresting(Instruction *I) {
const SCEV *NewStart = SE->getMinusSCEV(Start, Stride);
StrideUses->addUser(NewStart, User, I);
StrideUses->Users.back().setIsUseOfPostIncrementedValue(true);
DOUT << " USING POSTINC SCEV, START=" << *NewStart<< "\n";
DEBUG(errs() << " USING POSTINC SCEV, START=" << *NewStart<< "\n");
} else {
StrideUses->addUser(Start, User, I);
}

59
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
View File

@ -36,6 +36,7 @@
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <set>
using namespace llvm;
@ -539,10 +540,12 @@ SDValue DAGCombiner::CombineTo(SDNode *N, const SDValue *To, unsigned NumTo,
bool AddTo) {
assert(N->getNumValues() == NumTo && "Broken CombineTo call!");
++NodesCombined;
DOUT << "\nReplacing.1 "; DEBUG(N->dump(&DAG));
DOUT << "\nWith: "; DEBUG(To[0].getNode()->dump(&DAG));
DOUT << " and " << NumTo-1 << " other values\n";
DEBUG(for (unsigned i = 0, e = NumTo; i != e; ++i)
DEBUG(errs() << "\nReplacing.1 ";
N->dump(&DAG);
errs() << "\nWith: ";
To[0].getNode()->dump(&DAG);
errs() << " and " << NumTo-1 << " other values\n";
for (unsigned i = 0, e = NumTo; i != e; ++i)
assert(N->getValueType(i) == To[i].getValueType() &&
"Cannot combine value to value of different type!"));
WorkListRemover DeadNodes(*this);
@ -614,9 +617,11 @@ bool DAGCombiner::SimplifyDemandedBits(SDValue Op, const APInt &Demanded) {
// Replace the old value with the new one.
++NodesCombined;
DOUT << "\nReplacing.2 "; DEBUG(TLO.Old.getNode()->dump(&DAG));
DOUT << "\nWith: "; DEBUG(TLO.New.getNode()->dump(&DAG));
DOUT << '\n';
DEBUG(errs() << "\nReplacing.2 ";
TLO.Old.getNode()->dump(&DAG);
errs() << "\nWith: ";
TLO.New.getNode()->dump(&DAG);
errs() << '\n');
CommitTargetLoweringOpt(TLO);
return true;
@ -682,9 +687,11 @@ void DAGCombiner::Run(CombineLevel AtLevel) {
RV.getNode()->getOpcode() != ISD::DELETED_NODE &&
"Node was deleted but visit returned new node!");
DOUT << "\nReplacing.3 "; DEBUG(N->dump(&DAG));
DOUT << "\nWith: "; DEBUG(RV.getNode()->dump(&DAG));
DOUT << '\n';
DEBUG(errs() << "\nReplacing.3 ";
N->dump(&DAG);
errs() << "\nWith: ";
RV.getNode()->dump(&DAG);
errs() << '\n');
WorkListRemover DeadNodes(*this);
if (N->getNumValues() == RV.getNode()->getNumValues())
DAG.ReplaceAllUsesWith(N, RV.getNode(), &DeadNodes);
@ -4634,9 +4641,11 @@ bool DAGCombiner::CombineToPreIndexedLoadStore(SDNode *N) {
BasePtr, Offset, AM);
++PreIndexedNodes;
++NodesCombined;
DOUT << "\nReplacing.4 "; DEBUG(N->dump(&DAG));
DOUT << "\nWith: "; DEBUG(Result.getNode()->dump(&DAG));
DOUT << '\n';
DEBUG(errs() << "\nReplacing.4 ";
N->dump(&DAG);
errs() << "\nWith: ";
Result.getNode()->dump(&DAG);
errs() << '\n');
WorkListRemover DeadNodes(*this);
if (isLoad) {
DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Result.getValue(0),
@ -4766,9 +4775,11 @@ bool DAGCombiner::CombineToPostIndexedLoadStore(SDNode *N) {
BasePtr, Offset, AM);
++PostIndexedNodes;
++NodesCombined;
DOUT << "\nReplacing.5 "; DEBUG(N->dump(&DAG));
DOUT << "\nWith: "; DEBUG(Result.getNode()->dump(&DAG));
DOUT << '\n';
DEBUG(errs() << "\nReplacing.5 ";
N->dump(&DAG);
errs() << "\nWith: ";
Result.getNode()->dump(&DAG);
errs() << '\n');
WorkListRemover DeadNodes(*this);
if (isLoad) {
DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Result.getValue(0),
@ -4870,9 +4881,11 @@ SDValue DAGCombiner::visitLOAD(SDNode *N) {
// v3 = add v2, c
// Now we replace use of chain2 with chain1. This makes the second load
// isomorphic to the one we are deleting, and thus makes this load live.
DOUT << "\nReplacing.6 "; DEBUG(N->dump(&DAG));
DOUT << "\nWith chain: "; DEBUG(Chain.getNode()->dump(&DAG));
DOUT << "\n";
DEBUG(errs() << "\nReplacing.6 ";
N->dump(&DAG);
errs() << "\nWith chain: ";
Chain.getNode()->dump(&DAG);
errs() << "\n");
WorkListRemover DeadNodes(*this);
DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), Chain, &DeadNodes);
@ -4888,9 +4901,11 @@ SDValue DAGCombiner::visitLOAD(SDNode *N) {
assert(N->getValueType(2) == MVT::Other && "Malformed indexed loads?");
if (N->hasNUsesOfValue(0, 0) && N->hasNUsesOfValue(0, 1)) {
SDValue Undef = DAG.getUNDEF(N->getValueType(0));
DOUT << "\nReplacing.6 "; DEBUG(N->dump(&DAG));
DOUT << "\nWith: "; DEBUG(Undef.getNode()->dump(&DAG));
DOUT << " and 2 other values\n";
DEBUG(errs() << "\nReplacing.6 ";
N->dump(&DAG);
errs() << "\nWith: ";
Undef.getNode()->dump(&DAG);
errs() << " and 2 other values\n");
WorkListRemover DeadNodes(*this);
DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Undef, &DeadNodes);
DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1),

17
lib/CodeGen/SelectionDAG/ScheduleDAGFast.cpp
View File

@ -25,6 +25,7 @@
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
STATISTIC(NumUnfolds, "Number of nodes unfolded");
@ -109,7 +110,7 @@ private:
/// Schedule - Schedule the DAG using list scheduling.
void ScheduleDAGFast::Schedule() {
DOUT << "********** List Scheduling **********\n";
DEBUG(errs() << "********** List Scheduling **********\n");
NumLiveRegs = 0;
LiveRegDefs.resize(TRI->getNumRegs(), NULL);
@ -175,7 +176,7 @@ void ScheduleDAGFast::ReleasePredecessors(SUnit *SU, unsigned CurCycle) {
/// count of its predecessors. If a predecessor pending count is zero, add it to
/// the Available queue.
void ScheduleDAGFast::ScheduleNodeBottomUp(SUnit *SU, unsigned CurCycle) {
DOUT << "*** Scheduling [" << CurCycle << "]: ";
DEBUG(errs() << "*** Scheduling [" << CurCycle << "]: ");
DEBUG(SU->dump(this));
assert(CurCycle >= SU->getHeight() && "Node scheduled below its height!");
@ -233,7 +234,7 @@ SUnit *ScheduleDAGFast::CopyAndMoveSuccessors(SUnit *SU) {
if (!TII->unfoldMemoryOperand(*DAG, N, NewNodes))
return NULL;
DOUT << "Unfolding SU # " << SU->NodeNum << "\n";
DEBUG(errs() << "Unfolding SU # " << SU->NodeNum << "\n");
assert(NewNodes.size() == 2 && "Expected a load folding node!");
N = NewNodes[1];
@ -343,7 +344,7 @@ SUnit *ScheduleDAGFast::CopyAndMoveSuccessors(SUnit *SU) {
SU = NewSU;
}
DOUT << "Duplicating SU # " << SU->NodeNum << "\n";
DEBUG(errs() << "Duplicating SU # " << SU->NodeNum << "\n");
NewSU = Clone(SU);
// New SUnit has the exact same predecessors.
@ -550,16 +551,16 @@ void ScheduleDAGFast::ListScheduleBottomUp() {
// Issue copies, these can be expensive cross register class copies.
SmallVector<SUnit*, 2> Copies;
InsertCopiesAndMoveSuccs(LRDef, Reg, DestRC, RC, Copies);
DOUT << "Adding an edge from SU # " << TrySU->NodeNum
<< " to SU #" << Copies.front()->NodeNum << "\n";
DEBUG(errs() << "Adding an edge from SU # " << TrySU->NodeNum
<< " to SU #" << Copies.front()->NodeNum << "\n");
AddPred(TrySU, SDep(Copies.front(), SDep::Order, /*Latency=*/1,
/*Reg=*/0, /*isNormalMemory=*/false,
/*isMustAlias=*/false, /*isArtificial=*/true));
NewDef = Copies.back();
}
DOUT << "Adding an edge from SU # " << NewDef->NodeNum
<< " to SU #" << TrySU->NodeNum << "\n";
DEBUG(errs() << "Adding an edge from SU # " << NewDef->NodeNum
<< " to SU #" << TrySU->NodeNum << "\n");
LiveRegDefs[Reg] = NewDef;
AddPred(NewDef, SDep(TrySU, SDep::Order, /*Latency=*/1,
/*Reg=*/0, /*isNormalMemory=*/false,

9
lib/CodeGen/SelectionDAG/ScheduleDAGList.cpp
View File

@ -30,6 +30,7 @@
#include "llvm/Support/Debug.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/PriorityQueue.h"
#include "llvm/ADT/Statistic.h"
#include <climits>
@ -87,7 +88,7 @@ private:
/// Schedule - Schedule the DAG using list scheduling.
void ScheduleDAGList::Schedule() {
DOUT << "********** List Scheduling **********\n";
DEBUG(errs() << "********** List Scheduling **********\n");
// Build the scheduling graph.
BuildSchedGraph();
@ -141,7 +142,7 @@ void ScheduleDAGList::ReleaseSuccessors(SUnit *SU) {
/// count of its successors. If a successor pending count is zero, add it to
/// the Available queue.
void ScheduleDAGList::ScheduleNodeTopDown(SUnit *SU, unsigned CurCycle) {
DOUT << "*** Scheduling [" << CurCycle << "]: ";
DEBUG(errs() << "*** Scheduling [" << CurCycle << "]: ");
DEBUG(SU->dump(this));
Sequence.push_back(SU);
@ -233,7 +234,7 @@ void ScheduleDAGList::ListScheduleTopDown() {
} else if (!HasNoopHazards) {
// Otherwise, we have a pipeline stall, but no other problem, just advance
// the current cycle and try again.
DOUT << "*** Advancing cycle, no work to do\n";
DEBUG(errs() << "*** Advancing cycle, no work to do\n");
HazardRec->AdvanceCycle();
++NumStalls;
++CurCycle;
@ -241,7 +242,7 @@ void ScheduleDAGList::ListScheduleTopDown() {
// Otherwise, we have no instructions to issue and we have instructions
// that will fault if we don't do this right. This is the case for
// processors without pipeline interlocks and other cases.
DOUT << "*** Emitting noop\n";
DEBUG(errs() << "*** Emitting noop\n");
HazardRec->EmitNoop();
Sequence.push_back(0); // NULL here means noop
++NumNoops;

31
lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp
View File

@ -30,6 +30,7 @@
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/raw_ostream.h"
#include <climits>
using namespace llvm;
@ -164,7 +165,7 @@ private:
/// Schedule - Schedule the DAG using list scheduling.
void ScheduleDAGRRList::Schedule() {
DOUT << "********** List Scheduling **********\n";
DEBUG(errs() << "********** List Scheduling **********\n");
NumLiveRegs = 0;
LiveRegDefs.resize(TRI->getNumRegs(), NULL);
@ -238,7 +239,7 @@ void ScheduleDAGRRList::ReleasePredecessors(SUnit *SU, unsigned CurCycle) {
/// count of its predecessors. If a predecessor pending count is zero, add it to
/// the Available queue.
void ScheduleDAGRRList::ScheduleNodeBottomUp(SUnit *SU, unsigned CurCycle) {
DOUT << "*** Scheduling [" << CurCycle << "]: ";
DEBUG(errs() << "*** Scheduling [" << CurCycle << "]: ");
DEBUG(SU->dump(this));
assert(CurCycle >= SU->getHeight() && "Node scheduled below its height!");
@ -283,7 +284,7 @@ void ScheduleDAGRRList::CapturePred(SDep *PredEdge) {
/// UnscheduleNodeBottomUp - Remove the node from the schedule, update its and
/// its predecessor states to reflect the change.
void ScheduleDAGRRList::UnscheduleNodeBottomUp(SUnit *SU) {
DOUT << "*** Unscheduling [" << SU->getHeight() << "]: ";
DEBUG(errs() << "*** Unscheduling [" << SU->getHeight() << "]: ");
DEBUG(SU->dump(this));
AvailableQueue->UnscheduledNode(SU);
@ -370,7 +371,7 @@ SUnit *ScheduleDAGRRList::CopyAndMoveSuccessors(SUnit *SU) {
if (!TII->unfoldMemoryOperand(*DAG, N, NewNodes))
return NULL;
DOUT << "Unfolding SU # " << SU->NodeNum << "\n";
DEBUG(errs() << "Unfolding SU # " << SU->NodeNum << "\n");
assert(NewNodes.size() == 2 && "Expected a load folding node!");
N = NewNodes[1];
@ -489,7 +490,7 @@ SUnit *ScheduleDAGRRList::CopyAndMoveSuccessors(SUnit *SU) {
SU = NewSU;
}
DOUT << "Duplicating SU # " << SU->NodeNum << "\n";
DEBUG(errs() << "Duplicating SU # " << SU->NodeNum << "\n");
NewSU = CreateClone(SU);
// New SUnit has the exact same predecessors.
@ -770,8 +771,8 @@ void ScheduleDAGRRList::ListScheduleBottomUp() {
// Issue copies, these can be expensive cross register class copies.
SmallVector<SUnit*, 2> Copies;
InsertCopiesAndMoveSuccs(LRDef, Reg, DestRC, RC, Copies);
DOUT << "Adding an edge from SU #" << TrySU->NodeNum
<< " to SU #" << Copies.front()->NodeNum << "\n";
DEBUG(errs() << "Adding an edge from SU #" << TrySU->NodeNum
<< " to SU #" << Copies.front()->NodeNum << "\n");
AddPred(TrySU, SDep(Copies.front(), SDep::Order, /*Latency=*/1,
/*Reg=*/0, /*isNormalMemory=*/false,
/*isMustAlias=*/false,
@ -779,8 +780,8 @@ void ScheduleDAGRRList::ListScheduleBottomUp() {
NewDef = Copies.back();
}
DOUT << "Adding an edge from SU #" << NewDef->NodeNum
<< " to SU #" << TrySU->NodeNum << "\n";
DEBUG(errs() << "Adding an edge from SU #" << NewDef->NodeNum
<< " to SU #" << TrySU->NodeNum << "\n");
LiveRegDefs[Reg] = NewDef;
AddPred(NewDef, SDep(TrySU, SDep::Order, /*Latency=*/1,
/*Reg=*/0, /*isNormalMemory=*/false,
@ -857,7 +858,7 @@ void ScheduleDAGRRList::ReleaseSuccessors(SUnit *SU) {
/// count of its successors. If a successor pending count is zero, add it to
/// the Available queue.
void ScheduleDAGRRList::ScheduleNodeTopDown(SUnit *SU, unsigned CurCycle) {
DOUT << "*** Scheduling [" << CurCycle << "]: ";
DEBUG(errs() << "*** Scheduling [" << CurCycle << "]: ");
DEBUG(SU->dump(this));
assert(CurCycle >= SU->getDepth() && "Node scheduled above its depth!");
@ -1329,9 +1330,9 @@ void RegReductionPriorityQueue<SF>::PrescheduleNodesWithMultipleUses() {
// Ok, the transformation is safe and the heuristics suggest it is
// profitable. Update the graph.
DOUT << "Prescheduling SU # " << SU->NodeNum
<< " next to PredSU # " << PredSU->NodeNum
<< " to guide scheduling in the presence of multiple uses\n";
DEBUG(errs() << "Prescheduling SU # " << SU->NodeNum
<< " next to PredSU # " << PredSU->NodeNum
<< " to guide scheduling in the presence of multiple uses\n");
for (unsigned i = 0; i != PredSU->Succs.size(); ++i) {
SDep Edge = PredSU->Succs[i];
assert(!Edge.isAssignedRegDep());
@ -1419,8 +1420,8 @@ void RegReductionPriorityQueue<SF>::AddPseudoTwoAddrDeps() {
(hasCopyToRegUse(SU) && !hasCopyToRegUse(SuccSU)) ||
(!SU->isCommutable && SuccSU->isCommutable)) &&
!scheduleDAG->IsReachable(SuccSU, SU)) {
DOUT << "Adding a pseudo-two-addr edge from SU # " << SU->NodeNum
<< " to SU #" << SuccSU->NodeNum << "\n";
DEBUG(errs() << "Adding a pseudo-two-addr edge from SU # "
<< SU->NodeNum << " to SU #" << SuccSU->NodeNum << "\n");
scheduleDAG->AddPred(SU, SDep(SuccSU, SDep::Order, /*Latency=*/0,
/*Reg=*/0, /*isNormalMemory=*/false,
/*isMustAlias=*/false,

29
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
View File

@ -467,7 +467,7 @@ void SelectionDAGISel::CodeGenAndEmitDAG() {
BlockName = MF->getFunction()->getNameStr() + ":" +
BB->getBasicBlock()->getNameStr();
DOUT << "Initial selection DAG:\n";
DEBUG(errs() << "Initial selection DAG:\n");
DEBUG(CurDAG->dump());
if (ViewDAGCombine1) CurDAG->viewGraph("dag-combine1 input for " + BlockName);
@ -480,7 +480,7 @@ void SelectionDAGISel::CodeGenAndEmitDAG() {
CurDAG->Combine(Unrestricted, *AA, OptLevel);
}
DOUT << "Optimized lowered selection DAG:\n";
DEBUG(errs() << "Optimized lowered selection DAG:\n");
DEBUG(CurDAG->dump());
// Second step, hack on the DAG until it only uses operations and types that
@ -497,7 +497,7 @@ void SelectionDAGISel::CodeGenAndEmitDAG() {
Changed = CurDAG->LegalizeTypes();
}
DOUT << "Type-legalized selection DAG:\n";
DEBUG(errs() << "Type-legalized selection DAG:\n");
DEBUG(CurDAG->dump());
if (Changed) {
@ -512,7 +512,7 @@ void SelectionDAGISel::CodeGenAndEmitDAG() {
CurDAG->Combine(NoIllegalTypes, *AA, OptLevel);
}
DOUT << "Optimized type-legalized selection DAG:\n";
DEBUG(errs() << "Optimized type-legalized selection DAG:\n");
DEBUG(CurDAG->dump());
}
@ -542,7 +542,7 @@ void SelectionDAGISel::CodeGenAndEmitDAG() {
CurDAG->Combine(NoIllegalOperations, *AA, OptLevel);
}
DOUT << "Optimized vector-legalized selection DAG:\n";
DEBUG(errs() << "Optimized vector-legalized selection DAG:\n");
DEBUG(CurDAG->dump());
}
}
@ -556,7 +556,7 @@ void SelectionDAGISel::CodeGenAndEmitDAG() {
CurDAG->Legalize(DisableLegalizeTypes, OptLevel);
}
DOUT << "Legalized selection DAG:\n";
DEBUG(errs() << "Legalized selection DAG:\n");
DEBUG(CurDAG->dump());
if (ViewDAGCombine2) CurDAG->viewGraph("dag-combine2 input for " + BlockName);
@ -569,7 +569,7 @@ void SelectionDAGISel::CodeGenAndEmitDAG() {
CurDAG->Combine(NoIllegalOperations, *AA, OptLevel);
}
DOUT << "Optimized legalized selection DAG:\n";
DEBUG(errs() << "Optimized legalized selection DAG:\n");
DEBUG(CurDAG->dump());
if (ViewISelDAGs) CurDAG->viewGraph("isel input for " + BlockName);
@ -586,7 +586,7 @@ void SelectionDAGISel::CodeGenAndEmitDAG() {
InstructionSelect();
}
DOUT << "Selected selection DAG:\n";
DEBUG(errs() << "Selected selection DAG:\n");
DEBUG(CurDAG->dump());
if (ViewSchedDAGs) CurDAG->viewGraph("scheduler input for " + BlockName);
@ -619,7 +619,7 @@ void SelectionDAGISel::CodeGenAndEmitDAG() {
delete Scheduler;
}
DOUT << "Selected machine code:\n";
DEBUG(errs() << "Selected machine code:\n");
DEBUG(BB->dump());
}
@ -799,14 +799,15 @@ void SelectionDAGISel::SelectAllBasicBlocks(Function &Fn,
void
SelectionDAGISel::FinishBasicBlock() {
DOUT << "Target-post-processed machine code:\n";
DEBUG(errs() << "Target-post-processed machine code:\n");
DEBUG(BB->dump());
DOUT << "Total amount of phi nodes to update: "
<< SDL->PHINodesToUpdate.size() << "\n";
DEBUG(errs() << "Total amount of phi nodes to update: "
<< SDL->PHINodesToUpdate.size() << "\n");
DEBUG(for (unsigned i = 0, e = SDL->PHINodesToUpdate.size(); i != e; ++i)
DOUT << "Node " << i << " : (" << SDL->PHINodesToUpdate[i].first
<< ", " << SDL->PHINodesToUpdate[i].second << ")\n";);
errs() << "Node " << i << " : ("
<< SDL->PHINodesToUpdate[i].first
<< ", " << SDL->PHINodesToUpdate[i].second << ")\n");
// Next, now that we know what the last MBB the LLVM BB expanded is, update
// PHI nodes in successors.

2
lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp
View File

@ -216,7 +216,7 @@ bool SelectionDAG::setSubgraphColorHelper(SDNode *N, const char *Color, DenseSet
if (level >= 20) {
if (!printed) {
printed = true;
DOUT << "setSubgraphColor hit max level\n";
DEBUG(errs() << "setSubgraphColor hit max level\n");
}
return true;
}

27
lib/CodeGen/StackSlotColoring.cpp
View File

@ -198,7 +198,7 @@ void StackSlotColoring::InitializeSlots() {
Assignments.resize(LastFI);
// Gather all spill slots into a list.
DOUT << "Spill slot intervals:\n";
DEBUG(errs() << "Spill slot intervals:\n");
for (LiveStacks::iterator i = LS->begin(), e = LS->end(); i != e; ++i) {
LiveInterval &li = i->second;
DEBUG(li.dump());
@ -210,7 +210,7 @@ void StackSlotColoring::InitializeSlots() {
OrigSizes[FI] = MFI->getObjectSize(FI);
AllColors.set(FI);
}
DOUT << '\n';
DEBUG(errs() << '\n');
// Sort them by weight.
std::stable_sort(SSIntervals.begin(), SSIntervals.end(), IntervalSorter());
@ -242,7 +242,7 @@ StackSlotColoring::ColorSlotsWithFreeRegs(SmallVector<int, 16> &SlotMapping,
return false;
bool Changed = false;
DOUT << "Assigning unused registers to spill slots:\n";
DEBUG(errs() << "Assigning unused registers to spill slots:\n");
for (unsigned i = 0, e = SSIntervals.size(); i != e; ++i) {
LiveInterval *li = SSIntervals[i];
int SS = li->getStackSlotIndex();
@ -272,7 +272,8 @@ StackSlotColoring::ColorSlotsWithFreeRegs(SmallVector<int, 16> &SlotMapping,
AllColored = false;
continue;
} else {
DOUT << "Assigning fi#" << RSS << " to " << TRI->getName(Reg) << '\n';
DEBUG(errs() << "Assigning fi#" << RSS << " to "
<< TRI->getName(Reg) << '\n');
ColoredRegs.push_back(Reg);
SlotMapping[RSS] = Reg;
SlotIsReg.set(RSS);
@ -299,7 +300,7 @@ StackSlotColoring::ColorSlotsWithFreeRegs(SmallVector<int, 16> &SlotMapping,
++NumEliminated;
}
}
DOUT << '\n';
DEBUG(errs() << '\n');
return Changed;
}
@ -334,7 +335,7 @@ int StackSlotColoring::ColorSlot(LiveInterval *li) {
// Record the assignment.
Assignments[Color].push_back(li);
int FI = li->getStackSlotIndex();
DOUT << "Assigning fi#" << FI << " to fi#" << Color << "\n";
DEBUG(errs() << "Assigning fi#" << FI << " to fi#" << Color << "\n");
// Change size and alignment of the allocated slot. If there are multiple
// objects sharing the same slot, then make sure the size and alignment
@ -358,7 +359,7 @@ bool StackSlotColoring::ColorSlots(MachineFunction &MF) {
BitVector SlotIsReg(NumObjs);
BitVector UsedColors(NumObjs);
DOUT << "Color spill slot intervals:\n";
DEBUG(errs() << "Color spill slot intervals:\n");
bool Changed = false;
for (unsigned i = 0, e = SSIntervals.size(); i != e; ++i) {
LiveInterval *li = SSIntervals[i];
@ -372,7 +373,7 @@ bool StackSlotColoring::ColorSlots(MachineFunction &MF) {
Changed |= (SS != NewSS);
}
DOUT << "\nSpill slots after coloring:\n";
DEBUG(errs() << "\nSpill slots after coloring:\n");
for (unsigned i = 0, e = SSIntervals.size(); i != e; ++i) {
LiveInterval *li = SSIntervals[i];
int SS = li->getStackSlotIndex();
@ -384,7 +385,7 @@ bool StackSlotColoring::ColorSlots(MachineFunction &MF) {
#ifndef NDEBUG
for (unsigned i = 0, e = SSIntervals.size(); i != e; ++i)
DEBUG(SSIntervals[i]->dump());
DOUT << '\n';
DEBUG(errs() << '\n');
#endif
// Can we "color" a stack slot with a unused register?
@ -416,7 +417,7 @@ bool StackSlotColoring::ColorSlots(MachineFunction &MF) {
// Delete unused stack slots.
while (NextColor != -1) {
DOUT << "Removing unused stack object fi#" << NextColor << "\n";
DEBUG(errs() << "Removing unused stack object fi#" << NextColor << "\n");
MFI->RemoveStackObject(NextColor);
NextColor = AllColors.find_next(NextColor);
}
@ -610,7 +611,7 @@ StackSlotColoring::UnfoldAndRewriteInstruction(MachineInstr *MI, int OldFI,
MachineBasicBlock *MBB = MI->getParent();
if (unsigned DstReg = TII->isLoadFromStackSlot(MI, OldFI)) {
if (PropagateForward(MI, MBB, DstReg, Reg)) {
DOUT << "Eliminated load: ";
DEBUG(errs() << "Eliminated load: ");
DEBUG(MI->dump());
++NumLoadElim;
} else {
@ -626,7 +627,7 @@ StackSlotColoring::UnfoldAndRewriteInstruction(MachineInstr *MI, int OldFI,
}
} else if (unsigned SrcReg = TII->isStoreToStackSlot(MI, OldFI)) {
if (MI->killsRegister(SrcReg) && PropagateBackward(MI, MBB, SrcReg, Reg)) {
DOUT << "Eliminated store: ";
DEBUG(errs() << "Eliminated store: ");
DEBUG(MI->dump());
++NumStoreElim;
} else {
@ -704,7 +705,7 @@ bool StackSlotColoring::RemoveDeadStores(MachineBasicBlock* MBB) {
bool StackSlotColoring::runOnMachineFunction(MachineFunction &MF) {
DOUT << "********** Stack Slot Coloring **********\n";
DEBUG(errs() << "********** Stack Slot Coloring **********\n");
MFI = MF.getFrameInfo();
MRI = &MF.getRegInfo();

20
lib/CodeGen/StrongPHIElimination.cpp
View File

@ -554,8 +554,8 @@ void StrongPHIElimination::processBlock(MachineBasicBlock* MBB) {
// Add the renaming set for this PHI node to our overall renaming information
for (std::map<unsigned, MachineBasicBlock*>::iterator QI = PHIUnion.begin(),
QE = PHIUnion.end(); QI != QE; ++QI) {
DOUT << "Adding Renaming: " << QI->first << " -> "
<< P->getOperand(0).getReg() << "\n";
DEBUG(errs() << "Adding Renaming: " << QI->first << " -> "
<< P->getOperand(0).getReg() << "\n");
}
RenameSets.insert(std::make_pair(P->getOperand(0).getReg(), PHIUnion));
@ -697,7 +697,8 @@ void StrongPHIElimination::ScheduleCopies(MachineBasicBlock* MBB,
TII->copyRegToReg(*PI->getParent(), PI, t,
curr.second, RC, RC);
DOUT << "Inserted copy from " << curr.second << " to " << t << "\n";
DEBUG(errs() << "Inserted copy from " << curr.second << " to " << t
<< "\n");
// Push temporary on Stacks
Stacks[curr.second].push_back(t);
@ -713,8 +714,8 @@ void StrongPHIElimination::ScheduleCopies(MachineBasicBlock* MBB,
TII->copyRegToReg(*MBB, MBB->getFirstTerminator(), curr.second,
map[curr.first], RC, RC);
map[curr.first] = curr.second;
DOUT << "Inserted copy from " << curr.first << " to "
<< curr.second << "\n";
DEBUG(errs() << "Inserted copy from " << curr.first << " to "
<< curr.second << "\n");
// Push this copy onto InsertedPHICopies so we can
// update LiveIntervals with it.
@ -928,7 +929,8 @@ bool StrongPHIElimination::runOnMachineFunction(MachineFunction &Fn) {
unsigned reg = OI->first;
++OI;
I->second.erase(reg);
DOUT << "Removing Renaming: " << reg << " -> " << I->first << "\n";
DEBUG(errs() << "Removing Renaming: " << reg << " -> " << I->first
<< "\n");
}
}
}
@ -945,7 +947,7 @@ bool StrongPHIElimination::runOnMachineFunction(MachineFunction &Fn) {
while (I->second.size()) {
std::map<unsigned, MachineBasicBlock*>::iterator SI = I->second.begin();
DOUT << "Renaming: " << SI->first << " -> " << I->first << "\n";
DEBUG(errs() << "Renaming: " << SI->first << " -> " << I->first << "\n");
if (SI->first != I->first) {
if (mergeLiveIntervals(I->first, SI->first)) {
@ -977,8 +979,8 @@ bool StrongPHIElimination::runOnMachineFunction(MachineFunction &Fn) {
R.valno->setCopy(--SI->second->getFirstTerminator());
R.valno->def = LiveIntervals::getDefIndex(instrIdx);
DOUT << "Renaming failed: " << SI->first << " -> "
<< I->first << "\n";
DEBUG(errs() << "Renaming failed: " << SI->first << " -> "
<< I->first << "\n");
}
}

6
lib/ExecutionEngine/ExecutionEngine.cpp
View File

@ -243,13 +243,13 @@ static void *CreateArgv(LLVMContext &C, ExecutionEngine *EE,
unsigned PtrSize = EE->getTargetData()->getPointerSize();
char *Result = new char[(InputArgv.size()+1)*PtrSize];
DOUT << "JIT: ARGV = " << (void*)Result << "\n";
DEBUG(errs() << "JIT: ARGV = " << (void*)Result << "\n");
const Type *SBytePtr = PointerType::getUnqual(Type::getInt8Ty(C));
for (unsigned i = 0; i != InputArgv.size(); ++i) {
unsigned Size = InputArgv[i].size()+1;
char *Dest = new char[Size];
DOUT << "JIT: ARGV[" << i << "] = " << (void*)Dest << "\n";
DEBUG(errs() << "JIT: ARGV[" << i << "] = " << (void*)Dest << "\n");
std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest);
Dest[Size-1] = 0;
@ -899,7 +899,7 @@ void ExecutionEngine::LoadValueFromMemory(GenericValue &Result,
// specified memory location...
//
void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) {
DOUT << "JIT: Initializing " << Addr << " ";
DEBUG(errs() << "JIT: Initializing " << Addr << " ");
DEBUG(Init->dump());
if (isa<UndefValue>(Init)) {
return;

77
lib/ExecutionEngine/JIT/JITEmitter.cpp
View File

@ -269,8 +269,8 @@ void *JITResolver::getExternalFunctionStub(void *FnAddr) {
Stub = TheJIT->getJITInfo().emitFunctionStub(0, FnAddr,
*TheJIT->getCodeEmitter());
DOUT << "JIT: Stub emitted at [" << Stub
<< "] for external function at '" << FnAddr << "'\n";
DEBUG(errs() << "JIT: Stub emitted at [" << Stub
<< "] for external function at '" << FnAddr << "'\n");
return Stub;
}
@ -279,7 +279,8 @@ unsigned JITResolver::getGOTIndexForAddr(void* addr) {
if (!idx) {
idx = ++nextGOTIndex;
revGOTMap[addr] = idx;
DOUT << "JIT: Adding GOT entry " << idx << " for addr [" << addr << "]\n";
DEBUG(errs() << "JIT: Adding GOT entry " << idx << " for addr ["
<< addr << "]\n");
}
return idx;
}
@ -508,7 +509,7 @@ namespace {
MemMgr = JMM ? JMM : JITMemoryManager::CreateDefaultMemManager();
if (jit.getJITInfo().needsGOT()) {
MemMgr->AllocateGOT();
DOUT << "JIT is managing a GOT\n";
DEBUG(errs() << "JIT is managing a GOT\n");
}
if (DwarfExceptionHandling) DE = new JITDwarfEmitter(jit);
@ -556,8 +557,8 @@ namespace {
if (MBBLocations.size() <= (unsigned)MBB->getNumber())
MBBLocations.resize((MBB->getNumber()+1)*2);
MBBLocations[MBB->getNumber()] = getCurrentPCValue();
DOUT << "JIT: Emitting BB" << MBB->getNumber() << " at ["
<< (void*) getCurrentPCValue() << "]\n";
DEBUG(errs() << "JIT: Emitting BB" << MBB->getNumber() << " at ["
<< (void*) getCurrentPCValue() << "]\n");
}
virtual uintptr_t getConstantPoolEntryAddress(unsigned Entry) const;
@ -756,7 +757,7 @@ unsigned JITEmitter::addSizeOfGlobal(const GlobalVariable *GV, unsigned Size) {
size_t GVSize = (size_t)TheJIT->getTargetData()->getTypeAllocSize(ElTy);
size_t GVAlign =
(size_t)TheJIT->getTargetData()->getPreferredAlignment(GV);
DOUT << "JIT: Adding in size " << GVSize << " alignment " << GVAlign;
DEBUG(errs() << "JIT: Adding in size " << GVSize << " alignment " << GVAlign);
DEBUG(GV->dump());
// Assume code section ends with worst possible alignment, so first
// variable needs maximal padding.
@ -884,7 +885,7 @@ unsigned JITEmitter::GetSizeOfGlobalsInBytes(MachineFunction &MF) {
}
}
}
DOUT << "JIT: About to look through initializers\n";
DEBUG(errs() << "JIT: About to look through initializers\n");
// Look for more globals that are referenced only from initializers.
// GVSet.end is computed each time because the set can grow as we go.
for (SmallPtrSet<const GlobalVariable *, 8>::iterator I = GVSet.begin();
@ -905,7 +906,7 @@ void JITEmitter::startFunction(MachineFunction &F) {
// Set the memory writable, if it's not already
MemMgr->setMemoryWritable();
if (MemMgr->NeedsExactSize()) {
DOUT << "JIT: ExactSize\n";
DEBUG(errs() << "JIT: ExactSize\n");
const TargetInstrInfo* TII = F.getTarget().getInstrInfo();
MachineJumpTableInfo *MJTI = F.getJumpTableInfo();
MachineConstantPool *MCP = F.getConstantPool();
@ -932,12 +933,12 @@ void JITEmitter::startFunction(MachineFunction &F) {
// Add the function size
ActualSize += TII->GetFunctionSizeInBytes(F);
DOUT << "JIT: ActualSize before globals " << ActualSize << "\n";
DEBUG(errs() << "JIT: ActualSize before globals " << ActualSize << "\n");
// Add the size of the globals that will be allocated after this function.
// These are all the ones referenced from this function that were not
// previously allocated.
ActualSize += GetSizeOfGlobalsInBytes(F);
DOUT << "JIT: ActualSize after globals " << ActualSize << "\n";
DEBUG(errs() << "JIT: ActualSize after globals " << ActualSize << "\n");
} else if (SizeEstimate > 0) {
// SizeEstimate will be non-zero on reallocation attempts.
ActualSize = SizeEstimate;
@ -994,8 +995,8 @@ bool JITEmitter::finishFunction(MachineFunction &F) {
if (MR.isExternalSymbol()) {
ResultPtr = TheJIT->getPointerToNamedFunction(MR.getExternalSymbol(),
false);
DOUT << "JIT: Map \'" << MR.getExternalSymbol() << "\' to ["
<< ResultPtr << "]\n";
DEBUG(errs() << "JIT: Map \'" << MR.getExternalSymbol() << "\' to ["
<< ResultPtr << "]\n");
// If the target REALLY wants a stub for this function, emit it now.
if (!MR.doesntNeedStub()) {
@ -1036,9 +1037,9 @@ bool JITEmitter::finishFunction(MachineFunction &F) {
unsigned idx = Resolver.getGOTIndexForAddr(ResultPtr);
MR.setGOTIndex(idx);
if (((void**)MemMgr->getGOTBase())[idx] != ResultPtr) {
DOUT << "JIT: GOT was out of date for " << ResultPtr
<< " pointing at " << ((void**)MemMgr->getGOTBase())[idx]
<< "\n";
DEBUG(errs() << "JIT: GOT was out of date for " << ResultPtr
<< " pointing at " << ((void**)MemMgr->getGOTBase())[idx]
<< "\n");
((void**)MemMgr->getGOTBase())[idx] = ResultPtr;
}
}
@ -1053,8 +1054,9 @@ bool JITEmitter::finishFunction(MachineFunction &F) {
if (MemMgr->isManagingGOT()) {
unsigned idx = Resolver.getGOTIndexForAddr((void*)BufferBegin);
if (((void**)MemMgr->getGOTBase())[idx] != (void*)BufferBegin) {
DOUT << "JIT: GOT was out of date for " << (void*)BufferBegin
<< " pointing at " << ((void**)MemMgr->getGOTBase())[idx] << "\n";
DEBUG(errs() << "JIT: GOT was out of date for " << (void*)BufferBegin
<< " pointing at " << ((void**)MemMgr->getGOTBase())[idx]
<< "\n");
((void**)MemMgr->getGOTBase())[idx] = (void*)BufferBegin;
}
}
@ -1092,39 +1094,36 @@ bool JITEmitter::finishFunction(MachineFunction &F) {
// Mark code region readable and executable if it's not so already.
MemMgr->setMemoryExecutable();
#ifndef NDEBUG
{
DEBUG(
if (sys::hasDisassembler()) {
DOUT << "JIT: Disassembled code:\n";
DOUT << sys::disassembleBuffer(FnStart, FnEnd-FnStart, (uintptr_t)FnStart);
errs() << "JIT: Disassembled code:\n";
errs() << sys::disassembleBuffer(FnStart, FnEnd-FnStart,
(uintptr_t)FnStart);
} else {
DOUT << "JIT: Binary code:\n";
DOUT << std::hex;
errs() << "JIT: Binary code:\n";
uint8_t* q = FnStart;
for (int i = 0; q < FnEnd; q += 4, ++i) {
if (i == 4)
i = 0;
if (i == 0)
DOUT << "JIT: " << std::setw(8) << std::setfill('0')
<< (long)(q - FnStart) << ": ";
errs() << "JIT: " << (long)(q - FnStart) << ": ";
bool Done = false;
for (int j = 3; j >= 0; --j) {
if (q + j >= FnEnd)
Done = true;
else
DOUT << std::setw(2) << std::setfill('0') << (unsigned short)q[j];
errs() << (unsigned short)q[j];
}
if (Done)
break;
DOUT << ' ';
errs() << ' ';
if (i == 3)
DOUT << '\n';
errs() << '\n';
}
DOUT << std::dec;
DOUT<< '\n';
errs()<< '\n';
}
}
#endif
);
if (DwarfExceptionHandling) {
uintptr_t ActualSize = 0;
SavedBufferBegin = BufferBegin;
@ -1155,7 +1154,7 @@ bool JITEmitter::finishFunction(MachineFunction &F) {
}
void JITEmitter::retryWithMoreMemory(MachineFunction &F) {
DOUT << "JIT: Ran out of space for native code. Reattempting.\n";
DEBUG(errs() << "JIT: Ran out of space for native code. Reattempting.\n");
Relocations.clear(); // Clear the old relocations or we'll reapply them.
ConstPoolAddresses.clear();
++NumRetries;
@ -1190,7 +1189,7 @@ void JITEmitter::deallocateMemForFunction(const Function *F) {
// in the JITResolver. Were there a memory manager deallocateStub routine,
// we could call that at this point too.
if (FnRefs.empty()) {
DOUT << "\nJIT: Invalidated Stub at [" << Stub << "]\n";
DEBUG(errs() << "\nJIT: Invalidated Stub at [" << Stub << "]\n");
StubFnRefs.erase(Stub);
// Invalidate the stub. If it is a GV stub, update the JIT's global
@ -1245,8 +1244,8 @@ void JITEmitter::emitConstantPool(MachineConstantPool *MCP) {
if (ConstantPoolBase == 0) return; // Buffer overflow.
DOUT << "JIT: Emitted constant pool at [" << ConstantPoolBase
<< "] (size: " << Size << ", alignment: " << Align << ")\n";
DEBUG(errs() << "JIT: Emitted constant pool at [" << ConstantPoolBase
<< "] (size: " << Size << ", alignment: " << Align << ")\n");
// Initialize the memory for all of the constant pool entries.
unsigned Offset = 0;
@ -1263,8 +1262,8 @@ void JITEmitter::emitConstantPool(MachineConstantPool *MCP) {
"entry has not been implemented!");
}
TheJIT->InitializeMemory(CPE.Val.ConstVal, (void*)CAddr);
DOUT << "JIT: CP" << i << " at [0x"
<< std::hex << CAddr << std::dec << "]\n";
DEBUG(errs() << "JIT: CP" << i << " at [0x";
errs().write_hex(CAddr) << "]\n");
const Type *Ty = CPE.Val.ConstVal->getType();
Offset += TheJIT->getTargetData()->getTypeAllocSize(Ty);

2
lib/ExecutionEngine/JIT/JITMemoryManager.cpp
View File

@ -357,7 +357,7 @@ namespace {
// another block of memory and add it to the free list.
if (largest < ActualSize ||
largest <= FreeRangeHeader::getMinBlockSize()) {
DOUT << "JIT: Allocating another slab of memory for function.";
DEBUG(errs() << "JIT: Allocating another slab of memory for function.");
candidateBlock = allocateNewCodeSlab((size_t)ActualSize);
}

13
lib/ExecutionEngine/JIT/OProfileJITEventListener.cpp
View File

@ -50,9 +50,9 @@ OProfileJITEventListener::OProfileJITEventListener()
: Agent(op_open_agent()) {
if (Agent == NULL) {
const std::string err_str = sys::StrError();
DOUT << "Failed to connect to OProfile agent: " << err_str << "\n";
DEBUG(errs() << "Failed to connect to OProfile agent: " << err_str << "\n");
} else {
DOUT << "Connected to OProfile agent.\n";
DEBUG(errs() << "Connected to OProfile agent.\n");
}
}
@ -60,9 +60,10 @@ OProfileJITEventListener::~OProfileJITEventListener() {
if (Agent != NULL) {
if (op_close_agent(Agent) == -1) {
const std::string err_str = sys::StrError();
DOUT << "Failed to disconnect from OProfile agent: " << err_str << "\n";
DEBUG(errs() << "Failed to disconnect from OProfile agent: "
<< err_str << "\n");
} else {
DOUT << "Disconnected from OProfile agent.\n";
DEBUG(errs() << "Disconnected from OProfile agent.\n");
}
}
}
@ -99,8 +100,8 @@ static debug_line_info LineStartToOProfileFormat(
const DebugLocTuple& tuple = MF.getDebugLocTuple(Loc);
Result.lineno = tuple.Line;
Result.filename = Filenames.getFilename(tuple.CompileUnit);
DOUT << "Mapping " << reinterpret_cast<void*>(Result.vma) << " to "
<< Result.filename << ":" << Result.lineno << "\n";
DEBUG(errs() << "Mapping " << reinterpret_cast<void*>(Result.vma) << " to "
<< Result.filename << ":" << Result.lineno << "\n");
return Result;
}

6
lib/Transforms/IPO/DeadArgumentElimination.cpp
View File

@ -552,7 +552,7 @@ void DAE::MarkLive(const RetOrArg &RA) {
if (!LiveValues.insert(RA).second)
return; // We were already marked Live.
DOUT << "DAE - Marking " << RA.getDescription() << " live\n";
DEBUG(errs() << "DAE - Marking " << RA.getDescription() << " live\n");
PropagateLiveness(RA);
}
@ -916,7 +916,7 @@ bool DAE::runOnModule(Module &M) {
// removed. We can do this if they never call va_start. This loop cannot be
// fused with the next loop, because deleting a function invalidates
// information computed while surveying other functions.
DOUT << "DAE - Deleting dead varargs\n";
DEBUG(errs() << "DAE - Deleting dead varargs\n");
for (Module::iterator I = M.begin(), E = M.end(); I != E; ) {
Function &F = *I++;
if (F.getFunctionType()->isVarArg())
@ -927,7 +927,7 @@ bool DAE::runOnModule(Module &M) {
// We assume all arguments are dead unless proven otherwise (allowing us to
// determine that dead arguments passed into recursive functions are dead).
//
DOUT << "DAE - Determining liveness\n";
DEBUG(errs() << "DAE - Determining liveness\n");
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
SurveyFunction(*I);

4
lib/Transforms/IPO/MergeFunctions.cpp
View File

@ -633,11 +633,11 @@ bool MergeFunctions::runOnModule(Module &M) {
bool LocalChanged;
do {
LocalChanged = false;
DOUT << "size: " << FnMap.size() << "\n";
DEBUG(errs() << "size: " << FnMap.size() << "\n");
for (std::map<unsigned long, std::vector<Function *> >::iterator
I = FnMap.begin(), E = FnMap.end(); I != E; ++I) {
std::vector<Function *> &FnVec = I->second;
DOUT << "hash (" << I->first << "): " << FnVec.size() << "\n";
DEBUG(errs() << "hash (" << I->first << "): " << FnVec.size() << "\n");
for (int i = 0, e = FnVec.size(); i != e; ++i) {
for (int j = i + 1; j != e; ++j) {

4
lib/Transforms/IPO/StructRetPromotion.cpp
View File

@ -105,12 +105,12 @@ bool SRETPromotion::PromoteReturn(CallGraphNode *CGN) {
// Check if it is ok to perform this promotion.
if (isSafeToUpdateAllCallers(F) == false) {
DOUT << "SretPromotion: Not all callers can be updated\n";
DEBUG(errs() << "SretPromotion: Not all callers can be updated\n");
NumRejectedSRETUses++;
return false;
}
DOUT << "SretPromotion: sret argument will be promoted\n";
DEBUG(errs() << "SretPromotion: sret argument will be promoted\n");
NumSRET++;
// [1] Replace use of sret parameter
AllocaInst *TheAlloca = new AllocaInst(STy, NULL, "mrv",

6
lib/Transforms/Scalar/GVNPRE.cpp
View File

@ -1222,13 +1222,13 @@ void GVNPRE::topo_sort(ValueNumberedSet& set, SmallVector<Value*, 8>& vec) {
/// dump - Dump a set of values to standard error
void GVNPRE::dump(ValueNumberedSet& s) const {
DOUT << "{ ";
DEBUG(errs() << "{ ");
for (ValueNumberedSet::iterator I = s.begin(), E = s.end();
I != E; ++I) {
DOUT << "" << VN.lookup(*I) << ": ";
DEBUG(errs() << "" << VN.lookup(*I) << ": ");
DEBUG((*I)->dump());
}
DOUT << "}\n\n";
DEBUG(errs() << "}\n\n");
}
/// elimination - Phase 3 of the main algorithm. Perform full redundancy