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 //   Starting offsets for each area of the stack frame are aligned at
 197 //   a multiple of getStackFrameSizeAlignment().
 198 //---------------------------------------------------------------------------
 199
 200 int
 201 UltraSparcFrameInfo::getFirstAutomaticVarOffset(MachineCodeForMethod& ,
 202                                                 bool& pos) const
 203 {
 204   pos = false;                          // static stack area grows downwards
 205   return StaticAreaOffsetFromFP;
 206 }
 207
 208 int
 209 UltraSparcFrameInfo::getRegSpillAreaOffset(MachineCodeForMethod& mcInfo,
 210                                            bool& pos) const
 211 {
 212   pos = false;                          // static stack area grows downwards
 213   unsigned int autoVarsSize = mcInfo.getAutomaticVarsSize();
 214   if (int mod = autoVarsSize % getStackFrameSizeAlignment())
 215     autoVarsSize += (getStackFrameSizeAlignment() - mod);
 216   return StaticAreaOffsetFromFP - autoVarsSize;
 217 }
 218
 219 int
 220 UltraSparcFrameInfo::getTmpAreaOffset(MachineCodeForMethod& mcInfo,
 221                                       bool& pos) const
 222 {
 223   pos = false;                          // static stack area grows downwards
 224   unsigned int autoVarsSize = mcInfo.getAutomaticVarsSize();
 225   unsigned int spillAreaSize = mcInfo.getRegSpillsSize();
 226   int offset = autoVarsSize + spillAreaSize;
 227   if (int mod = offset % getStackFrameSizeAlignment())
 228     offset += (getStackFrameSizeAlignment() - mod);
 229   return StaticAreaOffsetFromFP - offset;
 230 }
 231
 232 int
 233 UltraSparcFrameInfo::getDynamicAreaOffset(MachineCodeForMethod& mcInfo,
 234                                           bool& pos) const
 235 {
 236   // dynamic stack area grows downwards starting at top of opt-args area
 237   unsigned int optArgsSize = mcInfo.getMaxOptionalArgsSize();
 238   int offset = optArgsSize + FirstOptionalOutgoingArgOffsetFromSP;
 239   assert(offset % getStackFrameSizeAlignment() == 0);
 240   return offset;
 241 }
 242
 243
 244 //---------------------------------------------------------------------------
 245 // class UltraSparcMachine
 246 //
 247 // Purpose:
 248 //   Primary interface to machine description for the UltraSPARC.
 249 //   Primarily just initializes machine-dependent parameters in
 250 //   class TargetMachine, and creates machine-dependent subclasses
 251 //   for classes such as MachineInstrInfo.
 252 //
 253 //---------------------------------------------------------------------------
 254
 255 UltraSparc::UltraSparc()
 256   : TargetMachine("UltraSparc-Native"),
 257     instrInfo(*this),
 258     schedInfo(*this),
 259     regInfo(*this),
 260     frameInfo(*this),
 261     cacheInfo(*this)
 262 {
 263   optSizeForSubWordData = 4;
 264   minMemOpWordSize = 8;
 265   maxAtomicMemOpWordSize = 8;
 266 }
 267
 268
 269 void
 270 ApplyPeepholeOptimizations(Method *method, TargetMachine &target)
 271 {
 272   return;
 273
 274   // OptimizeLeafProcedures();
 275   // DeleteFallThroughBranches();
 276   // RemoveChainedBranches();    // should be folded with previous
 277   // RemoveRedundantOps();       // operations with %g0, NOP, etc.
 278 }
 279
 280
 281
 282 bool
 283 UltraSparc::compileMethod(Method *method)
 284 {
 285   // Construct and initialize the MachineCodeForMethod object for this method.
 286   (void) MachineCodeForMethod::construct(method, *this);
 287
 288   if (SelectInstructionsForMethod(method, *this))
 289     {
 290       cerr << "Instruction selection failed for method " << method->getName()
 291            << "\n\n";
 292       return true;
 293     }
 294
 295   /*
 296   if (ScheduleInstructionsWithSSA(method, *this))
 297     {
 298       cerr << "Instruction scheduling before allocation failed for method "
 299            << method->getName() << "\n\n";
 300       return true;
 301     }
 302   */
 303
 304
 305   AllocateRegisters(method, *this);          // allocate registers
 306
 307   ApplyPeepholeOptimizations(method, *this); // machine-dependent peephole opts
 308
 309   InsertPrologEpilog(method, *this);
 310
 311   return false;
 312 }