blob: 15584f14a57209f37aa8b29b9db3bee0ae4034c0 [file] [log] [blame]
Vikram S. Adve39c94e12002-09-14 23:05:33 +00001//===-- LiveRangeInfo.cpp -------------------------------------------------===//
2//
3// Live range construction for coloring-based register allocation for LLVM.
4//
5//===----------------------------------------------------------------------===//
6
Ruchira Sasanka8e604792001-09-14 21:18:34 +00007#include "llvm/CodeGen/LiveRangeInfo.h"
Chris Lattner4309e732003-01-15 19:57:07 +00008#include "RegAllocCommon.h"
Chris Lattner9d4ed152003-01-15 21:14:01 +00009#include "RegClass.h"
Chris Lattnercb6b4bd2002-10-29 16:51:05 +000010#include "llvm/CodeGen/IGNode.h"
Chris Lattner0a8ed942002-02-04 05:56:09 +000011#include "llvm/CodeGen/MachineInstr.h"
Chris Lattnerf726e772002-10-28 19:22:04 +000012#include "llvm/CodeGen/MachineFunction.h"
Chris Lattner0a8ed942002-02-04 05:56:09 +000013#include "llvm/Target/TargetMachine.h"
Chris Lattner3501fea2003-01-14 22:00:31 +000014#include "llvm/Target/TargetInstrInfo.h"
Chris Lattner2fbfdcf2002-04-07 20:49:59 +000015#include "llvm/Function.h"
Chris Lattner7471a7b2002-02-05 03:35:53 +000016#include "Support/SetOperations.h"
Chris Lattner697954c2002-01-20 22:54:45 +000017using std::cerr;
Ruchira Sasanka8e604792001-09-14 21:18:34 +000018
Chris Lattner9d4ed152003-01-15 21:14:01 +000019unsigned LiveRange::getRegClassID() const { return getRegClass()->getID(); }
20
Chris Lattner2fbfdcf2002-04-07 20:49:59 +000021LiveRangeInfo::LiveRangeInfo(const Function *F, const TargetMachine &tm,
Chris Lattner697954c2002-01-20 22:54:45 +000022 std::vector<RegClass *> &RCL)
Chris Lattner2fbfdcf2002-04-07 20:49:59 +000023 : Meth(F), TM(tm), RegClassList(RCL), MRI(tm.getRegInfo()) { }
Ruchira Sasanka8e604792001-09-14 21:18:34 +000024
25
Ruchira Sasanka4f3eb222002-01-07 19:19:18 +000026LiveRangeInfo::~LiveRangeInfo() {
Chris Lattner2f898d22002-02-05 06:02:59 +000027 for (LiveRangeMapType::iterator MI = LiveRangeMap.begin();
28 MI != LiveRangeMap.end(); ++MI) {
Ruchira Sasanka4f3eb222002-01-07 19:19:18 +000029
Chris Lattner697954c2002-01-20 22:54:45 +000030 if (MI->first && MI->second) {
31 LiveRange *LR = MI->second;
32
33 // we need to be careful in deleting LiveRanges in LiveRangeMap
34 // since two/more Values in the live range map can point to the same
35 // live range. We have to make the other entries NULL when we delete
36 // a live range.
37
Chris Lattnercb6b4bd2002-10-29 16:51:05 +000038 for (LiveRange::iterator LI = LR->begin(); LI != LR->end(); ++LI)
Chris Lattner697954c2002-01-20 22:54:45 +000039 LiveRangeMap[*LI] = 0;
40
41 delete LR;
Ruchira Sasanka4f3eb222002-01-07 19:19:18 +000042 }
43 }
Ruchira Sasanka4f3eb222002-01-07 19:19:18 +000044}
45
46
47//---------------------------------------------------------------------------
Ruchira Sasanka8e604792001-09-14 21:18:34 +000048// union two live ranges into one. The 2nd LR is deleted. Used for coalescing.
Ruchira Sasankaa5ab9642001-09-30 23:11:59 +000049// Note: the caller must make sure that L1 and L2 are distinct and both
50// LRs don't have suggested colors
Ruchira Sasanka4f3eb222002-01-07 19:19:18 +000051//---------------------------------------------------------------------------
Ruchira Sasanka8e604792001-09-14 21:18:34 +000052
Chris Lattner296b7732002-02-05 02:52:05 +000053void LiveRangeInfo::unionAndUpdateLRs(LiveRange *L1, LiveRange *L2) {
54 assert(L1 != L2 && (!L1->hasSuggestedColor() || !L2->hasSuggestedColor()));
55 set_union(*L1, *L2); // add elements of L2 to L1
Ruchira Sasanka8e604792001-09-14 21:18:34 +000056
Chris Lattner296b7732002-02-05 02:52:05 +000057 for(ValueSet::iterator L2It = L2->begin(); L2It != L2->end(); ++L2It) {
Ruchira Sasanka8e604792001-09-14 21:18:34 +000058 //assert(( L1->getTypeID() == L2->getTypeID()) && "Merge:Different types");
59
Chris Lattner30adeb62002-02-04 16:36:59 +000060 L1->insert(*L2It); // add the var in L2 to L1
Chris Lattner2fbfdcf2002-04-07 20:49:59 +000061 LiveRangeMap[*L2It] = L1; // now the elements in L2 should map
Ruchira Sasanka4f3eb222002-01-07 19:19:18 +000062 //to L1
Ruchira Sasanka8e604792001-09-14 21:18:34 +000063 }
Ruchira Sasankaa5ab9642001-09-30 23:11:59 +000064
65
66 // Now if LROfDef(L1) has a suggested color, it will remain.
67 // But, if LROfUse(L2) has a suggested color, the new range
68 // must have the same color.
69
70 if(L2->hasSuggestedColor())
Chris Lattner296b7732002-02-05 02:52:05 +000071 L1->setSuggestedColor(L2->getSuggestedColor());
Ruchira Sasankaa5ab9642001-09-30 23:11:59 +000072
Ruchira Sasanka958faf32001-10-19 17:21:03 +000073
Chris Lattner296b7732002-02-05 02:52:05 +000074 if (L2->isCallInterference())
Ruchira Sasanka958faf32001-10-19 17:21:03 +000075 L1->setCallInterference();
76
Chris Lattner296b7732002-02-05 02:52:05 +000077 // add the spill costs
78 L1->addSpillCost(L2->getSpillCost());
79
Chris Lattner697954c2002-01-20 22:54:45 +000080 delete L2; // delete L2 as it is no longer needed
Ruchira Sasanka8e604792001-09-14 21:18:34 +000081}
82
83
Vikram S. Adve9d67cd12002-09-28 17:05:22 +000084//---------------------------------------------------------------------------
85// Method for creating a single live range for a definition.
86// The definition must be represented by a virtual register (a Value).
87// Note: this function does *not* check that no live range exists for def.
88//---------------------------------------------------------------------------
89
90LiveRange*
91LiveRangeInfo::createNewLiveRange(const Value* Def, bool isCC /* = false*/)
92{
93 LiveRange* DefRange = new LiveRange(); // Create a new live range,
94 DefRange->insert(Def); // add Def to it,
95 LiveRangeMap[Def] = DefRange; // and update the map.
96
97 // set the register class of the new live range
Chris Lattner9d4ed152003-01-15 21:14:01 +000098 DefRange->setRegClass(RegClassList[MRI.getRegClassIDOfType(Def->getType(),
99 isCC)]);
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000100
101 if (DEBUG_RA >= RA_DEBUG_LiveRanges) {
102 cerr << " Creating a LR for def ";
103 if (isCC) cerr << " (CC Register!)";
104 cerr << " : " << RAV(Def) << "\n";
105 }
106 return DefRange;
107}
108
109
110LiveRange*
111LiveRangeInfo::createOrAddToLiveRange(const Value* Def, bool isCC /* = false*/)
112{
113 LiveRange *DefRange = LiveRangeMap[Def];
114
115 // check if the LR is already there (because of multiple defs)
116 if (!DefRange) {
Chris Lattner133f0792002-10-28 04:45:29 +0000117 DefRange = createNewLiveRange(Def, isCC);
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000118 } else { // live range already exists
119 DefRange->insert(Def); // add the operand to the range
120 LiveRangeMap[Def] = DefRange; // make operand point to merged set
121 if (DEBUG_RA >= RA_DEBUG_LiveRanges)
122 cerr << " Added to existing LR for def: " << RAV(Def) << "\n";
123 }
124 return DefRange;
125}
126
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000127
Ruchira Sasanka4f3eb222002-01-07 19:19:18 +0000128//---------------------------------------------------------------------------
Chris Lattner2fbfdcf2002-04-07 20:49:59 +0000129// Method for constructing all live ranges in a function. It creates live
Ruchira Sasanka4f3eb222002-01-07 19:19:18 +0000130// ranges for all values defined in the instruction stream. Also, it
Chris Lattner2fbfdcf2002-04-07 20:49:59 +0000131// creates live ranges for all incoming arguments of the function.
Ruchira Sasanka4f3eb222002-01-07 19:19:18 +0000132//---------------------------------------------------------------------------
Chris Lattner2f898d22002-02-05 06:02:59 +0000133void LiveRangeInfo::constructLiveRanges() {
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000134
Vikram S. Adve39c94e12002-09-14 23:05:33 +0000135 if (DEBUG_RA >= RA_DEBUG_LiveRanges)
136 cerr << "Constructing Live Ranges ...\n";
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000137
Chris Lattner2fbfdcf2002-04-07 20:49:59 +0000138 // first find the live ranges for all incoming args of the function since
139 // those LRs start from the start of the function
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000140 for (Function::const_aiterator AI = Meth->abegin(); AI != Meth->aend(); ++AI)
Chris Lattner133f0792002-10-28 04:45:29 +0000141 createNewLiveRange(AI, /*isCC*/ false);
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000142
Chris Lattner2fbfdcf2002-04-07 20:49:59 +0000143 // Now suggest hardware registers for these function args
Ruchira Sasankaa5ab9642001-09-30 23:11:59 +0000144 MRI.suggestRegs4MethodArgs(Meth, *this);
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000145
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000146 // Now create LRs for machine instructions. A new LR will be created
147 // only for defs in the machine instr since, we assume that all Values are
148 // defined before they are used. However, there can be multiple defs for
149 // the same Value in machine instructions.
150 //
151 // Also, find CALL and RETURN instructions, which need extra work.
Chris Lattner2f898d22002-02-05 06:02:59 +0000152 //
Chris Lattnerf726e772002-10-28 19:22:04 +0000153 MachineFunction &MF = MachineFunction::get(Meth);
154 for (MachineFunction::iterator BBI = MF.begin(); BBI != MF.end(); ++BBI) {
155 MachineBasicBlock &MBB = *BBI;
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000156
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000157 // iterate over all the machine instructions in BB
Chris Lattnerf726e772002-10-28 19:22:04 +0000158 for(MachineBasicBlock::iterator MInstIterator = MBB.begin();
159 MInstIterator != MBB.end(); ++MInstIterator) {
Vikram S. Advec9a0ca52002-07-08 23:07:26 +0000160 MachineInstr *MInst = *MInstIterator;
Ruchira Sasankaa5ab9642001-09-30 23:11:59 +0000161
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000162 // If the machine instruction is a call/return instruction, add it to
163 // CallRetInstrList for processing its args, ret value, and ret addr.
164 //
Chris Lattner697954c2002-01-20 22:54:45 +0000165 if(TM.getInstrInfo().isReturn(MInst->getOpCode()) ||
166 TM.getInstrInfo().isCall(MInst->getOpCode()))
Chris Lattner133f0792002-10-28 04:45:29 +0000167 CallRetInstrList.push_back(MInst);
Ruchira Sasankaa90e7702001-10-15 16:26:38 +0000168
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000169 // iterate over explicit MI operands and create a new LR
170 // for each operand that is defined by the instruction
Vikram S. Advec9a0ca52002-07-08 23:07:26 +0000171 for (MachineInstr::val_op_iterator OpI = MInst->begin(),
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000172 OpE = MInst->end(); OpI != OpE; ++OpI)
Vikram S. Adve5f2180c2003-05-27 00:05:23 +0000173 if (OpI.isDefOnly() || OpI.isDefAndUse()) {
Chris Lattner30adeb62002-02-04 16:36:59 +0000174 const Value *Def = *OpI;
Chris Lattner133f0792002-10-28 04:45:29 +0000175 bool isCC = (OpI.getMachineOperand().getType()
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000176 == MachineOperand::MO_CCRegister);
Chris Lattner133f0792002-10-28 04:45:29 +0000177 createOrAddToLiveRange(Def, isCC);
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000178 }
Ruchira Sasankaa5ab9642001-09-30 23:11:59 +0000179
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000180 // iterate over implicit MI operands and create a new LR
181 // for each operand that is defined by the instruction
182 for (unsigned i = 0; i < MInst->getNumImplicitRefs(); ++i)
Vikram S. Adve5f2180c2003-05-27 00:05:23 +0000183 if (MInst->getImplicitOp(i).opIsDefOnly() ||
184 MInst->getImplicitOp(i).opIsDefAndUse()) {
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000185 const Value *Def = MInst->getImplicitRef(i);
Chris Lattner133f0792002-10-28 04:45:29 +0000186 createOrAddToLiveRange(Def, /*isCC*/ false);
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000187 }
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000188
189 } // for all machine instructions in the BB
190
Chris Lattner2fbfdcf2002-04-07 20:49:59 +0000191 } // for all BBs in function
Ruchira Sasankaa5ab9642001-09-30 23:11:59 +0000192
Ruchira Sasankaa90e7702001-10-15 16:26:38 +0000193 // Now we have to suggest clors for call and return arg live ranges.
194 // Also, if there are implicit defs (e.g., retun value of a call inst)
195 // they must be added to the live range list
Vikram S. Adve9d67cd12002-09-28 17:05:22 +0000196 //
Ruchira Sasankaa90e7702001-10-15 16:26:38 +0000197 suggestRegs4CallRets();
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000198
Vikram S. Adve39c94e12002-09-14 23:05:33 +0000199 if( DEBUG_RA >= RA_DEBUG_LiveRanges)
Chris Lattner697954c2002-01-20 22:54:45 +0000200 cerr << "Initial Live Ranges constructed!\n";
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000201}
202
203
Ruchira Sasanka4f3eb222002-01-07 19:19:18 +0000204//---------------------------------------------------------------------------
205// If some live ranges must be colored with specific hardware registers
206// (e.g., for outgoing call args), suggesting of colors for such live
Chris Lattner2fbfdcf2002-04-07 20:49:59 +0000207// ranges is done using target specific function. Those functions are called
Ruchira Sasanka4f3eb222002-01-07 19:19:18 +0000208// from this function. The target specific methods must:
209// 1) suggest colors for call and return args.
210// 2) create new LRs for implicit defs in machine instructions
211//---------------------------------------------------------------------------
Chris Lattner88da77c2002-10-29 17:03:19 +0000212void LiveRangeInfo::suggestRegs4CallRets() {
213 std::vector<MachineInstr*>::iterator It = CallRetInstrList.begin();
214 for( ; It != CallRetInstrList.end(); ++It) {
Vikram S. Advec9a0ca52002-07-08 23:07:26 +0000215 MachineInstr *MInst = *It;
Chris Lattner88da77c2002-10-29 17:03:19 +0000216 MachineOpCode OpCode = MInst->getOpCode();
Ruchira Sasankaa90e7702001-10-15 16:26:38 +0000217
Chris Lattner88da77c2002-10-29 17:03:19 +0000218 if ((TM.getInstrInfo()).isReturn(OpCode))
219 MRI.suggestReg4RetValue(MInst, *this);
220 else if ((TM.getInstrInfo()).isCall(OpCode))
221 MRI.suggestRegs4CallArgs(MInst, *this);
Ruchira Sasankaa90e7702001-10-15 16:26:38 +0000222 else
Chris Lattner88da77c2002-10-29 17:03:19 +0000223 assert( 0 && "Non call/ret instr in CallRetInstrList" );
Ruchira Sasankaa90e7702001-10-15 16:26:38 +0000224 }
Ruchira Sasankaa90e7702001-10-15 16:26:38 +0000225}
226
227
Ruchira Sasanka4f3eb222002-01-07 19:19:18 +0000228//--------------------------------------------------------------------------
229// The following method coalesces live ranges when possible. This method
230// must be called after the interference graph has been constructed.
Ruchira Sasankaa90e7702001-10-15 16:26:38 +0000231
232
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000233/* Algorithm:
Chris Lattner2fbfdcf2002-04-07 20:49:59 +0000234 for each BB in function
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000235 for each machine instruction (inst)
236 for each definition (def) in inst
237 for each operand (op) of inst that is a use
Ruchira Sasankaefaf9be2001-11-10 00:20:24 +0000238 if the def and op are of the same register type
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000239 if the def and op do not interfere //i.e., not simultaneously live
240 if (degree(LR of def) + degree(LR of op)) <= # avail regs
Ruchira Sasankaa5ab9642001-09-30 23:11:59 +0000241 if both LRs do not have suggested colors
242 merge2IGNodes(def, op) // i.e., merge 2 LRs
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000243
244*/
Ruchira Sasanka4f3eb222002-01-07 19:19:18 +0000245//---------------------------------------------------------------------------
246void LiveRangeInfo::coalesceLRs()
247{
Vikram S. Adve39c94e12002-09-14 23:05:33 +0000248 if(DEBUG_RA >= RA_DEBUG_LiveRanges)
249 cerr << "\nCoalescing LRs ...\n";
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000250
Chris Lattnerf726e772002-10-28 19:22:04 +0000251 MachineFunction &MF = MachineFunction::get(Meth);
252 for (MachineFunction::iterator BBI = MF.begin(); BBI != MF.end(); ++BBI) {
253 MachineBasicBlock &MBB = *BBI;
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000254
255 // iterate over all the machine instructions in BB
Chris Lattnerf726e772002-10-28 19:22:04 +0000256 for(MachineBasicBlock::iterator MII = MBB.begin(); MII != MBB.end(); ++MII){
257 const MachineInstr *MI = *MII;
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000258
Vikram S. Adve39c94e12002-09-14 23:05:33 +0000259 if( DEBUG_RA >= RA_DEBUG_LiveRanges) {
Chris Lattner697954c2002-01-20 22:54:45 +0000260 cerr << " *Iterating over machine instr ";
Chris Lattnerf726e772002-10-28 19:22:04 +0000261 MI->dump();
Chris Lattner697954c2002-01-20 22:54:45 +0000262 cerr << "\n";
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000263 }
264
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000265 // iterate over MI operands to find defs
Chris Lattnerf726e772002-10-28 19:22:04 +0000266 for(MachineInstr::const_val_op_iterator DefI = MI->begin(),
267 DefE = MI->end(); DefI != DefE; ++DefI) {
Vikram S. Adve5f2180c2003-05-27 00:05:23 +0000268 if (DefI.isDefOnly() || DefI.isDefAndUse()) { // this operand is modified
Chris Lattner2f898d22002-02-05 06:02:59 +0000269 LiveRange *LROfDef = getLiveRangeForValue( *DefI );
270 RegClass *RCOfDef = LROfDef->getRegClass();
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000271
Chris Lattnerf726e772002-10-28 19:22:04 +0000272 MachineInstr::const_val_op_iterator UseI = MI->begin(),
273 UseE = MI->end();
274 for( ; UseI != UseE; ++UseI) { // for all uses
Chris Lattner2f898d22002-02-05 06:02:59 +0000275 LiveRange *LROfUse = getLiveRangeForValue( *UseI );
276 if (!LROfUse) { // if LR of use is not found
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000277 //don't warn about labels
Vikram S. Adve39c94e12002-09-14 23:05:33 +0000278 if (!isa<BasicBlock>(*UseI) && DEBUG_RA >= RA_DEBUG_LiveRanges)
Chris Lattner0665a5f2002-02-05 01:43:49 +0000279 cerr << " !! Warning: No LR for use " << RAV(*UseI) << "\n";
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000280 continue; // ignore and continue
281 }
282
Chris Lattner2f898d22002-02-05 06:02:59 +0000283 if (LROfUse == LROfDef) // nothing to merge if they are same
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000284 continue;
285
Chris Lattner37730942002-02-05 03:52:29 +0000286 if (MRI.getRegType(LROfDef) == MRI.getRegType(LROfUse)) {
Ruchira Sasankaefaf9be2001-11-10 00:20:24 +0000287 // If the two RegTypes are the same
Chris Lattner37730942002-02-05 03:52:29 +0000288 if (!RCOfDef->getInterference(LROfDef, LROfUse) ) {
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000289
290 unsigned CombinedDegree =
291 LROfDef->getUserIGNode()->getNumOfNeighbors() +
292 LROfUse->getUserIGNode()->getNumOfNeighbors();
293
Vikram S. Adve32f81a32002-09-20 00:45:47 +0000294 if (CombinedDegree > RCOfDef->getNumOfAvailRegs()) {
295 // get more precise estimate of combined degree
296 CombinedDegree = LROfDef->getUserIGNode()->
297 getCombinedDegree(LROfUse->getUserIGNode());
298 }
299
Chris Lattner37730942002-02-05 03:52:29 +0000300 if (CombinedDegree <= RCOfDef->getNumOfAvailRegs()) {
Ruchira Sasankaa5ab9642001-09-30 23:11:59 +0000301 // if both LRs do not have suggested colors
Chris Lattner37730942002-02-05 03:52:29 +0000302 if (!(LROfDef->hasSuggestedColor() &&
303 LROfUse->hasSuggestedColor())) {
Ruchira Sasankaa5ab9642001-09-30 23:11:59 +0000304
305 RCOfDef->mergeIGNodesOfLRs(LROfDef, LROfUse);
306 unionAndUpdateLRs(LROfDef, LROfUse);
307 }
308
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000309 } // if combined degree is less than # of regs
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000310 } // if def and use do not interfere
Ruchira Sasankad33238b2001-10-12 17:48:18 +0000311 }// if reg classes are the same
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000312 } // for all uses
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000313 } // if def
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000314 } // for all defs
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000315 } // for all machine instructions
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000316 } // for all BBs
317
Vikram S. Adve39c94e12002-09-14 23:05:33 +0000318 if (DEBUG_RA >= RA_DEBUG_LiveRanges)
319 cerr << "\nCoalescing Done!\n";
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000320}
321
322
323
324
325
326/*--------------------------- Debug code for printing ---------------*/
327
328
Chris Lattner0665a5f2002-02-05 01:43:49 +0000329void LiveRangeInfo::printLiveRanges() {
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000330 LiveRangeMapType::iterator HMI = LiveRangeMap.begin(); // hash map iterator
Chris Lattner697954c2002-01-20 22:54:45 +0000331 cerr << "\nPrinting Live Ranges from Hash Map:\n";
Chris Lattner0665a5f2002-02-05 01:43:49 +0000332 for( ; HMI != LiveRangeMap.end(); ++HMI) {
333 if (HMI->first && HMI->second) {
Vikram S. Adve39c94e12002-09-14 23:05:33 +0000334 cerr << " Value* " << RAV(HMI->first) << "\t: ";
Vikram S. Adve32f81a32002-09-20 00:45:47 +0000335 if (IGNode* igNode = HMI->second->getUserIGNode())
336 cerr << "LR# " << igNode->getIndex();
337 else
338 cerr << "LR# " << "<no-IGNode>";
Vikram S. Adve39c94e12002-09-14 23:05:33 +0000339 cerr << "\t:Values = "; printSet(*HMI->second); cerr << "\n";
Ruchira Sasanka8e604792001-09-14 21:18:34 +0000340 }
341 }
342}