summaryrefslogtreecommitdiffstats
path: root/llvm/lib/CodeGen
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/lib/CodeGen')
-rw-r--r--llvm/lib/CodeGen/InstrSched/SchedGraph.cpp16
-rw-r--r--llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp36
-rw-r--r--llvm/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp15
-rw-r--r--llvm/lib/CodeGen/MachineFunction.cpp50
-rw-r--r--llvm/lib/CodeGen/RegAlloc/LiveRangeInfo.cpp44
-rw-r--r--llvm/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp65
6 files changed, 102 insertions, 124 deletions
diff --git a/llvm/lib/CodeGen/InstrSched/SchedGraph.cpp b/llvm/lib/CodeGen/InstrSched/SchedGraph.cpp
index e67ba93f20c..daf4a49bb83 100644
--- a/llvm/lib/CodeGen/InstrSched/SchedGraph.cpp
+++ b/llvm/lib/CodeGen/InstrSched/SchedGraph.cpp
@@ -20,7 +20,7 @@
#include "llvm/Target/MachineRegInfo.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/BasicBlock.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
#include "llvm/iOther.h"
#include "Support/StringExtras.h"
#include "Support/STLExtras.h"
@@ -955,9 +955,9 @@ SchedGraph::buildGraph(const TargetMachine& target)
//
/*ctor*/
-SchedGraphSet::SchedGraphSet(const Method* _method,
+SchedGraphSet::SchedGraphSet(const Function* _function,
const TargetMachine& target) :
- method(_method)
+ method(_function)
{
buildGraphsForMethod(method, target);
}
@@ -975,23 +975,23 @@ SchedGraphSet::~SchedGraphSet()
void
SchedGraphSet::dump() const
{
- cerr << "======== Sched graphs for method `" << method->getName()
+ cerr << "======== Sched graphs for function `" << method->getName()
<< "' ========\n\n";
for (const_iterator I=begin(); I != end(); ++I)
(*I)->dump();
- cerr << "\n====== End graphs for method `" << method->getName()
+ cerr << "\n====== End graphs for function `" << method->getName()
<< "' ========\n\n";
}
void
-SchedGraphSet::buildGraphsForMethod(const Method *method,
+SchedGraphSet::buildGraphsForMethod(const Function *F,
const TargetMachine& target)
{
- for (Method::const_iterator BI = method->begin(); BI != method->end(); ++BI)
- this->addGraph(new SchedGraph(*BI, target));
+ for (Function::const_iterator BI = F->begin(); BI != F->end(); ++BI)
+ addGraph(new SchedGraph(*BI, target));
}
diff --git a/llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp b/llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp
index 3efc5274700..1eb507a695b 100644
--- a/llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp
+++ b/llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp
@@ -23,7 +23,7 @@
#include "llvm/Target/MachineRegInfo.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/BasicBlock.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
#include "llvm/iPHINode.h"
#include "Support/CommandLine.h"
#include <iostream>
@@ -60,7 +60,7 @@ static void PostprocessMachineCodeForTree(InstructionNode* instrNode,
short* nts,
TargetMachine &target);
-static void InsertCode4AllPhisInMeth(Method *method, TargetMachine &target);
+static void InsertCode4AllPhisInMeth(Function *F, TargetMachine &target);
@@ -73,25 +73,23 @@ static void InsertCode4AllPhisInMeth(Method *method, TargetMachine &target);
//---------------------------------------------------------------------------
bool
-SelectInstructionsForMethod(Method* method, TargetMachine &target)
+SelectInstructionsForMethod(Function *F, TargetMachine &target)
{
bool failed = false;
//
// Build the instruction trees to be given as inputs to BURG.
//
- InstrForest instrForest(method);
+ InstrForest instrForest(F);
if (SelectDebugLevel >= Select_DebugInstTrees)
{
- cerr << "\n\n*** Input to instruction selection for method "
- << (method->hasName()? method->getName() : "")
- << "\n\n";
- method->dump();
+ cerr << "\n\n*** Input to instruction selection for function "
+ << F->getName() << "\n\n";
+ F->dump();
- cerr << "\n\n*** Instruction trees for method "
- << (method->hasName()? method->getName() : "")
- << "\n\n";
+ cerr << "\n\n*** Instruction trees for function "
+ << F->getName() << "\n\n";
instrForest.dump();
}
@@ -125,7 +123,7 @@ SelectInstructionsForMethod(Method* method, TargetMachine &target)
//
// Record instructions in the vector for each basic block
//
- for (Method::iterator BI = method->begin(); BI != method->end(); ++BI)
+ for (Function::iterator BI = F->begin(), BE = F->end(); BI != BE; ++BI)
{
MachineCodeForBasicBlock& bbMvec = (*BI)->getMachineInstrVec();
for (BasicBlock::iterator II = (*BI)->begin(); II != (*BI)->end(); ++II)
@@ -137,13 +135,13 @@ SelectInstructionsForMethod(Method* method, TargetMachine &target)
}
// Insert phi elimination code -- added by Ruchira
- InsertCode4AllPhisInMeth(method, target);
+ InsertCode4AllPhisInMeth(F, target);
if (SelectDebugLevel >= Select_PrintMachineCode)
{
cerr << "\n*** Machine instructions after INSTRUCTION SELECTION\n";
- MachineCodeForMethod::get(method).dump();
+ MachineCodeForMethod::get(F).dump();
}
return false;
@@ -190,11 +188,11 @@ InsertPhiElimInstructions(BasicBlock *BB, const vector<MachineInstr*>& CpVec)
//-------------------------------------------------------------------------
void
-InsertCode4AllPhisInMeth(Method *method, TargetMachine &target)
+InsertCode4AllPhisInMeth(Function *F, TargetMachine &target)
{
- // for all basic blocks in method
+ // for all basic blocks in function
//
- for (Method::iterator BI = method->begin(); BI != method->end(); ++BI) {
+ for (Function::iterator BI = F->begin(); BI != F->end(); ++BI) {
BasicBlock *BB = *BI;
const BasicBlock::InstListType &InstList = BB->getInstList();
@@ -236,9 +234,7 @@ InsertCode4AllPhisInMeth(Method *method, TargetMachine &target)
else break; // since PHI nodes can only be at the top
} // for each Phi Instr in BB
-
- } // for all BBs in method
-
+ } // for all BBs in function
}
diff --git a/llvm/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp b/llvm/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp
index ff43f04a5f9..24efdf1456c 100644
--- a/llvm/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp
+++ b/llvm/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp
@@ -20,7 +20,7 @@
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/MachineRegInfo.h"
#include "llvm/ConstantVals.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
#include "llvm/BasicBlock.h"
#include "llvm/Type.h"
#include "llvm/iMemory.h"
@@ -30,7 +30,7 @@ using std::vector;
static TmpInstruction*
-InsertCodeToLoadConstant(Method* method,
+InsertCodeToLoadConstant(Function *F,
Value* opValue,
Instruction* vmInstr,
vector<MachineInstr*>& loadConstVec,
@@ -43,7 +43,7 @@ InsertCodeToLoadConstant(Method* method,
MachineCodeForInstruction &MCFI = MachineCodeForInstruction::get(vmInstr);
MCFI.addTemp(tmpReg);
- target.getInstrInfo().CreateCodeToLoadConst(method, opValue, tmpReg,
+ target.getInstrInfo().CreateCodeToLoadConst(F, opValue, tmpReg,
loadConstVec, tempVec);
// Register the new tmp values created for this m/c instruction sequence
@@ -344,7 +344,7 @@ FixConstantOperandsForInstr(Instruction* vmInstr,
const MachineInstrDescriptor& instrDesc =
target.getInstrInfo().getDescriptor(minstr->getOpCode());
- Method* method = vmInstr->getParent()->getParent();
+ Function *F = vmInstr->getParent()->getParent();
for (unsigned op=0; op < minstr->getNumOperands(); op++)
{
@@ -381,8 +381,9 @@ FixConstantOperandsForInstr(Instruction* vmInstr,
if (constantThatMustBeLoaded || isa<GlobalValue>(opValue))
{ // opValue is a constant that must be explicitly loaded into a reg.
- TmpInstruction* tmpReg = InsertCodeToLoadConstant(method, opValue, vmInstr,
- loadConstVec, target);
+ TmpInstruction* tmpReg = InsertCodeToLoadConstant(F, opValue, vmInstr,
+ loadConstVec,
+ target);
minstr->SetMachineOperandVal(op, MachineOperand::MO_VirtualRegister,
tmpReg);
}
@@ -404,7 +405,7 @@ FixConstantOperandsForInstr(Instruction* vmInstr,
{
Value* oldVal = minstr->getImplicitRef(i);
TmpInstruction* tmpReg =
- InsertCodeToLoadConstant(method, oldVal, vmInstr, loadConstVec, target);
+ InsertCodeToLoadConstant(F, oldVal, vmInstr, loadConstVec, target);
minstr->setImplicitRef(i, tmpReg);
}
diff --git a/llvm/lib/CodeGen/MachineFunction.cpp b/llvm/lib/CodeGen/MachineFunction.cpp
index ef27dbae71c..bb52ef298e5 100644
--- a/llvm/lib/CodeGen/MachineFunction.cpp
+++ b/llvm/lib/CodeGen/MachineFunction.cpp
@@ -1,9 +1,9 @@
-//===-- MachineCodeForMethod.cpp --------------------------------------------=//
+//===-- MachineCodeForFunction.cpp ------------------------------------------=//
//
// Purpose:
-// Collect native machine code information for a method.
+// Collect native machine code information for a function.
// This allows target-specific information about the generated code
-// to be stored with each method.
+// to be stored with each function.
//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/MachineCodeForMethod.h"
@@ -11,7 +11,7 @@
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/MachineFrameInfo.h"
#include "llvm/Target/MachineCacheInfo.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
#include "llvm/BasicBlock.h"
#include "llvm/iOther.h"
#include <limits.h>
@@ -20,57 +20,55 @@
const int INVALID_FRAME_OFFSET = INT_MAX; // std::numeric_limits<int>::max();
static AnnotationID MCFM_AID(
- AnnotationManager::getID("CodeGen::MachineCodeForMethod"));
+ AnnotationManager::getID("CodeGen::MachineCodeForFunction"));
// The next two methods are used to construct and to retrieve
-// the MachineCodeForMethod object for the given method.
-// construct() -- Allocates and initializes for a given method and target
+// the MachineCodeForFunction object for the given function.
+// construct() -- Allocates and initializes for a given function and target
// get() -- Returns a handle to the object.
// This should not be called before "construct()"
-// for a given Method.
+// for a given Function.
//
MachineCodeForMethod&
-MachineCodeForMethod::construct(const Method *M, const TargetMachine &Tar)
+MachineCodeForMethod::construct(const Function *M, const TargetMachine &Tar)
{
assert(M->getAnnotation(MCFM_AID) == 0 &&
- "Object already exists for this method!");
+ "Object already exists for this function!");
MachineCodeForMethod* mcInfo = new MachineCodeForMethod(M, Tar);
M->addAnnotation(mcInfo);
return *mcInfo;
}
void
-MachineCodeForMethod::destruct(const Method *M)
+MachineCodeForMethod::destruct(const Function *M)
{
bool Deleted = M->deleteAnnotation(MCFM_AID);
- assert(Deleted && "Machine code did not exist for method!");
+ assert(Deleted && "Machine code did not exist for function!");
}
MachineCodeForMethod&
-MachineCodeForMethod::get(const Method* method)
+MachineCodeForMethod::get(const Function *F)
{
- MachineCodeForMethod* mc = (MachineCodeForMethod*)
- method->getAnnotation(MCFM_AID);
+ MachineCodeForMethod *mc = (MachineCodeForMethod*)F->getAnnotation(MCFM_AID);
assert(mc && "Call construct() method first to allocate the object");
return *mc;
}
static unsigned
-ComputeMaxOptionalArgsSize(const TargetMachine& target, const Method* method)
+ComputeMaxOptionalArgsSize(const TargetMachine& target, const Function *F)
{
const MachineFrameInfo& frameInfo = target.getFrameInfo();
unsigned int maxSize = 0;
- for (Method::const_iterator MI=method->begin(), ME=method->end();
- MI != ME; ++MI)
+ for (Function::const_iterator MI = F->begin(), ME = F->end(); MI != ME; ++MI)
{
const BasicBlock *BB = *MI;
- for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I)
+ for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I)
if (CallInst *callInst = dyn_cast<CallInst>(*I))
{
unsigned int numOperands = callInst->getNumOperands() - 1;
- int numExtra = (int) numOperands - frameInfo.getNumFixedOutgoingArgs();
+ int numExtra = (int)numOperands-frameInfo.getNumFixedOutgoingArgs();
if (numExtra <= 0)
continue;
@@ -82,7 +80,9 @@ ComputeMaxOptionalArgsSize(const TargetMachine& target, const Method* method)
}
else
{
- assert(0 && "UNTESTED CODE: Size per stack argument is not fixed on this architecture: use actual arg sizes to compute MaxOptionalArgsSize");
+ assert(0 && "UNTESTED CODE: Size per stack argument is not "
+ "fixed on this architecture: use actual arg sizes to "
+ "compute MaxOptionalArgsSize");
sizeForThisCall = 0;
for (unsigned i=0; i < numOperands; ++i)
sizeForThisCall += target.findOptimalStorageSize(callInst->
@@ -118,10 +118,10 @@ SizeToAlignment(unsigned int size, const TargetMachine& target)
/*ctor*/
-MachineCodeForMethod::MachineCodeForMethod(const Method* _M,
+MachineCodeForMethod::MachineCodeForMethod(const Function *F,
const TargetMachine& target)
: Annotation(MCFM_AID),
- method(_M), compiledAsLeaf(false), staticStackSize(0),
+ method(F), compiledAsLeaf(false), staticStackSize(0),
automaticVarsSize(0), regSpillsSize(0),
currentOptionalArgsSize(0), maxOptionalArgsSize(0),
currentTmpValuesSize(0), maxTmpValuesSize(0)
@@ -307,7 +307,7 @@ MachineCodeForMethod::dump() const
std::cerr << "\n" << method->getReturnType()
<< " \"" << method->getName() << "\"\n";
- for (Method::const_iterator BI = method->begin(); BI != method->end(); ++BI)
+ for (Function::const_iterator BI = method->begin(); BI != method->end(); ++BI)
{
BasicBlock* bb = *BI;
std::cerr << "\n" << bb->getName() << " (" << bb << ")" << ":\n";
@@ -316,5 +316,5 @@ MachineCodeForMethod::dump() const
for (unsigned i=0; i < mvec.size(); i++)
std::cerr << "\t" << *mvec[i];
}
- std::cerr << "\nEnd method \"" << method->getName() << "\"\n\n";
+ std::cerr << "\nEnd function \"" << method->getName() << "\"\n\n";
}
diff --git a/llvm/lib/CodeGen/RegAlloc/LiveRangeInfo.cpp b/llvm/lib/CodeGen/RegAlloc/LiveRangeInfo.cpp
index 32951769e00..fb29af2bf19 100644
--- a/llvm/lib/CodeGen/RegAlloc/LiveRangeInfo.cpp
+++ b/llvm/lib/CodeGen/RegAlloc/LiveRangeInfo.cpp
@@ -2,15 +2,15 @@
#include "llvm/CodeGen/RegClass.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/Target/TargetMachine.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
#include "llvm/BasicBlock.h"
#include "Support/SetOperations.h"
#include <iostream>
using std::cerr;
-LiveRangeInfo::LiveRangeInfo(const Method *M, const TargetMachine &tm,
+LiveRangeInfo::LiveRangeInfo(const Function *F, const TargetMachine &tm,
std::vector<RegClass *> &RCL)
- : Meth(M), TM(tm), RegClassList(RCL), MRI(tm.getRegInfo()) { }
+ : Meth(F), TM(tm), RegClassList(RCL), MRI(tm.getRegInfo()) { }
LiveRangeInfo::~LiveRangeInfo() {
@@ -48,7 +48,7 @@ void LiveRangeInfo::unionAndUpdateLRs(LiveRange *L1, LiveRange *L2) {
//assert(( L1->getTypeID() == L2->getTypeID()) && "Merge:Different types");
L1->insert(*L2It); // add the var in L2 to L1
- LiveRangeMap[*L2It] = L1; // now the elements in L2 should map
+ LiveRangeMap[*L2It] = L1; // now the elements in L2 should map
//to L1
}
@@ -73,24 +73,22 @@ void LiveRangeInfo::unionAndUpdateLRs(LiveRange *L1, LiveRange *L2) {
//---------------------------------------------------------------------------
-// Method for constructing all live ranges in a method. It creates live
+// Method for constructing all live ranges in a function. It creates live
// ranges for all values defined in the instruction stream. Also, it
-// creates live ranges for all incoming arguments of the method.
+// creates live ranges for all incoming arguments of the function.
//---------------------------------------------------------------------------
void LiveRangeInfo::constructLiveRanges() {
if (DEBUG_RA)
cerr << "Consturcting Live Ranges ...\n";
- // first find the live ranges for all incoming args of the method since
- // those LRs start from the start of the method
+ // first find the live ranges for all incoming args of the function since
+ // those LRs start from the start of the function
- // get the argument list
- const Method::ArgumentListType& ArgList = Meth->getArgumentList();
- // get an iterator to arg list
- Method::ArgumentListType::const_iterator ArgIt = ArgList.begin();
+ // get the argument list
+ const Function::ArgumentListType& ArgList = Meth->getArgumentList();
-
+ Function::ArgumentListType::const_iterator ArgIt = ArgList.begin();
for( ; ArgIt != ArgList.end() ; ++ArgIt) { // for each argument
LiveRange * ArgRange = new LiveRange(); // creates a new LR and
const Value *Val = (const Value *) *ArgIt;
@@ -111,15 +109,14 @@ void LiveRangeInfo::constructLiveRanges() {
}
}
- // Now suggest hardware registers for these method args
+ // Now suggest hardware registers for these function args
MRI.suggestRegs4MethodArgs(Meth, *this);
-
// Now find speical LLVM instructions (CALL, RET) and LRs in machine
// instructions.
//
- for (Method::const_iterator BBI = Meth->begin(); BBI != Meth->end(); ++BBI) {
+ for (Function::const_iterator BBI = Meth->begin(); BBI != Meth->end(); ++BBI){
// Now find all LRs for machine the instructions. A new LR will be created
// only for defs in the machine instr since, we assume that all Values are
// defined before they are used. However, there can be multiple defs for
@@ -207,7 +204,7 @@ void LiveRangeInfo::constructLiveRanges() {
} // for all machine instructions in the BB
- } // for all BBs in method
+ } // for all BBs in function
// Now we have to suggest clors for call and return arg live ranges.
@@ -225,16 +222,14 @@ void LiveRangeInfo::constructLiveRanges() {
//---------------------------------------------------------------------------
// If some live ranges must be colored with specific hardware registers
// (e.g., for outgoing call args), suggesting of colors for such live
-// ranges is done using target specific method. Those methods are called
+// ranges is done using target specific function. Those functions are called
// from this function. The target specific methods must:
// 1) suggest colors for call and return args.
// 2) create new LRs for implicit defs in machine instructions
//---------------------------------------------------------------------------
void LiveRangeInfo::suggestRegs4CallRets()
{
-
CallRetInstrListType::const_iterator It = CallRetInstrList.begin();
-
for( ; It != CallRetInstrList.end(); ++It ) {
const MachineInstr *MInst = *It;
@@ -259,7 +254,7 @@ void LiveRangeInfo::suggestRegs4CallRets()
/* Algorithm:
- for each BB in method
+ for each BB in function
for each machine instruction (inst)
for each definition (def) in inst
for each operand (op) of inst that is a use
@@ -273,12 +268,11 @@ void LiveRangeInfo::suggestRegs4CallRets()
//---------------------------------------------------------------------------
void LiveRangeInfo::coalesceLRs()
{
- if( DEBUG_RA)
+ if(DEBUG_RA)
cerr << "\nCoalscing LRs ...\n";
- Method::const_iterator BBI = Meth->begin(); // random iterator for BBs
-
- for( ; BBI != Meth->end(); ++BBI) { // traverse BBs in random order
+ for(Function::const_iterator BBI = Meth->begin(), BBE = Meth->end();
+ BBI != BBE; ++BBI) {
// get the iterator for machine instructions
const MachineCodeForBasicBlock& MIVec = (*BBI)->getMachineInstrVec();
diff --git a/llvm/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp b/llvm/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
index 49667e00795..c9d775e2849 100644
--- a/llvm/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
+++ b/llvm/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
@@ -19,7 +19,7 @@
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/MachineFrameInfo.h"
#include "llvm/BasicBlock.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
#include "llvm/Type.h"
#include <iostream>
#include <math.h>
@@ -45,12 +45,12 @@ namespace {
public:
inline RegisterAllocator(TargetMachine &T) : Target(T) {}
- bool runOnMethod(Method *M) {
+ bool runOnMethod(Function *F) {
if (DEBUG_RA)
- cerr << "\n******************** Method "<< M->getName()
+ cerr << "\n******************** Method "<< F->getName()
<< " ********************\n";
- PhyRegAlloc PRA(M, Target, &getAnalysis<MethodLiveVarInfo>(),
+ PhyRegAlloc PRA(F, Target, &getAnalysis<MethodLiveVarInfo>(),
&getAnalysis<cfg::LoopInfo>());
PRA.allocateRegisters();
@@ -75,22 +75,22 @@ MethodPass *getRegisterAllocator(TargetMachine &T) {
//----------------------------------------------------------------------------
// Constructor: Init local composite objects and create register classes.
//----------------------------------------------------------------------------
-PhyRegAlloc::PhyRegAlloc(Method *M,
+PhyRegAlloc::PhyRegAlloc(Function *F,
const TargetMachine& tm,
MethodLiveVarInfo *Lvi,
cfg::LoopInfo *LDC)
- : TM(tm), Meth(M),
- mcInfo(MachineCodeForMethod::get(M)),
- LVI(Lvi), LRI(M, tm, RegClassList),
- MRI( tm.getRegInfo() ),
+ : TM(tm), Meth(F),
+ mcInfo(MachineCodeForMethod::get(F)),
+ LVI(Lvi), LRI(F, tm, RegClassList),
+ MRI(tm.getRegInfo()),
NumOfRegClasses(MRI.getNumOfRegClasses()),
LoopDepthCalc(LDC) {
// create each RegisterClass and put in RegClassList
//
for(unsigned int rc=0; rc < NumOfRegClasses; rc++)
- RegClassList.push_back( new RegClass(M, MRI.getMachineRegClass(rc),
- &ResColList) );
+ RegClassList.push_back(new RegClass(F, MRI.getMachineRegClass(rc),
+ &ResColList));
}
@@ -278,13 +278,12 @@ void PhyRegAlloc::buildInterferenceGraphs()
if(DEBUG_RA) cerr << "Creating interference graphs ...\n";
unsigned BBLoopDepthCost;
- Method::const_iterator BBI = Meth->begin(); // random iterator for BBs
-
- for( ; BBI != Meth->end(); ++BBI) { // traverse BBs in random order
+ for (Function::const_iterator BBI = Meth->begin(), BBE = Meth->end();
+ BBI != BBE; ++BBI) {
// find the 10^(loop_depth) of this BB
//
- BBLoopDepthCost = (unsigned) pow( 10.0, LoopDepthCalc->getLoopDepth(*BBI));
+ BBLoopDepthCost = (unsigned) pow(10.0, LoopDepthCalc->getLoopDepth(*BBI));
// get the iterator for machine instructions
//
@@ -346,12 +345,11 @@ void PhyRegAlloc::buildInterferenceGraphs()
} // for all machine instructions in BB
-
- } // for all BBs in method
+ } // for all BBs in function
- // add interferences for method arguments. Since there are no explict
- // defs in method for args, we have to add them manually
+ // add interferences for function arguments. Since there are no explict
+ // defs in the function for args, we have to add them manually
//
addInterferencesForArgs();
@@ -405,17 +403,17 @@ void PhyRegAlloc::addInterf4PseudoInstr(const MachineInstr *MInst) {
//----------------------------------------------------------------------------
-// This method will add interferences for incoming arguments to a method.
+// This method will add interferences for incoming arguments to a function.
//----------------------------------------------------------------------------
void PhyRegAlloc::addInterferencesForArgs() {
// get the InSet of root BB
const ValueSet &InSet = LVI->getInSetOfBB(Meth->front());
// get the argument list
- const Method::ArgumentListType& ArgList = Meth->getArgumentList();
+ const Function::ArgumentListType &ArgList = Meth->getArgumentList();
// get an iterator to arg list
- Method::ArgumentListType::const_iterator ArgIt = ArgList.begin();
+ Function::ArgumentListType::const_iterator ArgIt = ArgList.begin();
for( ; ArgIt != ArgList.end() ; ++ArgIt) { // for each argument
@@ -441,10 +439,8 @@ void PhyRegAlloc::addInterferencesForArgs() {
void PhyRegAlloc::updateMachineCode()
{
- Method::const_iterator BBI = Meth->begin(); // random iterator for BBs
-
- for( ; BBI != Meth->end(); ++BBI) { // traverse BBs in random order
-
+ for (Function::const_iterator BBI = Meth->begin(), BBE = Meth->end();
+ BBI != BBE; ++BBI) {
// get the iterator for machine instructions
//
MachineCodeForBasicBlock& MIVec = (*BBI)->getMachineInstrVec();
@@ -955,14 +951,12 @@ void PhyRegAlloc:: move2DelayedInstr(const MachineInstr *OrigMI,
void PhyRegAlloc::printMachineCode()
{
- cerr << "\n;************** Method " << Meth->getName()
+ cerr << "\n;************** Function " << Meth->getName()
<< " *****************\n";
- Method::const_iterator BBI = Meth->begin(); // random iterator for BBs
-
- for( ; BBI != Meth->end(); ++BBI) { // traverse BBs in random order
-
- cerr << "\n"; printLabel( *BBI); cerr << ": ";
+ for (Function::const_iterator BBI = Meth->begin(), BBE = Meth->end();
+ BBI != BBE; ++BBI) {
+ cerr << "\n"; printLabel(*BBI); cerr << ": ";
// get the iterator for machine instructions
MachineCodeForBasicBlock& MIVec = (*BBI)->getMachineInstrVec();
@@ -970,18 +964,12 @@ void PhyRegAlloc::printMachineCode()
// iterate over all the machine instructions in BB
for( ; MInstIterator != MIVec.end(); ++MInstIterator) {
-
MachineInstr *const MInst = *MInstIterator;
-
cerr << "\n\t";
cerr << TargetInstrDescriptors[MInst->getOpCode()].opCodeString;
-
-
- //for(MachineInstr::val_const_op_iterator OpI(MInst);!OpI.done();++OpI) {
for(unsigned OpNum=0; OpNum < MInst->getNumOperands(); ++OpNum) {
-
MachineOperand& Op = MInst->getOperand(OpNum);
if( Op.getOperandType() == MachineOperand::MO_VirtualRegister ||
@@ -1074,7 +1062,6 @@ void PhyRegAlloc::colorCallRetArgs()
// So reset it before we call each such method
//mcInfo.popAllTempValues(TM);
-
if (TM.getInstrInfo().isCall(OpCode))
MRI.colorCallArgs(CRMI, LRI, AI, *this);
OpenPOWER on IntegriCloud