lib/Target/SparcV9/SparcV9Internals.h

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