lib/Target/SparcV9/SparcV9TargetMachine.cpp

   1 // $Id$
   2 //***************************************************************************
   3 // File:
   4 //      Sparc.cpp
   5 //
   6 // Purpose:
   7 //
   8 // History:
   9 //      7/15/01  -  Vikram Adve  -  Created
  10 //**************************************************************************/
  11
  12
  13 #include "SparcInternals.h"
  14 #include "llvm/Target/Sparc.h"
  15 #include "llvm/CodeGen/InstrScheduling.h"
  16 #include "llvm/CodeGen/InstrSelection.h"
  17 #include "llvm/CodeGen/PhyRegAlloc.h"
  18 #include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h"
  19 #include "llvm/Method.h"
  20
  21
  22 // Build the MachineInstruction Description Array...
  23 const MachineInstrDescriptor SparcMachineInstrDesc[] = {
  24 #define I(ENUM, OPCODESTRING, NUMOPERANDS, RESULTPOS, MAXIMM, IMMSE, \
  25           NUMDELAYSLOTS, LATENCY, SCHEDCLASS, INSTFLAGS)             \
  26   { OPCODESTRING, NUMOPERANDS, RESULTPOS, MAXIMM, IMMSE,             \
  27           NUMDELAYSLOTS, LATENCY, SCHEDCLASS, INSTFLAGS },
  28 #include "SparcInstr.def"
  29 };
  30
  31 //----------------------------------------------------------------------------
  32 // allocateSparcTargetMachine - Allocate and return a subclass of TargetMachine
  33 // that implements the Sparc backend. (the llvm/CodeGen/Sparc.h interface)
  34 //----------------------------------------------------------------------------
  35 //
  36
  37 TargetMachine *allocateSparcTargetMachine() { return new UltraSparc(); }
  38
  39
  40 //----------------------------------------------------------------------------
  41 // Entry point for register allocation for a module
  42 //----------------------------------------------------------------------------
  43
  44 void AllocateRegisters(Method *M, TargetMachine &target)
  45 {
  46
  47   if ( (M)->isExternal() )     // don't process prototypes
  48     return;
  49
  50   if( DEBUG_RA ) {
  51     cerr << endl << "******************** Method "<< (M)->getName();
  52     cerr <<        " ********************" <<endl;
  53   }
  54
  55   MethodLiveVarInfo LVI(M );   // Analyze live varaibles
  56   LVI.analyze();
  57
  58
  59   PhyRegAlloc PRA(M, target, &LVI); // allocate registers
  60   PRA.allocateRegisters();
  61
  62
  63   if( DEBUG_RA )  cerr << endl << "Register allocation complete!" << endl;
  64
  65 }
  66
  67
  68 //---------------------------------------------------------------------------
  69 // Function InsertPrologCode
  70 // Function InsertEpilogCode
  71 // Function InsertPrologEpilog
  72 //
  73 // Insert prolog code at the unique method entry point.
  74 // Insert epilog code at each method exit point.
  75 // InsertPrologEpilog invokes these only if the method is not compiled
  76 // with the leaf method optimization.
  77 //---------------------------------------------------------------------------
  78
  79 static MachineInstr* minstrVec[MAX_INSTR_PER_VMINSTR];
  80
  81 static void
  82 InsertPrologCode(Method* method, TargetMachine& target)
  83 {
  84   BasicBlock* entryBB = method->getEntryNode();
  85   unsigned N = GetInstructionsForProlog(entryBB, target, minstrVec);
  86   assert(N <= MAX_INSTR_PER_VMINSTR);
  87   if (N > 0)
  88     {
  89       MachineCodeForBasicBlock& bbMvec = entryBB->getMachineInstrVec();
  90       bbMvec.insert(bbMvec.begin(), minstrVec, minstrVec+N);
  91     }
  92 }
  93
  94
  95 static void
  96 InsertEpilogCode(Method* method, TargetMachine& target)
  97 {
  98   for (Method::iterator I=method->begin(), E=method->end(); I != E; ++I)
  99     if ((*I)->getTerminator()->getOpcode() == Instruction::Ret)
 100       {
 101         BasicBlock* exitBB = *I;
 102         unsigned N = GetInstructionsForEpilog(exitBB, target, minstrVec);
 103
 104         MachineCodeForBasicBlock& bbMvec = exitBB->getMachineInstrVec();
 105         MachineCodeForVMInstr& termMvec =
 106           exitBB->getTerminator()->getMachineInstrVec();
 107
 108         // Remove the NOPs in the delay slots of the return instruction
 109         const MachineInstrInfo& mii = target.getInstrInfo();
 110         unsigned numNOPs = 0;
 111         while (termMvec.back()->getOpCode() == NOP)
 112           {
 113             assert( termMvec.back() == bbMvec.back());
 114             termMvec.pop_back();
 115             bbMvec.pop_back();
 116             ++numNOPs;
 117           }
 118         assert(termMvec.back() == bbMvec.back());
 119
 120         // Check that we found the right number of NOPs and have the right
 121         // number of instructions to replace them.
 122         unsigned ndelays = mii.getNumDelaySlots(termMvec.back()->getOpCode());
 123         assert(numNOPs == ndelays && "Missing NOPs in delay slots?");
 124         assert(N == ndelays && "Cannot use epilog code for delay slots?");
 125
 126         // Append the epilog code to the end of the basic block.
 127         bbMvec.push_back(minstrVec[0]);
 128       }
 129 }
 130
 131
 132 // Insert SAVE/RESTORE instructions for the method
 133 static void
 134 InsertPrologEpilog(Method *method, TargetMachine &target)
 135 {
 136   MachineCodeForMethod& mcodeInfo = MachineCodeForMethod::get(method);
 137   if (mcodeInfo.isCompiledAsLeafMethod())
 138     return;                             // nothing to do
 139
 140   InsertPrologCode(method, target);
 141   InsertEpilogCode(method, target);
 142 }
 143
 144
 145 //---------------------------------------------------------------------------
 146 // class UltraSparcSchedInfo
 147 //
 148 // Purpose:
 149 //   Scheduling information for the UltraSPARC.
 150 //   Primarily just initializes machine-dependent parameters in
 151 //   class MachineSchedInfo.
 152 //---------------------------------------------------------------------------
 153
 154 /*ctor*/
 155 UltraSparcSchedInfo::UltraSparcSchedInfo(const TargetMachine& tgt)
 156   : MachineSchedInfo(tgt,
 157                      (unsigned int) SPARC_NUM_SCHED_CLASSES,
 158                      SparcRUsageDesc,
 159                      SparcInstrUsageDeltas,
 160                      SparcInstrIssueDeltas,
 161                      sizeof(SparcInstrUsageDeltas)/sizeof(InstrRUsageDelta),
 162                      sizeof(SparcInstrIssueDeltas)/sizeof(InstrIssueDelta))
 163 {
 164   maxNumIssueTotal = 4;
 165   longestIssueConflict = 0;             // computed from issuesGaps[]
 166
 167   branchMispredictPenalty = 4;          // 4 for SPARC IIi
 168   branchTargetUnknownPenalty = 2;       // 2 for SPARC IIi
 169   l1DCacheMissPenalty = 8;              // 7 or 9 for SPARC IIi
 170   l1ICacheMissPenalty = 8;              // ? for SPARC IIi
 171
 172   inOrderLoads = true;                  // true for SPARC IIi
 173   inOrderIssue = true;                  // true for SPARC IIi
 174   inOrderExec  = false;                 // false for most architectures
 175   inOrderRetire= true;                  // true for most architectures
 176
 177   // must be called after above parameters are initialized.
 178   this->initializeResources();
 179 }
 180
 181 void
 182 UltraSparcSchedInfo::initializeResources()
 183 {
 184   // Compute MachineSchedInfo::instrRUsages and MachineSchedInfo::issueGaps
 185   MachineSchedInfo::initializeResources();
 186
 187   // Machine-dependent fixups go here.  None for now.
 188 }
 189
 190
 191 //---------------------------------------------------------------------------
 192 // class UltraSparcFrameInfo
 193 //
 194 // Purpose:
 195 //   Interface to stack frame layout info for the UltraSPARC.
 196 //   Note that there is no machine-independent interface to this information
 197 //---------------------------------------------------------------------------
 198
 199 int
 200 UltraSparcFrameInfo::getFirstAutomaticVarOffset(MachineCodeForMethod& ,
 201                                                 bool& pos) const
 202 {
 203   pos = false;                          // static stack area grows downwards
 204   return StaticAreaOffsetFromFP;
 205 }
 206
 207 int
 208 UltraSparcFrameInfo::getRegSpillAreaOffset(MachineCodeForMethod& mcInfo,
 209                                            bool& pos) const
 210 {
 211   pos = false;                          // static stack area grows downwards
 212   unsigned int autoVarsSize = mcInfo.getAutomaticVarsSize();
 213   return  StaticAreaOffsetFromFP - autoVarsSize;
 214 }
 215
 216 int
 217 UltraSparcFrameInfo::getTmpAreaOffset(MachineCodeForMethod& mcInfo,
 218                                       bool& pos) const
 219 {
 220   pos = false;                          // static stack area grows downwards
 221   unsigned int autoVarsSize = mcInfo.getAutomaticVarsSize();
 222   unsigned int spillAreaSize = mcInfo.getRegSpillsSize();
 223   return StaticAreaOffsetFromFP - (autoVarsSize + spillAreaSize);
 224 }
 225
 226 int
 227 UltraSparcFrameInfo::getDynamicAreaOffset(MachineCodeForMethod& mcInfo,
 228                                           bool& pos) const
 229 {
 230   // dynamic stack area grows downwards starting at top of opt-args area
 231   unsigned int optArgsSize = mcInfo.getMaxOptionalArgsSize();
 232   return optArgsSize + FirstOptionalOutgoingArgOffsetFromSP;
 233 }
 234
 235
 236 //---------------------------------------------------------------------------
 237 // class UltraSparcMachine
 238 //
 239 // Purpose:
 240 //   Primary interface to machine description for the UltraSPARC.
 241 //   Primarily just initializes machine-dependent parameters in
 242 //   class TargetMachine, and creates machine-dependent subclasses
 243 //   for classes such as MachineInstrInfo.
 244 //
 245 //---------------------------------------------------------------------------
 246
 247 UltraSparc::UltraSparc()
 248   : TargetMachine("UltraSparc-Native"),
 249     instrInfo(*this),
 250     schedInfo(*this),
 251     regInfo(*this),
 252     frameInfo(*this)
 253 {
 254   optSizeForSubWordData = 4;
 255   minMemOpWordSize = 8;
 256   maxAtomicMemOpWordSize = 8;
 257 }
 258
 259
 260 void
 261 ApplyPeepholeOptimizations(Method *method, TargetMachine &target)
 262 {
 263   return;
 264
 265   // OptimizeLeafProcedures();
 266   // DeleteFallThroughBranches();
 267   // RemoveChainedBranches();    // should be folded with previous
 268   // RemoveRedundantOps();       // operations with %g0, NOP, etc.
 269 }
 270
 271
 272
 273 bool
 274 UltraSparc::compileMethod(Method *method)
 275 {
 276   // Construct and initialize the MachineCodeForMethod object for this method.
 277   (void) MachineCodeForMethod::construct(method, *this);
 278
 279   if (SelectInstructionsForMethod(method, *this))
 280     {
 281       cerr << "Instruction selection failed for method " << method->getName()
 282            << "\n\n";
 283       return true;
 284     }
 285
 286   if (ScheduleInstructionsWithSSA(method, *this))
 287     {
 288       cerr << "Instruction scheduling before allocation failed for method "
 289            << method->getName() << "\n\n";
 290       return true;
 291     }
 292
 293   AllocateRegisters(method, *this);          // allocate registers
 294
 295   ApplyPeepholeOptimizations(method, *this); // machine-dependent peephole opts
 296
 297   InsertPrologEpilog(method, *this);
 298
 299   return false;
 300 }