lib/Target/SparcV9/SparcV9RegInfo.cpp

   1 #include "llvm/Target/Sparc.h"
   2 #include "SparcInternals.h"
   3 #include "llvm/Method.h"
   4 #include "llvm/iTerminators.h"
   5 #include "llvm/iOther.h"
   6 #include "llvm/CodeGen/InstrScheduling.h"
   7 #include "llvm/CodeGen/InstrSelection.h"
   8
   9 #include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h"
  10 #include "llvm/CodeGen/PhyRegAlloc.h"
  11
  12
  13
  14
  15 //---------------------------------------------------------------------------
  16 // UltraSparcRegInfo
  17 //---------------------------------------------------------------------------
  18
  19 //---------------------------------------------------------------------------
  20 // Finds the return value of a call instruction
  21 //---------------------------------------------------------------------------
  22
  23 const Value *
  24 UltraSparcRegInfo::getCallInstRetVal(const MachineInstr *CallMI) const{
  25
  26   unsigned OpCode = CallMI->getOpCode();
  27   unsigned NumOfImpRefs =  CallMI->getNumImplicitRefs();
  28
  29   if( OpCode == CALL ) {
  30
  31     // The one before the last implicit operand is the return value of
  32     // a CALL instr
  33     if( NumOfImpRefs > 1 )
  34       if(  CallMI->implicitRefIsDefined(NumOfImpRefs-2) )
  35         return  CallMI->getImplicitRef(NumOfImpRefs-2);
  36
  37   }
  38   else if( OpCode == JMPLCALL) {
  39
  40     // The last implicit operand is the return value of a JMPL in
  41     if( NumOfImpRefs > 0 )
  42       if(  CallMI->implicitRefIsDefined(NumOfImpRefs-1) )
  43         return  CallMI->getImplicitRef(NumOfImpRefs-1);
  44   }
  45   else
  46     assert(0 && "OpCode must be CALL/JMPL for a call instr");
  47
  48   return NULL;
  49
  50 }
  51
  52 //---------------------------------------------------------------------------
  53 // Finds the return address of a call instruction
  54 //---------------------------------------------------------------------------
  55
  56 const Value *
  57 UltraSparcRegInfo::getCallInstRetAddr(const MachineInstr *CallMI)const {
  58
  59   unsigned OpCode = CallMI->getOpCode();
  60
  61   if( OpCode == CALL) {
  62
  63     unsigned NumOfImpRefs =  CallMI->getNumImplicitRefs();
  64
  65     assert( NumOfImpRefs && "CALL instr must have at least on ImpRef");
  66     // The last implicit operand is the return address of a CALL instr
  67     return  CallMI->getImplicitRef(NumOfImpRefs-1);
  68
  69   }
  70   else if( OpCode == JMPLCALL ) {
  71
  72     MachineOperand & MO  = ( MachineOperand &) CallMI->getOperand(2);
  73     return MO.getVRegValue();
  74
  75   }
  76   else
  77     assert(0 && "OpCode must be CALL/JMPL for a call instr");
  78
  79   assert(0  && "There must be a return addr for a call instr");
  80
  81   return NULL;
  82
  83 }
  84
  85
  86 //---------------------------------------------------------------------------
  87 // Finds the # of actual arguments of the call instruction
  88 //---------------------------------------------------------------------------
  89
  90 const unsigned
  91 UltraSparcRegInfo::getCallInstNumArgs(const MachineInstr *CallMI) const {
  92
  93   unsigned OpCode = CallMI->getOpCode();
  94   unsigned NumOfImpRefs =  CallMI->getNumImplicitRefs();
  95   int NumArgs = -1;
  96
  97   if( OpCode == CALL ) {
  98
  99     switch( NumOfImpRefs ) {
 100
 101     case 0: assert(0 && "A CALL inst must have at least one ImpRef (RetAddr)");
 102
 103     case 1: NumArgs = 0;
 104             break;
 105
 106     default:  // two or more implicit refs
 107       if(  CallMI->implicitRefIsDefined(NumOfImpRefs-2) )
 108         NumArgs = NumOfImpRefs - 2;    // i.e., NumOfImpRef-2 is the ret val
 109       else
 110         NumArgs = NumOfImpRefs - 1;
 111     }
 112
 113   }
 114   else if( OpCode == JMPLCALL ) {
 115
 116     // The last implicit operand is the return value of a JMPL instr
 117     if( NumOfImpRefs > 0 ) {
 118       if(  CallMI->implicitRefIsDefined(NumOfImpRefs-1) )
 119         NumArgs = NumOfImpRefs - 1;    // i.e., NumOfImpRef-1 is the ret val
 120       else
 121         NumArgs = NumOfImpRefs;
 122     }
 123     else
 124       NumArgs = NumOfImpRefs;
 125   }
 126   else
 127     assert(0 && "OpCode must be CALL/JMPL for a call instr");
 128
 129   assert( (NumArgs != -1)  && "Internal error in getCallInstNumArgs" );
 130   return (unsigned) NumArgs;
 131
 132
 133 }
 134
 135
 136 //---------------------------------------------------------------------------
 137 // Suggests a register for the ret address in the RET machine instruction
 138 //---------------------------------------------------------------------------
 139
 140 void UltraSparcRegInfo::suggestReg4RetAddr(const MachineInstr * RetMI,
 141                                            LiveRangeInfo& LRI) const {
 142
 143   assert( (RetMI->getNumOperands() >= 2)
 144           && "JMPL/RETURN must have 3 and 2 operands respectively");
 145
 146   MachineOperand & MO  = ( MachineOperand &) RetMI->getOperand(0);
 147
 148   MO.setRegForValue( getUnifiedRegNum( IntRegClassID, SparcIntRegOrder::i7) );
 149
 150   // TODO (Optimize):
 151   // Instead of setting the color, we can suggest one. In that case,
 152   // we have to test later whether it received the suggested color.
 153   // In that case, a LR has to be created at the start of method.
 154   // It has to be done as follows (remove the setRegVal above):
 155
 156   /*
 157   const Value *RetAddrVal = MO.getVRegValue();
 158
 159   assert( RetAddrVal && "LR for ret address must be created at start");
 160
 161   LiveRange * RetAddrLR = LRI.getLiveRangeForValue( RetAddrVal);
 162   RetAddrLR->setSuggestedColor(getUnifiedRegNum( IntRegClassID,
 163   SparcIntRegOrdr::i7) );
 164   */
 165
 166
 167 }
 168
 169
 170 //---------------------------------------------------------------------------
 171 // Suggests a register for the ret address in the JMPL/CALL machine instr
 172 //---------------------------------------------------------------------------
 173 void UltraSparcRegInfo::suggestReg4CallAddr(const MachineInstr * CallMI,
 174                                             LiveRangeInfo& LRI,
 175                                             vector<RegClass *> RCList) const {
 176
 177
 178   const Value *RetAddrVal = getCallInstRetAddr( CallMI );
 179
 180   // RetAddrVal cannot be NULL (asserted in  getCallInstRetAddr)
 181   // create a new LR for the return address and color it
 182
 183   LiveRange * RetAddrLR = new LiveRange();
 184   RetAddrLR->add( RetAddrVal );
 185   unsigned RegClassID = getRegClassIDOfValue( RetAddrVal );
 186   RetAddrLR->setRegClass( RCList[RegClassID] );
 187   RetAddrLR->setColor(getUnifiedRegNum(IntRegClassID,SparcIntRegOrder::o7));
 188   LRI.addLRToMap( RetAddrVal, RetAddrLR);
 189
 190
 191   /*
 192   assert( (CallMI->getNumOperands() == 3) && "JMPL must have 3 operands");
 193
 194   // directly set color since the LR of ret address (if there were one)
 195   // will not extend after the call instr
 196
 197   MachineOperand & MO  = ( MachineOperand &) CallMI->getOperand(2);
 198   MO.setRegForValue( getUnifiedRegNum( IntRegClassID,SparcIntRegOrder::o7) );
 199
 200   */
 201
 202 }
 203
 204
 205
 206
 207 //---------------------------------------------------------------------------
 208 //  This method will suggest colors to incoming args to a method.
 209 //  If the arg is passed on stack due to the lack of regs, NOTHING will be
 210 //  done - it will be colored (or spilled) as a normal value.
 211 //---------------------------------------------------------------------------
 212
 213 void UltraSparcRegInfo::suggestRegs4MethodArgs(const Method *const Meth,
 214                                                LiveRangeInfo& LRI) const
 215 {
 216
 217                                                  // get the argument list
 218   const Method::ArgumentListType& ArgList = Meth->getArgumentList();
 219                                                  // get an iterator to arg list
 220   Method::ArgumentListType::const_iterator ArgIt = ArgList.begin();
 221
 222   // for each argument
 223   for( unsigned argNo=0; ArgIt != ArgList.end() ; ++ArgIt, ++argNo) {
 224
 225     // get the LR of arg
 226     LiveRange *const LR = LRI.getLiveRangeForValue((const Value *) *ArgIt);
 227     assert( LR && "No live range found for method arg");
 228
 229     unsigned RegType = getRegType( LR );
 230
 231
 232     // if the arg is in int class - allocate a reg for an int arg
 233     if( RegType == IntRegType ) {
 234
 235       if( argNo < NumOfIntArgRegs) {
 236         LR->setSuggestedColor( SparcIntRegOrder::i0 + argNo );
 237
 238       }
 239
 240       else {
 241         // Do NOTHING as this will be colored as a normal value.
 242         if (DEBUG_RA) cerr << " Int Regr not suggested for method arg\n";
 243       }
 244
 245     }
 246     else if( RegType==FPSingleRegType && (argNo*2+1) < NumOfFloatArgRegs)
 247       LR->setSuggestedColor( SparcFloatRegOrder::f0 + (argNo * 2 + 1) );
 248
 249
 250     else if( RegType == FPDoubleRegType && (argNo*2) < NumOfFloatArgRegs)
 251       LR->setSuggestedColor( SparcFloatRegOrder::f0 + (argNo * 2) );
 252
 253
 254   }
 255
 256 }
 257
 258 //---------------------------------------------------------------------------
 259 //
 260 //---------------------------------------------------------------------------
 261
 262 void UltraSparcRegInfo::colorMethodArgs(const Method *const Meth,
 263                                         LiveRangeInfo& LRI,
 264                                         AddedInstrns *const FirstAI) const {
 265
 266                                                  // get the argument list
 267   const Method::ArgumentListType& ArgList = Meth->getArgumentList();
 268                                                  // get an iterator to arg list
 269   Method::ArgumentListType::const_iterator ArgIt = ArgList.begin();
 270
 271   MachineInstr *AdMI;
 272
 273
 274   // for each argument
 275   for( unsigned argNo=0; ArgIt != ArgList.end() ; ++ArgIt, ++argNo) {
 276
 277     // get the LR of arg
 278     LiveRange *const LR = LRI.getLiveRangeForValue((const Value *) *ArgIt);
 279     assert( LR && "No live range found for method arg");
 280
 281
 282     unsigned RegType = getRegType( LR );
 283     unsigned RegClassID = (LR->getRegClass())->getID();
 284
 285
 286     // find whether this argument is coming in a register (if not, on stack)
 287
 288     bool isArgInReg = false;
 289     unsigned UniArgReg = InvalidRegNum;  // reg that LR MUST be colored with
 290
 291     if( (RegType== IntRegType && argNo <  NumOfIntArgRegs)) {
 292       isArgInReg = true;
 293       UniArgReg = getUnifiedRegNum( RegClassID, SparcIntRegOrder::i0 + argNo );
 294     }
 295     else if(RegType == FPSingleRegType && argNo < NumOfFloatArgRegs)  {
 296       isArgInReg = true;
 297       UniArgReg = getUnifiedRegNum( RegClassID,
 298                                     SparcFloatRegOrder::f0 + argNo*2 + 1 ) ;
 299     }
 300     else if(RegType == FPDoubleRegType && argNo < NumOfFloatArgRegs)  {
 301       isArgInReg = true;
 302       UniArgReg = getUnifiedRegNum(RegClassID, SparcFloatRegOrder::f0+argNo*2);
 303     }
 304
 305
 306     if( LR->hasColor() ) {
 307
 308       unsigned UniLRReg = getUnifiedRegNum(  RegClassID, LR->getColor() );
 309
 310       // if LR received the correct color, nothing to do
 311       if( UniLRReg == UniArgReg )
 312         continue;
 313
 314       // We are here because the LR did not have a suggested
 315       // color or did not receive the suggested color but LR got a register.
 316       // Now we have to copy %ix reg (or stack pos of arg)
 317       // to the register it was colored with.
 318
 319       // if the arg is coming in UniArgReg register MUST go into
 320       // the UniLRReg register
 321       if( isArgInReg )
 322         AdMI = cpReg2RegMI( UniArgReg, UniLRReg, RegType );
 323
 324       else {
 325
 326         // Now the arg is coming on stack. Since the LR recieved a register,
 327         // we just have to load the arg on stack into that register
 328         const MachineFrameInfo& frameInfo = target.getFrameInfo();
 329         assert(frameInfo.argsOnStackHaveFixedSize());
 330
 331         bool growUp;
 332         int firstArg =
 333           frameInfo.getFirstIncomingArgOffset(MachineCodeForMethod::get(Meth), growUp);
 334         int offsetFromFP =
 335           growUp? firstArg + argNo * frameInfo.getSizeOfEachArgOnStack()
 336                 : firstArg - argNo * frameInfo.getSizeOfEachArgOnStack();
 337
 338         AdMI = cpMem2RegMI(getFramePointer(), offsetFromFP,
 339                            UniLRReg, RegType );
 340       }
 341
 342       FirstAI->InstrnsBefore.push_back( AdMI );
 343
 344     } // if LR received a color
 345
 346     else {
 347
 348       // Now, the LR did not receive a color. But it has a stack offset for
 349       // spilling.
 350
 351       // So, if the arg is coming in UniArgReg register,  we can just move
 352       // that on to the stack pos of LR
 353
 354
 355       if( isArgInReg ) {
 356
 357         MachineInstr *AdIBef =
 358           cpReg2MemMI(UniArgReg, getFramePointer(),
 359                       LR->getSpillOffFromFP(), RegType );
 360
 361         FirstAI->InstrnsBefore.push_back( AdMI );
 362       }
 363
 364       else {
 365
 366         // Now the arg is coming on stack. Since the LR did NOT
 367         // recieved a register as well, it is allocated a stack position. We
 368         // can simply change the stack poistion of the LR. We can do this,
 369         // since this method is called before any other method that makes
 370         // uses of the stack pos of the LR (e.g., updateMachineInstr)
 371
 372         const MachineFrameInfo& frameInfo = target.getFrameInfo();
 373         assert(frameInfo.argsOnStackHaveFixedSize());
 374
 375         bool growUp;
 376         int firstArg = frameInfo.getFirstIncomingArgOffset(MachineCodeForMethod::get(Meth), growUp);
 377         int offsetFromFP =
 378           growUp? firstArg + argNo * frameInfo.getSizeOfEachArgOnStack()
 379                 : firstArg - argNo * frameInfo.getSizeOfEachArgOnStack();
 380
 381         LR->modifySpillOffFromFP( offsetFromFP );
 382       }
 383
 384     }
 385
 386   }  // for each incoming argument
 387
 388 }
 389
 390
 391
 392
 393 //---------------------------------------------------------------------------
 394 // This method is called before graph coloring to suggest colors to the
 395 // outgoing call args and the return value of the call.
 396 //---------------------------------------------------------------------------
 397 void UltraSparcRegInfo::suggestRegs4CallArgs(const MachineInstr *const CallMI,
 398                                              LiveRangeInfo& LRI,
 399                                              vector<RegClass *> RCList) const {
 400
 401   assert ( (UltraSparcInfo->getInstrInfo()).isCall(CallMI->getOpCode()) );
 402
 403   suggestReg4CallAddr(CallMI, LRI, RCList);
 404
 405
 406   // First color the return value of the call instruction. The return value
 407   // will be in %o0 if the value is an integer type, or in %f0 if the
 408   // value is a float type.
 409
 410   // the return value cannot have a LR in machine instruction since it is
 411   // only defined by the call instruction
 412
 413   // if type is not void,  create a new live range and set its
 414   // register class and add to LRI
 415
 416
 417   const Value *RetVal = getCallInstRetVal( CallMI );
 418
 419
 420   if( RetVal ) {
 421
 422     assert( (! LRI.getLiveRangeForValue( RetVal ) ) &&
 423             "LR for ret Value of call already definded!");
 424
 425
 426       // create a new LR for the return value
 427
 428     LiveRange * RetValLR = new LiveRange();
 429     RetValLR->add( RetVal );
 430     unsigned RegClassID = getRegClassIDOfValue( RetVal );
 431     RetValLR->setRegClass( RCList[RegClassID] );
 432     LRI.addLRToMap( RetVal, RetValLR);
 433
 434     // now suggest a register depending on the register class of ret arg
 435
 436     if( RegClassID == IntRegClassID )
 437       RetValLR->setSuggestedColor(SparcIntRegOrder::o0);
 438     else if (RegClassID == FloatRegClassID )
 439       RetValLR->setSuggestedColor(SparcFloatRegOrder::f0 );
 440     else assert( 0 && "Unknown reg class for return value of call\n");
 441
 442   }
 443
 444
 445   // Now suggest colors for arguments (operands) of the call instruction.
 446   // Colors are suggested only if the arg number is smaller than the
 447   // the number of registers allocated for argument passing.
 448   // Now, go thru call args - implicit operands of the call MI
 449
 450   unsigned NumOfCallArgs =  getCallInstNumArgs( CallMI );
 451
 452   for(unsigned argNo=0, i=0; i < NumOfCallArgs; ++i, ++argNo ) {
 453
 454     const Value *CallArg = CallMI->getImplicitRef(i);
 455
 456     // get the LR of call operand (parameter)
 457     LiveRange *const LR = LRI.getLiveRangeForValue(CallArg);
 458
 459     // not possible to have a null LR since all args (even consts)
 460     // must be defined before
 461     if( !LR ) {
 462       if( DEBUG_RA) {
 463         cerr << " ERROR: In call instr, no LR for arg:  " ;
 464         printValue(CallArg); cerr << endl;
 465       }
 466       assert(0 && "NO LR for call arg");
 467       // continue;
 468     }
 469
 470     unsigned RegType = getRegType( LR );
 471
 472     // if the arg is in int class - allocate a reg for an int arg
 473     if( RegType == IntRegType ) {
 474
 475       if( argNo < NumOfIntArgRegs)
 476         LR->setSuggestedColor( SparcIntRegOrder::o0 + argNo );
 477
 478       else if (DEBUG_RA)
 479         // Do NOTHING as this will be colored as a normal value.
 480         cerr << " Regr not suggested for int call arg" << endl;
 481
 482     }
 483     else if( RegType == FPSingleRegType &&  (argNo*2 +1)< NumOfFloatArgRegs)
 484       LR->setSuggestedColor( SparcFloatRegOrder::f0 + (argNo * 2 + 1) );
 485
 486
 487     else if( RegType == FPDoubleRegType && (argNo*2) < NumOfFloatArgRegs)
 488       LR->setSuggestedColor( SparcFloatRegOrder::f0 + (argNo * 2) );
 489
 490
 491   } // for all call arguments
 492
 493 }
 494
 495
 496 //---------------------------------------------------------------------------
 497 // After graph coloring, we have call this method to see whehter the return
 498 // value and the call args received the correct colors. If not, we have
 499 // to instert copy instructions.
 500 //---------------------------------------------------------------------------
 501
 502 void UltraSparcRegInfo::colorCallArgs(const MachineInstr *const CallMI,
 503                                       LiveRangeInfo& LRI,
 504                                       AddedInstrns *const CallAI,
 505                                       PhyRegAlloc &PRA) const {
 506
 507   assert ( (UltraSparcInfo->getInstrInfo()).isCall(CallMI->getOpCode()) );
 508
 509   // Reset the optional args area in the stack frame
 510   // since that is reused for each call
 511   //
 512   PRA.mcInfo.resetOptionalArgs(target);
 513
 514   // First color the return value of the call.
 515   // If there is a LR for the return value, it means this
 516   // method returns a value
 517
 518   MachineInstr *AdMI;
 519
 520   const Value *RetVal = getCallInstRetVal( CallMI );
 521
 522   if( RetVal ) {
 523
 524     LiveRange * RetValLR = LRI.getLiveRangeForValue( RetVal );
 525
 526     if( !RetValLR ) {
 527       cerr << "\nNo LR for:";
 528       printValue( RetVal );
 529       cerr << endl;
 530       assert( RetValLR && "ERR:No LR for non-void return value");
 531       //return;
 532     }
 533
 534     unsigned RegClassID = (RetValLR->getRegClass())->getID();
 535     bool recvCorrectColor = false;
 536
 537     unsigned CorrectCol;                // correct color for ret value
 538     if(RegClassID == IntRegClassID)
 539       CorrectCol = SparcIntRegOrder::o0;
 540     else if(RegClassID == FloatRegClassID)
 541       CorrectCol = SparcFloatRegOrder::f0;
 542     else {
 543       assert( 0 && "Unknown RegClass");
 544       return;
 545     }
 546
 547     // if the LR received the correct color, NOTHING to do
 548
 549     if(  RetValLR->hasColor() )
 550       if( RetValLR->getColor() == CorrectCol )
 551         recvCorrectColor = true;
 552
 553
 554     // if we didn't receive the correct color for some reason,
 555     // put copy instruction
 556
 557     if( !recvCorrectColor ) {
 558
 559       unsigned RegType = getRegType( RetValLR );
 560
 561       // the  reg that LR must be colored with
 562       unsigned UniRetReg = getUnifiedRegNum( RegClassID, CorrectCol);
 563
 564       if( RetValLR->hasColor() ) {
 565
 566         unsigned
 567           UniRetLRReg=getUnifiedRegNum(RegClassID,RetValLR->getColor());
 568
 569         // the return value is coming in UniRetReg but has to go into
 570         // the UniRetLRReg
 571
 572         AdMI = cpReg2RegMI( UniRetReg, UniRetLRReg, RegType );
 573
 574       } // if LR has color
 575       else {
 576
 577         // if the LR did NOT receive a color, we have to move the return
 578         // value coming in UniRetReg to the stack pos of spilled LR
 579
 580         AdMI =  cpReg2MemMI(UniRetReg, getFramePointer(),
 581                             RetValLR->getSpillOffFromFP(), RegType );
 582       }
 583
 584       CallAI->InstrnsAfter.push_back( AdMI );
 585
 586     } // the LR didn't receive the suggested color
 587
 588   } // if there a return value
 589
 590
 591   // Now color all args of the call instruction
 592
 593   vector <MachineInstr *> AddedInstrnsBefore;
 594
 595   unsigned NumOfCallArgs =  getCallInstNumArgs( CallMI );
 596
 597   for(unsigned argNo=0, i=0; i < NumOfCallArgs; ++i, ++argNo ) {
 598
 599     const Value *CallArg = CallMI->getImplicitRef(i);
 600
 601     // get the LR of call operand (parameter)
 602     LiveRange *const LR = LRI.getLiveRangeForValue(CallArg);
 603
 604     unsigned RegType = getRegType( CallArg );
 605     unsigned RegClassID =  getRegClassIDOfValue( CallArg);
 606
 607     // find whether this argument is coming in a register (if not, on stack)
 608
 609     bool isArgInReg = false;
 610     unsigned UniArgReg = InvalidRegNum;  // reg that LR must be colored with
 611
 612     if( (RegType== IntRegType && argNo <  NumOfIntArgRegs)) {
 613       isArgInReg = true;
 614       UniArgReg = getUnifiedRegNum(RegClassID, SparcIntRegOrder::o0 + argNo );
 615     }
 616     else if(RegType == FPSingleRegType && argNo < NumOfFloatArgRegs)  {
 617       isArgInReg = true;
 618       UniArgReg = getUnifiedRegNum(RegClassID,
 619                                    SparcFloatRegOrder::f0 + (argNo*2 + 1) );
 620     }
 621     else if(RegType == FPDoubleRegType && argNo < NumOfFloatArgRegs)  {
 622       isArgInReg = true;
 623       UniArgReg = getUnifiedRegNum(RegClassID, SparcFloatRegOrder::f0+argNo*2);
 624     }
 625
 626
 627     // not possible to have a null LR since all args (even consts)
 628     // must be defined before
 629     if( !LR ) {
 630       if( DEBUG_RA) {
 631         cerr << " ERROR: In call instr, no LR for arg:  " ;
 632         printValue(CallArg); cerr << endl;
 633       }
 634       assert(0 && "NO LR for call arg");
 635       // continue;
 636     }
 637
 638
 639     // if the LR received the suggested color, NOTHING to do
 640
 641
 642     if( LR->hasColor() ) {
 643
 644
 645       unsigned UniLRReg = getUnifiedRegNum( RegClassID,  LR->getColor() );
 646
 647       // if LR received the correct color, nothing to do
 648       if( UniLRReg == UniArgReg )
 649         continue;
 650
 651       // We are here because though the LR is allocated a register, it
 652       // was not allocated the suggested register. So, we have to copy %ix reg
 653       // (or stack pos of arg) to the register it was colored with
 654
 655       // the LR is colored with UniLRReg but has to go into  UniArgReg
 656       // to pass it as an argument
 657
 658       if( isArgInReg ) {
 659         AdMI = cpReg2RegMI(UniLRReg, UniArgReg, RegType );
 660         AddedInstrnsBefore.push_back( AdMI );
 661       }
 662
 663       else {
 664         // Now, we have to pass the arg on stack. Since LR received a register
 665         // we just have to move that register to the stack position where
 666         // the argument must be passed
 667
 668         int argOffset = PRA.mcInfo.allocateOptionalArg(target, LR->getType());
 669
 670         AdMI = cpReg2MemMI(UniLRReg, getStackPointer(), argOffset, RegType );
 671
 672         // Now add the instruction. We can directly add to
 673         // CallAI->InstrnsBefore since we are just saving a reg on stack
 674         //
 675         CallAI->InstrnsBefore.push_back( AdMI );
 676
 677         //cerr << "\nCaution: Passing a reg on stack";
 678       }
 679
 680
 681     }
 682
 683     else {                          // LR is not colored (i.e., spilled)
 684
 685       if( isArgInReg ) {
 686
 687         // Now the LR did NOT recieve a register but has a stack poistion.
 688         // Since, the outgoing arg goes in a register we just have to insert
 689         // a load instruction to load the LR to outgoing register
 690
 691
 692         AdMI = cpMem2RegMI(getFramePointer(), LR->getSpillOffFromFP(),
 693                            UniArgReg, RegType );
 694
 695         cerr << "\nCaution: Loading a spilled val to a reg as a call arg";
 696         AddedInstrnsBefore.push_back( AdMI );  // Now add the instruction
 697       }
 698
 699       else {
 700         // Now, we have to pass the arg on stack. Since LR  also did NOT
 701         // receive a register we have to move an argument in memory to
 702         // outgoing parameter on stack.
 703
 704         // Optoimize: Optimize when reverse pointers in MahineInstr are
 705         // introduced.
 706         // call PRA.getUnusedRegAtMI(....) to get an unused reg. Only if this
 707         // fails, then use the following code. Currently, we cannot call the
 708         // above method since we cannot find LVSetBefore without the BB
 709
 710         int TReg = PRA.getUniRegNotUsedByThisInst( LR->getRegClass(), CallMI );
 711
 712     /**** NOTE: THIS SHOULD USE THE RIGHT SIZE FOR THE REG BEING PUSHED ****/
 713         int TmpOff = PRA.mcInfo.pushTempValue(target, 8);
 714                           // target.findOptimalStorageSize(LR->getType()));
 715
 716         int argOffset = PRA.mcInfo.allocateOptionalArg(target, LR->getType());
 717
 718         MachineInstr *Ad1, *Ad2, *Ad3, *Ad4;
 719
 720         // Sequence:
 721         // (1) Save TReg on stack
 722         // (2) Load LR value into TReg from stack pos of LR
 723         // (3) Store Treg on outgoing Arg pos on stack
 724         // (4) Load the old value of TReg from stack to TReg (restore it)
 725
 726         Ad1 = cpReg2MemMI(TReg, getFramePointer(), TmpOff, RegType );
 727         Ad2 = cpMem2RegMI(getFramePointer(), LR->getSpillOffFromFP(),
 728                           TReg, RegType );
 729         Ad3 = cpReg2MemMI(TReg, getStackPointer(), argOffset, RegType );
 730         Ad4 = cpMem2RegMI(getFramePointer(), TmpOff, TReg, RegType );
 731
 732         // We directly add to CallAI->InstrnsBefore instead of adding to
 733         // AddedInstrnsBefore since these instructions must not be
 734         // reordered.
 735
 736         CallAI->InstrnsBefore.push_back( Ad1 );
 737         CallAI->InstrnsBefore.push_back( Ad2 );
 738         CallAI->InstrnsBefore.push_back( Ad3 );
 739         CallAI->InstrnsBefore.push_back( Ad4 );
 740
 741         cerr << "\nCaution: Call arg moved from stack2stack for: " << *CallMI ;
 742       }
 743
 744     }
 745
 746   }  // for each parameter in call instruction
 747
 748
 749   // if we added any instruction before the call instruction, verify
 750   // that they are in the proper order and if not, reorder them
 751
 752   if( ! AddedInstrnsBefore.empty() ) {
 753
 754     if( DEBUG_RA  ) {
 755       cerr << "\nCalling reorder with instrns: \n";
 756       for(unsigned i=0; i < AddedInstrnsBefore.size(); i++)
 757         cerr  << *(AddedInstrnsBefore[i]);
 758     }
 759
 760     vector <MachineInstr *> TmpVec;
 761     OrderAddedInstrns(AddedInstrnsBefore, TmpVec, PRA);
 762
 763     if( DEBUG_RA   ) {
 764       cerr << "\nAfter reordering instrns: \n";
 765       for(unsigned i=0; i < TmpVec.size(); i++)
 766         cerr << *(TmpVec[i]);
 767     }
 768
 769     // copy the results back from TmpVec to InstrnsBefore
 770     for(unsigned i=0; i < TmpVec.size(); i++)
 771       CallAI->InstrnsBefore.push_back( TmpVec[i] );
 772   }
 773
 774
 775   // Reset optional args area again to be safe
 776   PRA.mcInfo.resetOptionalArgs(target);
 777
 778
 779 }
 780
 781 //---------------------------------------------------------------------------
 782 // This method is called for an LLVM return instruction to identify which
 783 // values will be returned from this method and to suggest colors.
 784 //---------------------------------------------------------------------------
 785 void UltraSparcRegInfo::suggestReg4RetValue(const MachineInstr *const RetMI,
 786                                              LiveRangeInfo& LRI) const {
 787
 788   assert( (UltraSparcInfo->getInstrInfo()).isReturn( RetMI->getOpCode() ) );
 789
 790     suggestReg4RetAddr(RetMI, LRI);
 791
 792   // if there is an implicit ref, that has to be the ret value
 793   if(  RetMI->getNumImplicitRefs() > 0 ) {
 794
 795     // The first implicit operand is the return value of a return instr
 796     const Value *RetVal =  RetMI->getImplicitRef(0);
 797
 798     MachineInstr *AdMI;
 799     LiveRange *const LR = LRI.getLiveRangeForValue( RetVal );
 800
 801     if( !LR ) {
 802      cerr << "\nNo LR for:";
 803      printValue( RetVal );
 804      cerr << endl;
 805      assert( LR && "No LR for return value of non-void method");
 806      //return;
 807    }
 808
 809     unsigned RegClassID = (LR->getRegClass())->getID();
 810
 811     if( RegClassID == IntRegClassID )
 812       LR->setSuggestedColor(SparcIntRegOrder::i0);
 813
 814     else if ( RegClassID == FloatRegClassID )
 815       LR->setSuggestedColor(SparcFloatRegOrder::f0);
 816
 817   }
 818
 819 }
 820
 821
 822
 823 //---------------------------------------------------------------------------
 824 // Colors the return value of a method to %i0 or %f0, if possible. If it is
 825 // not possilbe to directly color the LR, insert a copy instruction to move
 826 // the LR to %i0 or %f0. When the LR is spilled, instead of the copy, we
 827 // have to put a load instruction.
 828 //---------------------------------------------------------------------------
 829 void UltraSparcRegInfo::colorRetValue(const  MachineInstr *const RetMI,
 830                                       LiveRangeInfo& LRI,
 831                                       AddedInstrns *const RetAI) const {
 832
 833   assert( (UltraSparcInfo->getInstrInfo()).isReturn( RetMI->getOpCode() ) );
 834
 835   // if there is an implicit ref, that has to be the ret value
 836   if(  RetMI->getNumImplicitRefs() > 0 ) {
 837
 838     // The first implicit operand is the return value of a return instr
 839     const Value *RetVal =  RetMI->getImplicitRef(0);
 840
 841     MachineInstr *AdMI;
 842     LiveRange *const LR = LRI.getLiveRangeForValue( RetVal );
 843
 844     if( ! LR ) {
 845         cerr << "\nNo LR for:";
 846         printValue( RetVal );
 847         cerr << endl;
 848         // assert( LR && "No LR for return value of non-void method");
 849         return;
 850     }
 851
 852     unsigned RegClassID =  getRegClassIDOfValue(RetVal);
 853     unsigned RegType = getRegType( RetVal );
 854
 855     unsigned CorrectCol;
 856     if(RegClassID == IntRegClassID)
 857       CorrectCol = SparcIntRegOrder::i0;
 858     else if(RegClassID == FloatRegClassID)
 859       CorrectCol = SparcFloatRegOrder::f0;
 860     else {
 861       assert( 0 && "Unknown RegClass");
 862       return;
 863     }
 864
 865     // if the LR received the correct color, NOTHING to do
 866
 867     if(  LR->hasColor() )
 868       if( LR->getColor() == CorrectCol )
 869         return;
 870
 871     unsigned UniRetReg =  getUnifiedRegNum( RegClassID, CorrectCol );
 872
 873     if( LR->hasColor() ) {
 874
 875       // We are here because the LR was allocted a regiter
 876       // It may be the suggested register or not
 877
 878       // copy the LR of retun value to i0 or f0
 879
 880       unsigned UniLRReg =getUnifiedRegNum( RegClassID, LR->getColor());
 881
 882       // the LR received  UniLRReg but must be colored with UniRetReg
 883       // to pass as the return value
 884
 885       AdMI = cpReg2RegMI( UniLRReg, UniRetReg, RegType);
 886       RetAI->InstrnsBefore.push_back( AdMI );
 887     }
 888     else {                              // if the LR is spilled
 889
 890       AdMI = cpMem2RegMI(getFramePointer(), LR->getSpillOffFromFP(),
 891                          UniRetReg, RegType);
 892       RetAI->InstrnsBefore.push_back( AdMI );
 893       cout << "\nCopied the return value from stack";
 894     }
 895
 896   } // if there is a return value
 897
 898 }
 899
 900
 901 //---------------------------------------------------------------------------
 902 // Copy from a register to register. Register number must be the unified
 903 // register number
 904 //---------------------------------------------------------------------------
 905
 906 MachineInstr * UltraSparcRegInfo::cpReg2RegMI(const unsigned SrcReg,
 907                                               const unsigned DestReg,
 908                                               const int RegType) const {
 909
 910   assert( ((int)SrcReg != InvalidRegNum) && ((int)DestReg != InvalidRegNum) &&
 911           "Invalid Register");
 912
 913   MachineInstr * MI = NULL;
 914
 915   switch( RegType ) {
 916
 917   case IntRegType:
 918   case IntCCRegType:
 919   case FloatCCRegType:
 920     MI = new MachineInstr(ADD, 3);
 921     MI->SetMachineOperand(0, SrcReg, false);
 922     MI->SetMachineOperand(1, SparcIntRegOrder::g0, false);
 923     MI->SetMachineOperand(2, DestReg, true);
 924     break;
 925
 926   case FPSingleRegType:
 927     MI = new MachineInstr(FMOVS, 2);
 928     MI->SetMachineOperand(0, SrcReg, false);
 929     MI->SetMachineOperand(1, DestReg, true);
 930     break;
 931
 932   case FPDoubleRegType:
 933     MI = new MachineInstr(FMOVD, 2);
 934     MI->SetMachineOperand(0, SrcReg, false);
 935     MI->SetMachineOperand(1, DestReg, true);
 936     break;
 937
 938   default:
 939     assert(0 && "Unknow RegType");
 940   }
 941
 942   return MI;
 943 }
 944
 945
 946 //---------------------------------------------------------------------------
 947 // Copy from a register to memory (i.e., Store). Register number must
 948 // be the unified register number
 949 //---------------------------------------------------------------------------
 950
 951
 952 MachineInstr * UltraSparcRegInfo::cpReg2MemMI(const unsigned SrcReg,
 953                                               const unsigned DestPtrReg,
 954                                               const int Offset,
 955                                               const int RegType) const {
 956
 957
 958   MachineInstr * MI = NULL;
 959
 960   switch( RegType ) {
 961
 962   case IntRegType:
 963   case FloatCCRegType:
 964     MI = new MachineInstr(STX, 3);
 965     MI->SetMachineOperand(0, SrcReg, false);
 966     MI->SetMachineOperand(1, DestPtrReg, false);
 967     MI->SetMachineOperand(2, MachineOperand:: MO_SignExtendedImmed,
 968                           (int64_t) Offset, false);
 969     break;
 970
 971   case FPSingleRegType:
 972     MI = new MachineInstr(ST, 3);
 973     MI->SetMachineOperand(0, SrcReg, false);
 974     MI->SetMachineOperand(1, DestPtrReg, false);
 975     MI->SetMachineOperand(2, MachineOperand:: MO_SignExtendedImmed,
 976                           (int64_t) Offset, false);
 977     break;
 978
 979   case FPDoubleRegType:
 980     MI = new MachineInstr(STD, 3);
 981     MI->SetMachineOperand(0, SrcReg, false);
 982     MI->SetMachineOperand(1, DestPtrReg, false);
 983     MI->SetMachineOperand(2, MachineOperand:: MO_SignExtendedImmed,
 984                           (int64_t) Offset, false);
 985     break;
 986
 987   case IntCCRegType:
 988     assert( 0 && "Cannot directly store %ccr to memory");
 989
 990   default:
 991     assert(0 && "Unknow RegType in cpReg2MemMI");
 992   }
 993
 994   return MI;
 995 }
 996
 997
 998 //---------------------------------------------------------------------------
 999 // Copy from memory to a reg (i.e., Load) Register number must be the unified
