Added support to move "added instructions" after the delay slot

llvm-svn: 967

lib/CodeGen/RegAlloc/PhyRegAlloc.cpp

@@ -565,7 +565,26 @@ void PhyRegAlloc::updateMachineCode()
       // If there are instructions to be added *after* this machine
       // instruction, add them now
       
-      if( AddedInstrMap[ MInst ] ) {
+      if( AddedInstrMap[ MInst ] && 
+	  ! (AddedInstrMap[ MInst ]->InstrnsAfter).empty() ) {
+
+	// if there are delay slots for this instruction, the instructions
+	// added after it must really go after the delayed instruction(s)
+	// So, we move the InstrAfter of the current instruction to the 
+	// corresponding delayed instruction
+	
+	unsigned delay;
+	if((delay=TM.getInstrInfo().getNumDelaySlots(MInst->getOpCode())) >0){ 
+	  move2DelayedInstr(MInst,  *(MInstIterator+delay) );
+
+	  if(DEBUG_RA)  cout<< "\nMoved an added instr after the delay slot";
+	}
+       
+	else {
+	
+
+	  // Here we can add the "instructions after" to the current
+	  // instruction since there are no delay slots for this instruction
 
 	  deque<MachineInstr *> &IAft = (AddedInstrMap[MInst])->InstrnsAfter;
 	  
@@ -591,6 +610,8 @@ void PhyRegAlloc::updateMachineCode()
 	    
 	  }
 	  
+	}  // if not delay
+	
       }
       
     } // for each machine instruction
@@ -598,7 +619,46 @@ void PhyRegAlloc::updateMachineCode()
 }
 
 
+//----------------------------------------------------------------------------
+//
+// If there are delay slots for an instruction, the instructions
+// added after it must really go after the delayed instruction(s).
+// So, we move the InstrAfter of that instruction to the 
+// corresponding delayed instruction using the following method.
 
+//----------------------------------------------------------------------------
+void PhyRegAlloc:: move2DelayedInstr(const MachineInstr *OrigMI,
+				     const MachineInstr *DelayedMI) {
+
+
+  // "added after" instructions of the original instr
+  deque<MachineInstr *> &OrigAft = (AddedInstrMap[OrigMI])->InstrnsAfter;
+
+  // "added instructions" of the delayed instr
+  AddedInstrns *DelayAdI = AddedInstrMap[DelayedMI];
+
+  if(! DelayAdI )  {                // create a new "added after" if necessary
+    DelayAdI = new AddedInstrns();
+    AddedInstrMap[DelayedMI] =  DelayAdI;
+  }
+
+  // "added after" instructions of the delayed instr
+  deque<MachineInstr *> &DelayedAft = DelayAdI->InstrnsAfter;
+
+  // go thru all the "added after instructions" of the original instruction
+  // and append them to the "addded after instructions" of the delayed
+  // instructions
+
+  deque<MachineInstr *>::iterator OrigAdIt; 
+	    
+  for( OrigAdIt = OrigAft.begin(); OrigAdIt != OrigAft.end() ; ++OrigAdIt ) { 
+    DelayedAft.push_back( *OrigAdIt );
+  }    
+
+  // empty the "added after instructions" of the original instruction
+  OrigAft.clear();
+    
+}
 
 //----------------------------------------------------------------------------
 // This method prints the code with registers after register allocation is