lib/Target/SparcV9/SparcV9Internals.h

   1 //===-- SparcInternals.h ----------------------------------------*- C++ -*-===//
   2 //
   3 // This file defines stuff that is to be private to the Sparc backend, but is
   4 // shared among different portions of the backend.
   5 //
   6 //===----------------------------------------------------------------------===//
   7
   8 #ifndef SPARC_INTERNALS_H
   9 #define SPARC_INTERNALS_H
  10
  11 #include "llvm/Target/TargetMachine.h"
  12 #include "llvm/Target/MachineSchedInfo.h"
  13 #include "llvm/Target/MachineFrameInfo.h"
  14 #include "llvm/Target/MachineCacheInfo.h"
  15 #include "llvm/Target/MachineRegInfo.h"
  16 #include "llvm/Target/MachineOptInfo.h"
  17 #include "llvm/Type.h"
  18 #include <sys/types.h>
  19
  20 class LiveRange;
  21 class UltraSparc;
  22 class PhyRegAlloc;
  23 class Pass;
  24
  25 enum SparcInstrSchedClass {
  26   SPARC_NONE,           /* Instructions with no scheduling restrictions */
  27   SPARC_IEUN,           /* Integer class that can use IEU0 or IEU1 */
  28   SPARC_IEU0,           /* Integer class IEU0 */
  29   SPARC_IEU1,           /* Integer class IEU1 */
  30   SPARC_FPM,            /* FP Multiply or Divide instructions */
  31   SPARC_FPA,            /* All other FP instructions */
  32   SPARC_CTI,            /* Control-transfer instructions */
  33   SPARC_LD,             /* Load instructions */
  34   SPARC_ST,             /* Store instructions */
  35   SPARC_SINGLE,         /* Instructions that must issue by themselves */
  36
  37   SPARC_INV,            /* This should stay at the end for the next value */
  38   SPARC_NUM_SCHED_CLASSES = SPARC_INV
  39 };
  40
  41
  42 //---------------------------------------------------------------------------
  43 // enum SparcMachineOpCode.
  44 // const MachineInstrDescriptor SparcMachineInstrDesc[]
  45 //
  46 // Purpose:
  47 //   Description of UltraSparc machine instructions.
  48 //
  49 //---------------------------------------------------------------------------
  50
  51 enum SparcMachineOpCode {
  52 #define I(ENUM, OPCODESTRING, NUMOPERANDS, RESULTPOS, MAXIMM, IMMSE, \
  53           NUMDELAYSLOTS, LATENCY, SCHEDCLASS, INSTFLAGS)             \
  54    ENUM,
  55 #include "SparcInstr.def"
  56
  57   // End-of-array marker
  58   INVALID_OPCODE,
  59   NUM_REAL_OPCODES = PHI,               // number of valid opcodes
  60   NUM_TOTAL_OPCODES = INVALID_OPCODE
  61 };
  62
  63
  64 // Array of machine instruction descriptions...
  65 extern const MachineInstrDescriptor SparcMachineInstrDesc[];
  66
  67
  68 //---------------------------------------------------------------------------
  69 // class UltraSparcInstrInfo
  70 //
  71 // Purpose:
  72 //   Information about individual instructions.
  73 //   Most information is stored in the SparcMachineInstrDesc array above.
  74 //   Other information is computed on demand, and most such functions
  75 //   default to member functions in base class MachineInstrInfo.
  76 //---------------------------------------------------------------------------
  77
  78 struct UltraSparcInstrInfo : public MachineInstrInfo {
  79   UltraSparcInstrInfo();
  80
  81   //
  82   // All immediate constants are in position 1 except the
  83   // store instructions and SETxx.
  84   //
  85   virtual int getImmedConstantPos(MachineOpCode opCode) const {
  86     bool ignore;
  87     if (this->maxImmedConstant(opCode, ignore) != 0)
  88       {
  89         assert(! this->isStore((MachineOpCode) STB - 1)); // 1st  store opcode
  90         assert(! this->isStore((MachineOpCode) STXFSR+1));// last store opcode
  91         if (opCode==SETSW || opCode==SETUW || opCode==SETX || opCode==SETHI)
  92           return 0;
  93         if (opCode >= STB && opCode <= STXFSR)
  94           return 2;
  95         return 1;
  96       }
  97     else
  98       return -1;
  99   }
 100
 101   virtual bool          hasResultInterlock      (MachineOpCode opCode) const
 102   {
 103     // All UltraSPARC instructions have interlocks (note that delay slots
 104     // are not considered here).
 105     // However, instructions that use the result of an FCMP produce a
 106     // 9-cycle stall if they are issued less than 3 cycles after the FCMP.
 107     // Force the compiler to insert a software interlock (i.e., gap of
 108     // 2 other groups, including NOPs if necessary).
 109     return (opCode == FCMPS || opCode == FCMPD || opCode == FCMPQ);
 110   }
 111
 112   //-------------------------------------------------------------------------
 113   // Queries about representation of LLVM quantities (e.g., constants)
 114   //-------------------------------------------------------------------------
 115
 116   virtual bool ConstantMayNotFitInImmedField(const Constant* CV,
 117                                              const Instruction* I) const;
 118
 119   //-------------------------------------------------------------------------
 120   // Code generation support for creating individual machine instructions
 121   //-------------------------------------------------------------------------
 122
 123   // Get certain common op codes for the current target.  This and all the
 124   // Create* methods below should be moved to a machine code generation class
 125   //
 126   virtual MachineOpCode getNOPOpCode() const { return NOP; }
 127
 128   // Create an instruction sequence to put the constant `val' into
 129   // the virtual register `dest'.  `val' may be a Constant or a
 130   // GlobalValue, viz., the constant address of a global variable or function.
 131   // The generated instructions are returned in `mvec'.
 132   // Any temp. registers (TmpInstruction) created are recorded in mcfi.
 133   // Any stack space required is allocated via mcff.
 134   //
 135   virtual void  CreateCodeToLoadConst(const TargetMachine& target,
 136                                       Function* F,
 137                                       Value* val,
 138                                       Instruction* dest,
 139                                       std::vector<MachineInstr*>& mvec,
 140                                       MachineCodeForInstruction& mcfi) const;
 141
 142   // Create an instruction sequence to copy an integer value `val'
 143   // to a floating point value `dest' by copying to memory and back.
 144   // val must be an integral type.  dest must be a Float or Double.
 145   // The generated instructions are returned in `mvec'.
 146   // Any temp. registers (TmpInstruction) created are recorded in mcfi.
 147   // Any stack space required is allocated via mcff.
 148   //
 149   virtual void  CreateCodeToCopyIntToFloat(const TargetMachine& target,
 150                                        Function* F,
 151                                        Value* val,
 152                                        Instruction* dest,
 153                                        std::vector<MachineInstr*>& mvec,
 154                                        MachineCodeForInstruction& mcfi) const;
 155
 156   // Similarly, create an instruction sequence to copy an FP value
 157   // `val' to an integer value `dest' by copying to memory and back.
 158   // The generated instructions are returned in `mvec'.
 159   // Any temp. registers (TmpInstruction) created are recorded in mcfi.
 160   // Any stack space required is allocated via mcff.
 161   //
 162   virtual void  CreateCodeToCopyFloatToInt(const TargetMachine& target,
 163                                        Function* F,
 164                                        Value* val,
 165                                        Instruction* dest,
 166                                        std::vector<MachineInstr*>& mvec,
 167                                        MachineCodeForInstruction& mcfi) const;
 168
 169   // Create instruction(s) to copy src to dest, for arbitrary types
 170   // The generated instructions are returned in `mvec'.
 171   // Any temp. registers (TmpInstruction) created are recorded in mcfi.
 172   // Any stack space required is allocated via mcff.
 173   //
 174   virtual void CreateCopyInstructionsByType(const TargetMachine& target,
 175                                        Function* F,
 176                                        Value* src,
 177                                        Instruction* dest,
 178                                        std::vector<MachineInstr*>& mvec,
 179                                        MachineCodeForInstruction& mcfi) const;
 180
 181   // Create instruction sequence to produce a sign-extended register value
 182   // from an arbitrary sized value (sized in bits, not bytes).
 183   // The generated instructions are appended to `mvec'.
 184   // Any temp. registers (TmpInstruction) created are recorded in mcfi.
 185   // Any stack space required is allocated via mcff.
 186   //
 187   virtual void CreateSignExtensionInstructions(const TargetMachine& target,
 188                                        Function* F,
 189                                        Value* srcVal,
 190                                        Value* destVal,
 191                                        unsigned int numLowBits,
 192                                        std::vector<MachineInstr*>& mvec,
 193                                        MachineCodeForInstruction& mcfi) const;
 194
 195   // Create instruction sequence to produce a zero-extended register value
 196   // from an arbitrary sized value (sized in bits, not bytes).
 197   // The generated instructions are appended to `mvec'.
 198   // Any temp. registers (TmpInstruction) created are recorded in mcfi.
 199   // Any stack space required is allocated via mcff.
 200   //
 201   virtual void CreateZeroExtensionInstructions(const TargetMachine& target,
 202                                        Function* F,
 203                                        Value* srcVal,
 204                                        Value* destVal,
 205                                        unsigned int numLowBits,
 206                                        std::vector<MachineInstr*>& mvec,
 207                                        MachineCodeForInstruction& mcfi) const;
 208 };
 209
 210
 211 //----------------------------------------------------------------------------
 212 // class UltraSparcRegInfo
 213 //
 214 // This class implements the virtual class MachineRegInfo for Sparc.
 215 //
 216 //----------------------------------------------------------------------------
 217
 218 class UltraSparcRegInfo : public MachineRegInfo {
 219   // The actual register classes in the Sparc
 220   //
 221   enum RegClassIDs {
 222     IntRegClassID,                      // Integer
 223     FloatRegClassID,                    // Float (both single/double)
 224     IntCCRegClassID,                    // Int Condition Code
 225     FloatCCRegClassID                   // Float Condition code
 226   };
 227
 228
 229   // Type of registers available in Sparc. There can be several reg types
 230   // in the same class. For instace, the float reg class has Single/Double
 231   // types
 232   //
 233   enum RegTypes {
 234     IntRegType,
 235     FPSingleRegType,
 236     FPDoubleRegType,
 237     IntCCRegType,
 238     FloatCCRegType
 239   };
 240
 241   // **** WARNING: If the above enum order is changed, also modify
 242   // getRegisterClassOfValue method below since it assumes this particular
 243   // order for efficiency.
 244
 245
 246   // Number of registers used for passing int args (usually 6: %o0 - %o5)
 247   //
 248   unsigned const NumOfIntArgRegs;
 249
 250   // Number of registers used for passing float args (usually 32: %f0 - %f31)
 251   //
 252   unsigned const NumOfFloatArgRegs;
 253
 254   // An out of bound register number that can be used to initialize register
 255   // numbers. Useful for error detection.
 256   //
 257   int const InvalidRegNum;
 258
 259
 260   // ========================  Private Methods =============================
 261
 262   // The following methods are used to color special live ranges (e.g.
 263   // function args and return values etc.) with specific hardware registers
 264   // as required. See SparcRegInfo.cpp for the implementation.
 265   //
 266   void suggestReg4RetAddr(MachineInstr *RetMI,
 267                           LiveRangeInfo &LRI) const;
 268
 269   void suggestReg4CallAddr(MachineInstr *CallMI, LiveRangeInfo &LRI) const;
 270
 271   void InitializeOutgoingArg(MachineInstr* CallMI, AddedInstrns *CallAI,
 272                              PhyRegAlloc &PRA, LiveRange* LR,
 273                              unsigned regType, unsigned RegClassID,
 274                              int  UniArgReg, unsigned int argNo,
 275                              std::vector<MachineInstr *>& AddedInstrnsBefore)
 276     const;
 277
 278   // The following 4 methods are used to find the RegType (see enum above)
 279   // for a reg class and a given primitive type, a LiveRange, a Value,
 280   // or a particular machine register.
 281   // The fifth function gives the reg class of the given RegType.
 282   //
 283   int getRegType(unsigned regClassID, const Type* type) const;
 284   int getRegType(const LiveRange *LR) const;
 285   int getRegType(const Value *Val) const;
 286   int getRegType(int unifiedRegNum) const;
 287
 288   // Used to generate a copy instruction based on the register class of
 289   // value.
 290   //
 291   MachineInstr *cpValue2RegMI(Value *Val,  unsigned DestReg,
 292                               int RegType) const;
 293
 294
 295   // The following 2 methods are used to order the instructions addeed by
 296   // the register allocator in association with function calling. See
 297   // SparcRegInfo.cpp for more details
 298   //
 299   void moveInst2OrdVec(std::vector<MachineInstr *> &OrdVec,
 300                        MachineInstr *UnordInst,
 301                        PhyRegAlloc &PRA) const;
 302
 303   void OrderAddedInstrns(std::vector<MachineInstr *> &UnordVec,
 304                          std::vector<MachineInstr *> &OrdVec,
 305                          PhyRegAlloc &PRA) const;
 306
 307
 308   // Compute which register can be used for an argument, if any
 309   //
 310   int regNumForIntArg(bool inCallee, bool isVarArgsCall,
 311                       unsigned argNo, unsigned intArgNo, unsigned fpArgNo,
 312                       unsigned& regClassId) const;
 313
 314   int regNumForFPArg(unsigned RegType, bool inCallee, bool isVarArgsCall,
 315                      unsigned argNo, unsigned intArgNo, unsigned fpArgNo,
 316                      unsigned& regClassId) const;
 317
 318 public:
 319   UltraSparcRegInfo(const UltraSparc &tgt);
 320
 321   // To find the register class used for a specified Type
 322   //
 323   unsigned getRegClassIDOfType(const Type *type,
 324                                bool isCCReg = false) const;
 325
 326   // To find the register class of a Value
 327   //
 328   inline unsigned getRegClassIDOfValue(const Value *Val,
 329                                        bool isCCReg = false) const {
 330     return getRegClassIDOfType(Val->getType(), isCCReg);
 331   }
 332
 333   // To find the register class to which a specified register belongs
 334   //
 335   unsigned getRegClassIDOfReg(int unifiedRegNum) const;
 336   unsigned getRegClassIDOfRegType(int regType) const;
 337
 338   // getZeroRegNum - returns the register that contains always zero this is the
 339   // unified register number
 340   //
 341   virtual int getZeroRegNum() const;
 342
 343   // getCallAddressReg - returns the reg used for pushing the address when a
 344   // function is called. This can be used for other purposes between calls
 345   //
 346   unsigned getCallAddressReg() const;
 347
 348   // Returns the register containing the return address.
 349   // It should be made sure that this  register contains the return
 350   // value when a return instruction is reached.
 351   //
 352   unsigned getReturnAddressReg() const;
 353
 354   // Number of registers used for passing int args (usually 6: %o0 - %o5)
 355   // and float args (usually 32: %f0 - %f31)
 356   //
 357   unsigned const GetNumOfIntArgRegs() const   { return NumOfIntArgRegs; }
 358   unsigned const GetNumOfFloatArgRegs() const { return NumOfFloatArgRegs; }
 359
 360   // The following methods are used to color special live ranges (e.g.
 361   // function args and return values etc.) with specific hardware registers
 362   // as required. See SparcRegInfo.cpp for the implementation for Sparc.
 363   //
 364   void suggestRegs4MethodArgs(const Function *Meth,
 365                               LiveRangeInfo& LRI) const;
 366
 367   void suggestRegs4CallArgs(MachineInstr *CallMI,
 368                             LiveRangeInfo& LRI) const;
 369
 370   void suggestReg4RetValue(MachineInstr *RetMI,
 371                            LiveRangeInfo& LRI) const;
 372
 373   void colorMethodArgs(const Function *Meth,  LiveRangeInfo &LRI,
 374                        AddedInstrns *FirstAI) const;
 375
 376   void colorCallArgs(MachineInstr *CallMI, LiveRangeInfo &LRI,
 377                      AddedInstrns *CallAI,  PhyRegAlloc &PRA,
 378                      const BasicBlock *BB) const;
 379
 380   void colorRetValue(MachineInstr *RetI,   LiveRangeInfo& LRI,
 381                      AddedInstrns *RetAI) const;
 382
 383
 384   // method used for printing a register for debugging purposes
 385   //
 386   static void printReg(const LiveRange *LR);
 387
 388   // Each register class has a seperate space for register IDs. To convert
 389   // a regId in a register class to a common Id, or vice versa,
 390   // we use the folloing methods.
 391   //
 392   // This method provides a unique number for each register
 393   inline int getUnifiedRegNum(unsigned regClassID, int reg) const {
 394
 395     if (regClassID == IntRegClassID) {
 396       assert(reg < 32 && "Invalid reg. number");
 397       return reg;
 398     }
 399     else if (regClassID == FloatRegClassID) {
 400       assert(reg < 64 && "Invalid reg. number");
 401       return reg + 32;                  // we have 32 int regs
 402     }
 403     else if (regClassID == FloatCCRegClassID) {
 404       assert(reg < 4 && "Invalid reg. number");
 405       return reg + 32 + 64;             // 32 int, 64 float
 406     }
 407     else if (regClassID == IntCCRegClassID ) {
 408       assert(reg == 0 && "Invalid reg. number");
 409       return reg + 4+ 32 + 64;          // only one int CC reg
 410     }
 411     else if (reg==InvalidRegNum) {
 412       return InvalidRegNum;
 413     }
 414     else
 415       assert(0 && "Invalid register class");
 416     return 0;
 417   }
 418
 419   // This method converts the unified number to the number in its class,
 420   // and returns the class ID in regClassID.
 421   inline int getClassRegNum(int ureg, unsigned& regClassID) const {
 422     if      (ureg < 32)     { regClassID = IntRegClassID;     return ureg;    }
 423     else if (ureg < 32+64)  { regClassID = FloatRegClassID;   return ureg-32; }
 424     else if (ureg < 4 +96)  { regClassID = FloatCCRegClassID; return ureg-96; }
 425     else if (ureg < 1 +100) { regClassID = IntCCRegClassID;   return ureg-100;}
 426     else if (ureg == InvalidRegNum) { return InvalidRegNum; }
 427     else { assert(0 && "Invalid unified register number"); }
 428     return 0;
 429   }
 430
 431   // Returns the assembly-language name of the specified machine register.
 432   //
 433   virtual const char * const getUnifiedRegName(int reg) const;
 434
 435
 436   // returns the # of bytes of stack space allocated for each register
 437   // type. For Sparc, currently we allocate 8 bytes on stack for all
 438   // register types. We can optimize this later if necessary to save stack
 439   // space (However, should make sure that stack alignment is correct)
 440   //
 441   inline int getSpilledRegSize(int RegType) const {
 442     return 8;
 443   }
 444
 445
 446   // To obtain the return value and the indirect call address (if any)
 447   // contained in a CALL machine instruction
 448   //
 449   const Value * getCallInstRetVal(const MachineInstr *CallMI) const;
 450   const Value * getCallInstIndirectAddrVal(const MachineInstr *CallMI) const;
 451
 452   // The following methods are used to generate "copy" machine instructions
 453   // for an architecture.
 454   //
 455   // The function regTypeNeedsScratchReg() can be used to check whether a
 456   // scratch register is needed to copy a register of type `regType' to
 457   // or from memory.  If so, such a scratch register can be provided by
 458   // the caller (e.g., if it knows which regsiters are free); otherwise
 459   // an arbitrary one will be chosen and spilled by the copy instructions.
 460   //
 461   bool regTypeNeedsScratchReg(int RegType,
 462                               int& scratchRegClassId) const;
 463
 464   void cpReg2RegMI(std::vector<MachineInstr*>& mvec,
 465                    unsigned SrcReg, unsigned DestReg,
 466                    int RegType) const;
 467
 468   void cpReg2MemMI(std::vector<MachineInstr*>& mvec,
 469                    unsigned SrcReg, unsigned DestPtrReg,
 470                    int Offset, int RegType, int scratchReg = -1) const;
 471
 472   void cpMem2RegMI(std::vector<MachineInstr*>& mvec,
 473                    unsigned SrcPtrReg, int Offset, unsigned DestReg,
 474                    int RegType, int scratchReg = -1) const;
 475
 476   void cpValue2Value(Value *Src, Value *Dest,
 477                      std::vector<MachineInstr*>& mvec) const;
 478
 479   // To see whether a register is a volatile (i.e., whehter it must be
 480   // preserved acorss calls)
 481   //
 482   inline bool isRegVolatile(int RegClassID, int Reg) const {
 483     return MachineRegClassArr[RegClassID]->isRegVolatile(Reg);
 484   }
 485
 486
 487   virtual unsigned getFramePointer() const;
 488   virtual unsigned getStackPointer() const;
 489
 490   virtual int getInvalidRegNum() const {
 491     return InvalidRegNum;
 492   }
 493
 494   // This method inserts the caller saving code for call instructions
 495   //
 496   void insertCallerSavingCode(std::vector<MachineInstr*>& instrnsBefore,
 497                               std::vector<MachineInstr*>& instrnsAfter,
 498                               MachineInstr *MInst,
 499                               const BasicBlock *BB, PhyRegAlloc &PRA ) const;
 500 };
 501
 502
 503
 504
 505 //---------------------------------------------------------------------------
 506 // class UltraSparcSchedInfo
 507 //
 508 // Purpose:
 509 //   Interface to instruction scheduling information for UltraSPARC.
 510 //   The parameter values above are based on UltraSPARC IIi.
 511 //---------------------------------------------------------------------------
 512
 513
 514 class UltraSparcSchedInfo: public MachineSchedInfo {
 515 public:
 516   UltraSparcSchedInfo(const TargetMachine &tgt);
 517 protected:
 518   virtual void initializeResources();
 519 };
 520
 521
 522 //---------------------------------------------------------------------------
 523 // class UltraSparcFrameInfo
 524 //
 525 // Purpose:
 526 //   Interface to stack frame layout info for the UltraSPARC.
 527 //   Starting offsets for each area of the stack frame are aligned at
 528 //   a multiple of getStackFrameSizeAlignment().
 529 //---------------------------------------------------------------------------
 530
 531 class UltraSparcFrameInfo: public MachineFrameInfo {
 532 public:
 533   UltraSparcFrameInfo(const TargetMachine &tgt) : MachineFrameInfo(tgt) {}
 534
 535 public:
 536   // These methods provide constant parameters of the frame layout.
 537   //
 538   int  getStackFrameSizeAlignment() const { return StackFrameSizeAlignment;}
 539   int  getMinStackFrameSize()       const { return MinStackFrameSize; }
 540   int  getNumFixedOutgoingArgs()    const { return NumFixedOutgoingArgs; }
 541   int  getSizeOfEachArgOnStack()    const { return SizeOfEachArgOnStack; }
 542   bool argsOnStackHaveFixedSize()   const { return true; }
 543
 544   // This method adjusts a stack offset to meet alignment rules of target.
 545   // The fixed OFFSET (0x7ff) must be subtracted and the result aligned.
 546   virtual int  adjustAlignment                  (int unalignedOffset,
 547                                                  bool growUp,
 548                                                  unsigned int align) const {
 549     return unalignedOffset + (growUp? +1:-1)*((unalignedOffset-OFFSET) % align);
 550   }
 551
 552   // These methods compute offsets using the frame contents for a
 553   // particular function.  The frame contents are obtained from the
 554   // MachineCodeInfoForMethod object for the given function.
 555   //
 556   int getFirstIncomingArgOffset  (MachineFunction& mcInfo,
 557                                   bool& growUp) const
 558   {
 559     growUp = true;                         // arguments area grows upwards
 560     return FirstIncomingArgOffsetFromFP;
 561   }
 562   int getFirstOutgoingArgOffset  (MachineFunction& mcInfo,
 563                                   bool& growUp) const
 564   {
 565     growUp = true;                         // arguments area grows upwards
 566     return FirstOutgoingArgOffsetFromSP;
 567   }
 568   int getFirstOptionalOutgoingArgOffset(MachineFunction& mcInfo,
 569                                         bool& growUp)const
 570   {
 571     growUp = true;                         // arguments area grows upwards
 572     return FirstOptionalOutgoingArgOffsetFromSP;
 573   }
 574
 575   int getFirstAutomaticVarOffset (MachineFunction& mcInfo,
 576                                   bool& growUp) const;
 577   int getRegSpillAreaOffset      (MachineFunction& mcInfo,
 578                                   bool& growUp) const;
 579   int getTmpAreaOffset           (MachineFunction& mcInfo,
 580                                   bool& growUp) const;
 581   int getDynamicAreaOffset       (MachineFunction& mcInfo,
 582                                   bool& growUp) const;
 583
 584   //
 585   // These methods specify the base register used for each stack area
 586   // (generally FP or SP)
 587   //
 588   virtual int getIncomingArgBaseRegNum()               const {
 589     return (int) target.getRegInfo().getFramePointer();
 590   }
 591   virtual int getOutgoingArgBaseRegNum()               const {
 592     return (int) target.getRegInfo().getStackPointer();
 593   }
 594   virtual int getOptionalOutgoingArgBaseRegNum()       const {
 595     return (int) target.getRegInfo().getStackPointer();
 596   }
 597   virtual int getAutomaticVarBaseRegNum()              const {
 598     return (int) target.getRegInfo().getFramePointer();
 599   }
 600   virtual int getRegSpillAreaBaseRegNum()              const {
 601     return (int) target.getRegInfo().getFramePointer();
 602   }
 603   virtual int getDynamicAreaBaseRegNum()               const {
 604     return (int) target.getRegInfo().getStackPointer();
 605   }
 606
 607 private:
 608   /*----------------------------------------------------------------------
 609     This diagram shows the stack frame layout used by llc on Sparc V9.
 610     Note that only the location of automatic variables, spill area,
 611     temporary storage, and dynamically allocated stack area are chosen
 612     by us.  The rest conform to the Sparc V9 ABI.
 613     All stack addresses are offset by OFFSET = 0x7ff (2047).
 614
 615     Alignment assumpteions and other invariants:
 616     (1) %sp+OFFSET and %fp+OFFSET are always aligned on 16-byte boundary
 617     (2) Variables in automatic, spill, temporary, or dynamic regions
 618         are aligned according to their size as in all memory accesses.
 619     (3) Everything below the dynamically allocated stack area is only used
 620         during a call to another function, so it is never needed when
 621         the current function is active.  This is why space can be allocated
 622         dynamically by incrementing %sp any time within the function.
 623
 624     STACK FRAME LAYOUT:
 625
 626        ...
 627        %fp+OFFSET+176      Optional extra incoming arguments# 1..N
 628        %fp+OFFSET+168      Incoming argument #6
 629        ...                 ...
 630        %fp+OFFSET+128      Incoming argument #1
 631        ...                 ...
 632     ---%fp+OFFSET-0--------Bottom of caller's stack frame--------------------
 633        %fp+OFFSET-8        Automatic variables <-- ****TOP OF STACK FRAME****
 634                            Spill area
 635                            Temporary storage
 636        ...
 637
 638        %sp+OFFSET+176+8N   Bottom of dynamically allocated stack area
 639        %sp+OFFSET+168+8N   Optional extra outgoing argument# N
 640        ...                 ...
 641        %sp+OFFSET+176      Optional extra outgoing argument# 1
 642        %sp+OFFSET+168      Outgoing argument #6
 643        ...                 ...
 644        %sp+OFFSET+128      Outgoing argument #1
 645        %sp+OFFSET+120      Save area for %i7
 646        ...                 ...
 647        %sp+OFFSET+0        Save area for %l0 <-- ****BOTTOM OF STACK FRAME****
 648
 649    *----------------------------------------------------------------------*/
 650
 651   // All stack addresses must be offset by 0x7ff (2047) on Sparc V9.
 652   static const int OFFSET                                  = (int) 0x7ff;
 653   static const int StackFrameSizeAlignment                 =  16;
 654   static const int MinStackFrameSize                       = 176;
 655   static const int NumFixedOutgoingArgs                    =   6;
 656   static const int SizeOfEachArgOnStack                    =   8;
 657   static const int FirstIncomingArgOffsetFromFP            = 128 + OFFSET;
 658   static const int FirstOptionalIncomingArgOffsetFromFP    = 176 + OFFSET;
 659   static const int StaticAreaOffsetFromFP                  =   0 + OFFSET;
 660   static const int FirstOutgoingArgOffsetFromSP            = 128 + OFFSET;
 661   static const int FirstOptionalOutgoingArgOffsetFromSP    = 176 + OFFSET;
 662 };
 663
 664
 665 //---------------------------------------------------------------------------
 666 // class UltraSparcCacheInfo
 667 //
 668 // Purpose:
 669 //   Interface to cache parameters for the UltraSPARC.
 670 //   Just use defaults for now.
 671 //---------------------------------------------------------------------------
 672
 673 class UltraSparcCacheInfo: public MachineCacheInfo {
 674 public:
 675   UltraSparcCacheInfo(const TargetMachine &T) : MachineCacheInfo(T) {}
 676 };
 677
 678
 679 //---------------------------------------------------------------------------
 680 // class UltraSparcOptInfo
 681 //
 682 // Purpose:
 683 //   Interface to machine-level optimization routines for the UltraSPARC.
 684 //---------------------------------------------------------------------------
 685
 686 class UltraSparcOptInfo: public MachineOptInfo {
 687 public:
 688   UltraSparcOptInfo(const TargetMachine &T) : MachineOptInfo(T) {}
 689
 690   virtual bool IsUselessCopy    (const MachineInstr* MI) const;
 691 };
 692
 693
 694 //---------------------------------------------------------------------------
 695 // class UltraSparcMachine
 696 //
 697 // Purpose:
 698 //   Primary interface to machine description for the UltraSPARC.
 699 //   Primarily just initializes machine-dependent parameters in
 700 //   class TargetMachine, and creates machine-dependent subclasses
 701 //   for classes such as InstrInfo, SchedInfo and RegInfo.
 702 //---------------------------------------------------------------------------
 703
 704 class UltraSparc : public TargetMachine {
 705   UltraSparcInstrInfo instrInfo;
 706   UltraSparcSchedInfo schedInfo;
 707   UltraSparcRegInfo   regInfo;
 708   UltraSparcFrameInfo frameInfo;
 709   UltraSparcCacheInfo cacheInfo;
 710   UltraSparcOptInfo   optInfo;
 711 public:
 712   UltraSparc();
 713
 714   virtual const MachineInstrInfo &getInstrInfo() const { return instrInfo; }
 715   virtual const MachineSchedInfo &getSchedInfo() const { return schedInfo; }
 716   virtual const MachineRegInfo   &getRegInfo()   const { return regInfo; }
 717   virtual const MachineFrameInfo &getFrameInfo() const { return frameInfo; }
 718   virtual const MachineCacheInfo &getCacheInfo() const { return cacheInfo; }
 719   virtual const MachineOptInfo   &getOptInfo()   const { return optInfo; }
 720
 721   virtual void addPassesToEmitAssembly(PassManager &PM, std::ostream &Out);
 722
 723   // getPrologEpilogCodeInserter - Inserts prolog/epilog code.
 724   virtual Pass* getPrologEpilogInsertionPass();
 725
 726   // getFunctionAsmPrinterPass - Writes out machine code for a single function
 727   virtual Pass* getFunctionAsmPrinterPass(std::ostream &Out);
 728
 729   // getModuleAsmPrinterPass - Writes generated machine code to assembly file.
 730   virtual Pass* getModuleAsmPrinterPass(std::ostream &Out);
 731
 732   // getEmitBytecodeToAsmPass - Emits final LLVM bytecode to assembly file.
 733   virtual Pass* getEmitBytecodeToAsmPass(std::ostream &Out);
 734 };
 735
 736 #endif