1000 // register number
1001 //---------------------------------------------------------------------------
1002
1003
1004 MachineInstr * UltraSparcRegInfo::cpMem2RegMI(const unsigned SrcPtrReg,
1005                                               const int Offset,
1006                                               const unsigned DestReg,
1007                                               const int RegType) const {
1008
1009   MachineInstr * MI = NULL;
1010
1011   switch( RegType ) {
1012
1013   case IntRegType:
1014   case FloatCCRegType:
1015     MI = new MachineInstr(LDX, 3);
1016     MI->SetMachineOperand(0, SrcPtrReg, false);
1017     MI->SetMachineOperand(1, MachineOperand:: MO_SignExtendedImmed,
1018                           (int64_t) Offset, false);
1019     MI->SetMachineOperand(2, DestReg, true);
1020     break;
1021
1022   case FPSingleRegType:
1023     MI = new MachineInstr(LD, 3);
1024     MI->SetMachineOperand(0, SrcPtrReg, false);
1025     MI->SetMachineOperand(1, MachineOperand:: MO_SignExtendedImmed,
1026                           (int64_t) Offset, false);
1027     MI->SetMachineOperand(2, DestReg, true);
1028
1029     break;
1030
1031   case FPDoubleRegType:
1032     MI = new MachineInstr(LDD, 3);
1033     MI->SetMachineOperand(0, SrcPtrReg, false);
1034     MI->SetMachineOperand(1, MachineOperand:: MO_SignExtendedImmed,
1035                           (int64_t) Offset, false);
1036     MI->SetMachineOperand(2, DestReg, true);
1037     break;
1038
1039   case IntCCRegType:
1040     assert( 0 && "Cannot directly load into %ccr from memory");
1041
1042   default:
1043     assert(0 && "Unknown RegType in cpMem2RegMI");
1044   }
1045
1046   return MI;
1047 }
1048
1049
1050
1051
1052
1053 //---------------------------------------------------------------------------
1054 // Generate a copy instruction to copy a value to another. Temporarily
1055 // used by PhiElimination code.
1056 //---------------------------------------------------------------------------
1057
1058
1059 MachineInstr * UltraSparcRegInfo::cpValue2Value(Value *Src, Value *Dest) const{
1060
1061   int RegType = getRegType( Src );
1062
1063   assert( (RegType==getRegType(Src))  && "Src & Dest are diff types");
1064
1065   MachineInstr * MI = NULL;
1066
1067   switch( RegType ) {
1068
1069   case IntRegType:
1070
1071     MI = new MachineInstr(ADD, 3);
1072     MI->SetMachineOperand(0, MachineOperand:: MO_VirtualRegister, Src, false);
1073     MI->SetMachineOperand(1, SparcIntRegOrder::g0, false);
1074     MI->SetMachineOperand(2, MachineOperand:: MO_VirtualRegister, Dest, true);
1075     break;
1076
1077   case FPSingleRegType:
1078     MI = new MachineInstr(FMOVS, 2);
1079     MI->SetMachineOperand(0, MachineOperand:: MO_VirtualRegister, Src, false);
1080     MI->SetMachineOperand(1, MachineOperand:: MO_VirtualRegister, Dest, true);
1081     break;
1082
1083
1084   case FPDoubleRegType:
1085     MI = new MachineInstr(FMOVD, 2);
1086     MI->SetMachineOperand(0, MachineOperand:: MO_VirtualRegister, Src, false);
1087     MI->SetMachineOperand(1, MachineOperand:: MO_VirtualRegister, Dest, true);
1088     break;
1089
1090   default:
1091     assert(0 && "Unknow RegType in CpValu2Value");
1092   }
1093
1094   return MI;
1095 }
1096
1097
1098
1099
1100
1101
1102 //----------------------------------------------------------------------------
1103 // This method inserts caller saving/restoring instructons before/after
1104 // a call machine instruction.
1105 //----------------------------------------------------------------------------
1106
1107
1108 void UltraSparcRegInfo::insertCallerSavingCode(const MachineInstr *MInst,
1109                                                const BasicBlock *BB,
1110                                                PhyRegAlloc &PRA) const {
1111   // assert( (getInstrInfo()).isCall( MInst->getOpCode() ) );
1112
1113   // Clear the temp area of the stack
1114   //PRA.mcInfo.popAllTempValues(target);
1115   // TODO*** Don't do this since we can have a situation lik
1116   /*
1117
1118         stx     %o1     %i6     1999   <--- inserted by this code
1119         stx     %o5     %i6     2007
1120
1121         *****
1122         stx     %o1     %i6     2007 ????  <-- inserted by statck2stack call arg
1123
1124   */
1125
1126
1127   hash_set<unsigned> PushedRegSet;
1128
1129   // Now find the LR of the return value of the call
1130   // The last *implicit operand* is the return value of a call
1131   // Insert it to to he PushedRegSet since we must not save that register
1132   // and restore it after the call.
1133   // We do this because, we look at the LV set *after* the instruction
1134   // to determine, which LRs must be saved across calls. The return value
1135   // of the call is live in this set - but we must not save/restore it.
1136
1137
1138   const Value *RetVal = getCallInstRetVal( MInst );
1139
1140   if( RetVal ) {
1141
1142     LiveRange *RetValLR = PRA.LRI.getLiveRangeForValue( RetVal );
1143     assert( RetValLR && "No LR for RetValue of call");
1144
1145     if(  RetValLR->hasColor())
1146       PushedRegSet.insert(
1147          getUnifiedRegNum((RetValLR->getRegClass())->getID(),
1148                                       RetValLR->getColor() ) );
1149   }
1150
1151
1152   const LiveVarSet *LVSetAft =  PRA.LVI->getLiveVarSetAfterMInst(MInst, BB);
1153
1154   LiveVarSet::const_iterator LIt = LVSetAft->begin();
1155
1156   // for each live var in live variable set after machine inst
1157   for( ; LIt != LVSetAft->end(); ++LIt) {
1158
1159    //  get the live range corresponding to live var
1160     LiveRange *const LR = PRA.LRI.getLiveRangeForValue(*LIt );
1161
1162     // LR can be null if it is a const since a const
1163     // doesn't have a dominating def - see Assumptions above
1164     if( LR )   {
1165
1166       if( LR->hasColor() ) {
1167
1168         unsigned RCID = (LR->getRegClass())->getID();
1169         unsigned Color = LR->getColor();
1170
1171         if ( isRegVolatile(RCID, Color) ) {
1172
1173           // if the value is in both LV sets (i.e., live before and after
1174           // the call machine instruction)
1175
1176           unsigned Reg = getUnifiedRegNum(RCID, Color);
1177
1178           if( PushedRegSet.find(Reg) == PushedRegSet.end() ) {
1179
1180             // if we haven't already pushed that register
1181
1182             unsigned RegType = getRegType( LR );
1183
1184             // Now get two instructions - to push on stack and pop from stack
1185             // and add them to InstrnsBefore and InstrnsAfter of the
1186             // call instruction
1187
1188     /**** NOTE: THIS SHOULD USE THE RIGHT SIZE FOR THE REG BEING PUSHED ****/
1189             int StackOff =  PRA.mcInfo.pushTempValue(target, 8);
1190                 // target.findOptimalStorageSize(LR->getType()));
1191
1192             MachineInstr *AdIBefCC, *AdIAftCC, *AdICpCC;
1193             MachineInstr *AdIBef, *AdIAft;
1194
1195
1196             //---- Insert code for pushing the reg on stack ----------
1197
1198             if( RegType == IntCCRegType ) {
1199
1200               // Handle IntCCRegType specially since we cannot directly
1201               // push %ccr on to the stack
1202
1203               const LiveVarSet *LVSetBef =
1204                 PRA.LVI->getLiveVarSetBeforeMInst(MInst, BB);
1205
1206               // get a free INTEGER register
1207               int FreeIntReg =
1208                 PRA.getUsableUniRegAtMI(LR->getRegClass(), IntRegType, MInst,
1209                                      LVSetBef, AdIBefCC, AdIAftCC);
1210
1211               // insert the instructions in reverse order since we are
1212               // adding them to the front of InstrnsBefore
1213
1214               if(AdIAftCC)
1215                 (PRA.AddedInstrMap[MInst]->InstrnsBefore).push_front(AdIAftCC);
1216
1217               AdICpCC = cpCCR2IntMI(FreeIntReg);
1218               (PRA.AddedInstrMap[MInst]->InstrnsBefore).push_front(AdICpCC);
1219
1220               if(AdIBefCC)
1221                 (PRA.AddedInstrMap[MInst]->InstrnsBefore).push_front(AdIBefCC);
1222
1223               if(DEBUG_RA) {
1224                 cerr << "\n!! Inserted caller saving (push) inst for %ccr:";
1225                 if(AdIBefCC) cerr << "\t" <<  *(AdIBefCC);
1226                 cerr  << "\t" << *AdICpCC;
1227                 if(AdIAftCC) cerr  << "\t" << *(AdIAftCC);
1228               }
1229
1230             } else  {
1231               // for any other register type, just add the push inst
1232               AdIBef = cpReg2MemMI(Reg, getFramePointer(), StackOff, RegType );
1233               ((PRA.AddedInstrMap[MInst])->InstrnsBefore).push_front(AdIBef);
1234             }
1235
1236
1237             //---- Insert code for popping the reg from the stack ----------
1238
1239             if( RegType == IntCCRegType ) {
1240
1241               // Handle IntCCRegType specially since we cannot directly
1242               // pop %ccr on from the stack
1243
1244               // get a free INT register
1245               int FreeIntReg =
1246                 PRA.getUsableUniRegAtMI(LR->getRegClass(), IntRegType, MInst,
1247                                      LVSetAft, AdIBefCC, AdIAftCC);
1248
1249               if(AdIBefCC)
1250                 (PRA.AddedInstrMap[MInst]->InstrnsAfter).push_back(AdIBefCC);
1251
1252               AdICpCC = cpInt2CCRMI(FreeIntReg);
1253               (PRA.AddedInstrMap[MInst]->InstrnsAfter).push_back(AdICpCC);
1254
1255               if(AdIAftCC)
1256                 (PRA.AddedInstrMap[MInst]->InstrnsAfter).push_back(AdIAftCC);
1257
1258               if(DEBUG_RA) {
1259
1260                 cerr << "\n!! Inserted caller saving (pop) inst for %ccr:";
1261                 if(AdIBefCC) cerr << "\t" <<  *(AdIBefCC);
1262                 cerr  << "\t" << *AdICpCC;
1263                 if(AdIAftCC) cerr  << "\t" << *(AdIAftCC);
1264               }
1265
1266             } else {
1267               // for any other register type, just add the pop inst
1268               AdIAft = cpMem2RegMI(getFramePointer(), StackOff, Reg, RegType );
1269               ((PRA.AddedInstrMap[MInst])->InstrnsAfter).push_back(AdIAft);
1270             }
1271
1272             PushedRegSet.insert( Reg );
1273
1274             if(DEBUG_RA) {
1275               cerr << "\nFor call inst:" << *MInst;
1276               cerr << " -inserted caller saving instrs:\n\t ";
1277               if( RegType == IntCCRegType )
1278                 cerr << *AdIBefCC << "\t" << *AdIAftCC  ;
1279               else
1280                 cerr << *AdIBef   << "\t" << *AdIAft    ;
1281             }
1282           } // if not already pushed
1283
1284         } // if LR has a volatile color
1285
1286       } // if LR has color
1287
1288     } // if there is a LR for Var
1289
1290   } // for each value in the LV set after instruction
1291
1292   // Clear the temp area of the stack
1293   // PRA.mcInfo.popAllTempValues(target);
1294   // TODO *** see above call - optimize later
1295
1296
1297 }
1298
1299 //---------------------------------------------------------------------------
1300 // Copies %ccr into an integer register. IntReg is the UNIFIED register
1301 // number.
1302 //---------------------------------------------------------------------------
1303
1304 MachineInstr * UltraSparcRegInfo::cpCCR2IntMI(const unsigned IntReg) const {
1305   MachineInstr * MI = NULL;
1306
1307   MI = new MachineInstr(RDCCR, 2);
1308   MI->SetMachineOperand(0, SparcIntCCRegOrder::ccr, false);
1309   MI->SetMachineOperand(1, IntReg, true);
1310
1311   return MI;
1312 }
1313
1314 //---------------------------------------------------------------------------
1315 // Copies an integer register into  %ccr. IntReg is the UNIFIED register
1316 // number.
1317 //---------------------------------------------------------------------------
1318
1319 MachineInstr * UltraSparcRegInfo::cpInt2CCRMI(const unsigned IntReg) const {
1320   MachineInstr * MI = NULL;
1321
1322   MI = new MachineInstr(WRCCR, 3);
1323   MI->SetMachineOperand(0, IntReg, false);
1324   MI->SetMachineOperand(1, SparcIntRegOrder::g0, false);
1325   MI->SetMachineOperand(2, SparcIntCCRegOrder::ccr, true);
1326
1327   return MI;
1328 }
1329
1330
1331
1332
1333 //---------------------------------------------------------------------------
1334 // Print the register assigned to a LR
1335 //---------------------------------------------------------------------------
1336
1337 void UltraSparcRegInfo::printReg(const LiveRange *const LR) {
1338
1339   unsigned RegClassID = (LR->getRegClass())->getID();
1340
1341   cerr << " *Node " << (LR->getUserIGNode())->getIndex();
1342
1343   if( ! LR->hasColor() ) {
1344     cerr << " - could not find a color" << endl;
1345     return;
1346   }
1347
1348   // if a color is found
1349
1350   cerr << " colored with color "<< LR->getColor();
1351
1352   if( RegClassID == IntRegClassID ) {
1353
1354     cerr<< " [" << SparcIntRegOrder::getRegName(LR->getColor()) ;
1355     cerr << "]" << endl;
1356   }
1357   else if ( RegClassID == FloatRegClassID) {
1358     cerr << "[" << SparcFloatRegOrder::getRegName(LR->getColor());
1359     if( LR->getTypeID() == Type::DoubleTyID )
1360       cerr << "+" << SparcFloatRegOrder::getRegName(LR->getColor()+1);
1361     cerr << "]" << endl;
1362   }
1363 }
1364
1365 //---------------------------------------------------------------------------
1366 // This method examines instructions inserted by RegAlloc code before a
1367 // machine instruction to detect invalid orders that destroy values before
1368 // they are used. If it detects such conditions, it reorders the instructions.
1369 //
1370 // The unordered instructions come in the UnordVec. These instructions are
1371 // instructions inserted by RegAlloc. All such instruction MUST have
1372 // their USES BEFORE THE DEFS after reordering.
1373
1374 // The UnordVec & OrdVec must be DISTINCT. The OrdVec must be empty when
1375 // this method is called.
1376
1377 // This method uses two vectors for efficiency in accessing
1378
1379 // Since instructions are inserted in RegAlloc, this assumes that the
1380 // first operand is the source reg and the last operand is the dest reg.
1381
1382 // All the uses are before THE def to a register
1383
1384
1385 //---------------------------------------------------------------------------
1386 void UltraSparcRegInfo::OrderAddedInstrns( vector<MachineInstr *> &UnordVec,
1387                                            vector<MachineInstr *> &OrdVec,
1388                                            PhyRegAlloc &PRA) const{
1389
1390   /*
1391     Problem: We can have instructions inserted by RegAlloc like
1392     1. add %ox %g0 %oy
1393     2. add %oy %g0 %oz, where z!=x or z==x
1394
1395     This is wrong since %oy used by 2 is overwritten by 1
1396
1397     Solution:
1398     We re-order the instructions so that the uses are before the defs
1399
1400     Algorithm:
1401
1402     do
1403       for each instruction 'DefInst' in the UnOrdVec
1404          for each instruction 'UseInst' that follows the DefInst
1405            if the reg defined by DefInst is used by UseInst
1406              mark DefInst as not movable in this iteration
1407          If DefInst is not marked as not-movable, move DefInst to OrdVec
1408     while all instructions in DefInst are moved to OrdVec
1409
1410     For moving, we call the move2OrdVec(). It checks whether there is a def
1411     in it for the uses in the instruction to be added to OrdVec. If there
1412     are no preceding defs, it just appends the instruction. If there is a
1413     preceding def, it puts two instructions to save the reg on stack before
1414     the load and puts a restore at use.
1415
1416   */
1417
1418
1419   bool CouldMoveAll;
1420   bool DebugPrint = false;
1421
1422   do {
1423
1424     CouldMoveAll = true;
1425
1426     vector<MachineInstr *>::iterator DefIt = UnordVec.begin();
1427
1428     for( ; DefIt !=  UnordVec.end(); ++DefIt ) {
1429
1430       // for each instruction in the UnordVec do ...
1431
1432       MachineInstr *DefInst = *DefIt;
1433
1434       if( DefInst == NULL) continue;
1435
1436       //cerr << "\nInst in UnordVec = " <<  *DefInst;
1437
1438       // last operand is the def (unless for a store which has no def reg)
1439       MachineOperand& DefOp = DefInst->getOperand(DefInst->getNumOperands()-1);
1440
1441       if( DefOp.opIsDef() &&
1442           DefOp.getOperandType() ==  MachineOperand::MO_MachineRegister) {
1443
1444         // If the operand in DefInst is a def ...
1445
1446         bool DefEqUse = false;
1447
1448         vector<MachineInstr *>::iterator UseIt = DefIt;
1449         UseIt++;
1450
1451         for( ; UseIt !=  UnordVec.end(); ++UseIt ) {
1452
1453           MachineInstr *UseInst = *UseIt;
1454           if( UseInst == NULL) continue;
1455
1456           // for each inst (UseInst) that is below the DefInst do ...
1457
1458
1459           MachineOperand& UseOp = UseInst->getOperand(0);
1460
1461           if( ! UseOp.opIsDef() &&
1462               UseOp.getOperandType() == MachineOperand::MO_MachineRegister) {
1463
1464             // if use is a register ...
1465
1466             if( DefOp.getMachineRegNum() == UseOp.getMachineRegNum() ) {
1467
1468               // if Def and this use are the same, it means that this use
1469               // is destroyed by a def before it is used
1470
1471               // cerr << "\nCouldn't move " << *DefInst;
1472
1473               DefEqUse = true;
1474               CouldMoveAll = false;
1475               DebugPrint = true;
1476               break;
1477             } // if two registers are equal
1478
1479           } // if use is a register
1480
1481         }// for all use instructions
1482
1483         if( ! DefEqUse ) {
1484
1485           // after examining all the instructions that follow the DefInst
1486           // if there are no dependencies, we can move it to the OrdVec
1487
1488           // cerr << "Moved to Ord: " << *DefInst;
1489
1490           moveInst2OrdVec(OrdVec, DefInst, PRA);
1491
1492           //OrdVec.push_back(DefInst);
1493
1494           // mark the pos of DefInst with NULL to indicate that it is
1495           // empty
1496           *DefIt = NULL;
1497         }
1498
1499       } // if Def is a machine register
1500
1501     } // for all instructions in the UnordVec
1502
1503
1504   } while( !CouldMoveAll);
1505
1506
1507   if(DebugPrint) {
1508     cerr << "\nAdded instructions were reordered to:\n";
1509     for(unsigned int i=0; i < OrdVec.size(); i++)
1510       cerr << *(OrdVec[i]);
1511   }
1512
1513 }
1514
1515
1516
1517
1518
1519
1520
1521
1522 void UltraSparcRegInfo::moveInst2OrdVec(vector<MachineInstr *> &OrdVec,
1523                                         MachineInstr *UnordInst,
1524                                         PhyRegAlloc &PRA ) const {
1525
1526   MachineOperand& UseOp = UnordInst->getOperand(0);
1527
1528   if( ! UseOp.opIsDef() &&
1529       UseOp.getOperandType() ==  MachineOperand::MO_MachineRegister) {
1530
1531     // for the use of UnordInst, see whether there is a defining instr
1532     // before in the OrdVec
1533     bool DefEqUse = false;
1534
1535     vector<MachineInstr *>::iterator OrdIt = OrdVec.begin();
1536
1537     for( ; OrdIt !=  OrdVec.end(); ++OrdIt ) {
1538
1539       MachineInstr *OrdInst = *OrdIt ;
1540
1541       MachineOperand& DefOp =
1542         OrdInst->getOperand(OrdInst->getNumOperands()-1);
1543
1544       if( DefOp.opIsDef() &&
1545           DefOp.getOperandType() == MachineOperand::MO_MachineRegister) {
1546
1547         //cerr << "\nDefining Ord Inst: " <<  *OrdInst;
1548
1549         if( DefOp.getMachineRegNum() == UseOp.getMachineRegNum() ) {
1550
1551           // we are here because there is a preceding def in the OrdVec
1552           // for the use in this intr we are going to insert. This
1553           // happened because the original code was like:
1554           // 1. add %ox %g0 %oy
1555           // 2. add %oy %g0 %ox
1556           // In Round1, we added 2 to OrdVec but 1 remained in UnordVec
1557           // Now we are processing %ox of 1.
1558           // We have to
1559
1560           const int UReg = DefOp.getMachineRegNum();
1561           const int RegType = getRegType(UReg);
1562           MachineInstr *AdIBef, *AdIAft;
1563
1564           // TODO: Change 8 below
1565     /**** NOTE: THIS SHOULD USE THE RIGHT SIZE FOR THE REG BEING PUSHED ****/
1566           const int StackOff =  PRA.mcInfo.pushTempValue(target, 8);
1567
1568           // Save the UReg (%ox) on stack before it's destroyed
1569           AdIBef=cpReg2MemMI(UReg, getFramePointer(), StackOff, RegType);
1570           OrdIt = OrdVec.insert( OrdIt, AdIBef);
1571           OrdIt++;  // points to current instr we processed
1572
1573           // Load directly into DReg (%oy)
1574           MachineOperand&  DOp=
1575             (UnordInst->getOperand(UnordInst->getNumOperands()-1));
1576           assert(DOp.opIsDef() && "Last operand is not the def");
1577           const int DReg = DOp.getMachineRegNum();
1578
1579           AdIAft=cpMem2RegMI(getFramePointer(), StackOff, DReg, RegType);
1580           OrdVec.push_back(AdIAft);
1581
1582           cerr << "\nFixed CIRCULAR references by reordering";
1583
1584           if( DEBUG_RA ) {
1585             cerr << "\nBefore CIRCULAR Reordering:\n";
1586             cerr << *UnordInst;
1587             cerr << *OrdInst;
1588
1589             cerr << "\nAfter CIRCULAR Reordering - All Inst so far:\n";
1590             for(unsigned i=0; i < OrdVec.size(); i++)
1591               cerr << *(OrdVec[i]);
1592           }
1593
1594           // Do not copy the UseInst to OrdVec
1595           DefEqUse = true;
1596           break;
1597
1598         }// if two registers are equal
1599
1600       } // if Def is a register
1601
1602     } // for each instr in OrdVec
1603
1604     if( !DefEqUse ) {
1605
1606       // We didn't find a def in the OrdVec, so just append this inst
1607       OrdVec.push_back( UnordInst );
1608       //cerr << "Reordered Inst (Moved Dn): " <<  *UnordInst;
1609     }
1610
1611   }// if the operand in UnordInst is a use
1612
1613 }
1614
1615
1616
1617
1618
1619