include/llvm/Target/TargetRegisterInfo.h

   1 //=== Target/TargetRegisterInfo.h - Target Register Information -*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file describes an abstract interface used to get information about a
  11 // target machines register file.  This information is used for a variety of
  12 // purposed, especially register allocation.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_TARGET_TARGETREGISTERINFO_H
  17 #define LLVM_TARGET_TARGETREGISTERINFO_H
  18
  19 #include "llvm/MC/MCRegisterInfo.h"
  20 #include "llvm/CodeGen/MachineBasicBlock.h"
  21 #include "llvm/CodeGen/ValueTypes.h"
  22 #include "llvm/ADT/ArrayRef.h"
  23 #include "llvm/ADT/DenseSet.h"
  24 #include <cassert>
  25 #include <functional>
  26
  27 namespace llvm {
  28
  29 class BitVector;
  30 class MachineFunction;
  31 class MachineMove;
  32 class RegScavenger;
  33 template<class T> class SmallVectorImpl;
  34 class raw_ostream;
  35
  36 class TargetRegisterClass {
  37 public:
  38   typedef const unsigned* iterator;
  39   typedef const unsigned* const_iterator;
  40
  41   typedef const EVT* vt_iterator;
  42   typedef const TargetRegisterClass* const * sc_iterator;
  43 private:
  44   unsigned ID;
  45   const char *Name;
  46   const vt_iterator VTs;
  47   const sc_iterator SubClasses;
  48   const sc_iterator SuperClasses;
  49   const sc_iterator SubRegClasses;
  50   const sc_iterator SuperRegClasses;
  51   const unsigned RegSize, Alignment;    // Size & Alignment of register in bytes
  52   const int CopyCost;
  53   const bool Allocatable;
  54   const iterator RegsBegin, RegsEnd;
  55   DenseSet<unsigned> RegSet;
  56 public:
  57   TargetRegisterClass(unsigned id,
  58                       const char *name,
  59                       const EVT *vts,
  60                       const TargetRegisterClass * const *subcs,
  61                       const TargetRegisterClass * const *supcs,
  62                       const TargetRegisterClass * const *subregcs,
  63                       const TargetRegisterClass * const *superregcs,
  64                       unsigned RS, unsigned Al, int CC, bool Allocable,
  65                       iterator RB, iterator RE)
  66     : ID(id), Name(name), VTs(vts), SubClasses(subcs), SuperClasses(supcs),
  67     SubRegClasses(subregcs), SuperRegClasses(superregcs),
  68     RegSize(RS), Alignment(Al), CopyCost(CC), Allocatable(Allocable),
  69     RegsBegin(RB), RegsEnd(RE) {
  70       for (iterator I = RegsBegin, E = RegsEnd; I != E; ++I)
  71         RegSet.insert(*I);
  72     }
  73   virtual ~TargetRegisterClass() {}     // Allow subclasses
  74
  75   /// getID() - Return the register class ID number.
  76   ///
  77   unsigned getID() const { return ID; }
  78
  79   /// getName() - Return the register class name for debugging.
  80   ///
  81   const char *getName() const { return Name; }
  82
  83   /// begin/end - Return all of the registers in this class.
  84   ///
  85   iterator       begin() const { return RegsBegin; }
  86   iterator         end() const { return RegsEnd; }
  87
  88   /// getNumRegs - Return the number of registers in this class.
  89   ///
  90   unsigned getNumRegs() const { return (unsigned)(RegsEnd-RegsBegin); }
  91
  92   /// getRegister - Return the specified register in the class.
  93   ///
  94   unsigned getRegister(unsigned i) const {
  95     assert(i < getNumRegs() && "Register number out of range!");
  96     return RegsBegin[i];
  97   }
  98
  99   /// contains - Return true if the specified register is included in this
 100   /// register class.  This does not include virtual registers.
 101   bool contains(unsigned Reg) const {
 102     return RegSet.count(Reg);
 103   }
 104
 105   /// contains - Return true if both registers are in this class.
 106   bool contains(unsigned Reg1, unsigned Reg2) const {
 107     return contains(Reg1) && contains(Reg2);
 108   }
 109
 110   /// hasType - return true if this TargetRegisterClass has the ValueType vt.
 111   ///
 112   bool hasType(EVT vt) const {
 113     for(int i = 0; VTs[i] != MVT::Other; ++i)
 114       if (VTs[i] == vt)
 115         return true;
 116     return false;
 117   }
 118
 119   /// vt_begin / vt_end - Loop over all of the value types that can be
 120   /// represented by values in this register class.
 121   vt_iterator vt_begin() const {
 122     return VTs;
 123   }
 124
 125   vt_iterator vt_end() const {
 126     vt_iterator I = VTs;
 127     while (*I != MVT::Other) ++I;
 128     return I;
 129   }
 130
 131   /// subregclasses_begin / subregclasses_end - Loop over all of
 132   /// the subreg register classes of this register class.
 133   sc_iterator subregclasses_begin() const {
 134     return SubRegClasses;
 135   }
 136
 137   sc_iterator subregclasses_end() const {
 138     sc_iterator I = SubRegClasses;
 139     while (*I != NULL) ++I;
 140     return I;
 141   }
 142
 143   /// getSubRegisterRegClass - Return the register class of subregisters with
 144   /// index SubIdx, or NULL if no such class exists.
 145   const TargetRegisterClass* getSubRegisterRegClass(unsigned SubIdx) const {
 146     assert(SubIdx>0 && "Invalid subregister index");
 147     return SubRegClasses[SubIdx-1];
 148   }
 149
 150   /// superregclasses_begin / superregclasses_end - Loop over all of
 151   /// the superreg register classes of this register class.
 152   sc_iterator superregclasses_begin() const {
 153     return SuperRegClasses;
 154   }
 155
 156   sc_iterator superregclasses_end() const {
 157     sc_iterator I = SuperRegClasses;
 158     while (*I != NULL) ++I;
 159     return I;
 160   }
 161
 162   /// hasSubClass - return true if the specified TargetRegisterClass
 163   /// is a proper subset of this TargetRegisterClass.
 164   bool hasSubClass(const TargetRegisterClass *cs) const {
 165     for (int i = 0; SubClasses[i] != NULL; ++i)
 166       if (SubClasses[i] == cs)
 167         return true;
 168     return false;
 169   }
 170
 171   /// hasSubClassEq - Returns true if RC is a subclass of or equal to this
 172   /// class.
 173   bool hasSubClassEq(const TargetRegisterClass *RC) const {
 174     return RC == this || hasSubClass(RC);
 175   }
 176
 177   /// subclasses_begin / subclasses_end - Loop over all of the classes
 178   /// that are proper subsets of this register class.
 179   sc_iterator subclasses_begin() const {
 180     return SubClasses;
 181   }
 182
 183   sc_iterator subclasses_end() const {
 184     sc_iterator I = SubClasses;
 185     while (*I != NULL) ++I;
 186     return I;
 187   }
 188
 189   /// hasSuperClass - return true if the specified TargetRegisterClass is a
 190   /// proper superset of this TargetRegisterClass.
 191   bool hasSuperClass(const TargetRegisterClass *cs) const {
 192     for (int i = 0; SuperClasses[i] != NULL; ++i)
 193       if (SuperClasses[i] == cs)
 194         return true;
 195     return false;
 196   }
 197
 198   /// hasSuperClassEq - Returns true if RC is a superclass of or equal to this
 199   /// class.
 200   bool hasSuperClassEq(const TargetRegisterClass *RC) const {
 201     return RC == this || hasSuperClass(RC);
 202   }
 203
 204   /// superclasses_begin / superclasses_end - Loop over all of the classes
 205   /// that are proper supersets of this register class.
 206   sc_iterator superclasses_begin() const {
 207     return SuperClasses;
 208   }
 209
 210   sc_iterator superclasses_end() const {
 211     sc_iterator I = SuperClasses;
 212     while (*I != NULL) ++I;
 213     return I;
 214   }
 215
 216   /// isASubClass - return true if this TargetRegisterClass is a subset
 217   /// class of at least one other TargetRegisterClass.
 218   bool isASubClass() const {
 219     return SuperClasses[0] != 0;
 220   }
 221
 222   /// getRawAllocationOrder - Returns the preferred order for allocating
 223   /// registers from this register class in MF. The raw order comes directly
 224   /// from the .td file and may include reserved registers that are not
 225   /// allocatable. Register allocators should also make sure to allocate
 226   /// callee-saved registers only after all the volatiles are used. The
 227   /// RegisterClassInfo class provides filtered allocation orders with
 228   /// callee-saved registers moved to the end.
 229   ///
 230   /// The MachineFunction argument can be used to tune the allocatable
 231   /// registers based on the characteristics of the function, subtarget, or
 232   /// other criteria.
 233   ///
 234   /// By default, this method returns all registers in the class.
 235   ///
 236   virtual
 237   ArrayRef<unsigned> getRawAllocationOrder(const MachineFunction &MF) const {
 238     return ArrayRef<unsigned>(begin(), getNumRegs());
 239   }
 240
 241   /// getSize - Return the size of the register in bytes, which is also the size
 242   /// of a stack slot allocated to hold a spilled copy of this register.
 243   unsigned getSize() const { return RegSize; }
 244
 245   /// getAlignment - Return the minimum required alignment for a register of
 246   /// this class.
 247   unsigned getAlignment() const { return Alignment; }
 248
 249   /// getCopyCost - Return the cost of copying a value between two registers in
 250   /// this class. A negative number means the register class is very expensive
 251   /// to copy e.g. status flag register classes.
 252   int getCopyCost() const { return CopyCost; }
 253
 254   /// isAllocatable - Return true if this register class may be used to create
 255   /// virtual registers.
 256   bool isAllocatable() const { return Allocatable; }
 257 };
 258
 259 /// TargetRegisterInfoDesc - Extra information, not in MCRegisterDesc, about
 260 /// registers. These are used by codegen, not by MC.
 261 struct TargetRegisterInfoDesc {
 262   unsigned CostPerUse;          // Extra cost of instructions using register.
 263   bool inAllocatableClass;      // Register belongs to an allocatable regclass.
 264 };
 265
 266 /// TargetRegisterInfo base class - We assume that the target defines a static
 267 /// array of TargetRegisterDesc objects that represent all of the machine
 268 /// registers that the target has.  As such, we simply have to track a pointer
 269 /// to this array so that we can turn register number into a register
 270 /// descriptor.
 271 ///
 272 class TargetRegisterInfo : public MCRegisterInfo {
 273 public:
 274   typedef const TargetRegisterClass * const * regclass_iterator;
 275 private:
 276   const TargetRegisterInfoDesc *InfoDesc;     // Extra desc array for codegen
 277   const char *const *SubRegIndexNames;        // Names of subreg indexes.
 278   regclass_iterator RegClassBegin, RegClassEnd;   // List of regclasses
 279   int CallFrameSetupOpcode, CallFrameDestroyOpcode;
 280
 281 protected:
 282   TargetRegisterInfo(const TargetRegisterInfoDesc *ID,
 283                      regclass_iterator RegClassBegin,
 284                      regclass_iterator RegClassEnd,
 285                      const char *const *subregindexnames,
 286                      int CallFrameSetupOpcode = -1,
 287                      int CallFrameDestroyOpcode = -1);
 288   virtual ~TargetRegisterInfo();
 289 public:
 290
 291   // Register numbers can represent physical registers, virtual registers, and
 292   // sometimes stack slots. The unsigned values are divided into these ranges:
 293   //
 294   //   0           Not a register, can be used as a sentinel.
 295   //   [1;2^30)    Physical registers assigned by TableGen.
 296   //   [2^30;2^31) Stack slots. (Rarely used.)
 297   //   [2^31;2^32) Virtual registers assigned by MachineRegisterInfo.
 298   //
 299   // Further sentinels can be allocated from the small negative integers.
 300   // DenseMapInfo<unsigned> uses -1u and -2u.
 301
 302   /// isStackSlot - Sometimes it is useful the be able to store a non-negative
 303   /// frame index in a variable that normally holds a register. isStackSlot()
 304   /// returns true if Reg is in the range used for stack slots.
 305   ///
 306   /// Note that isVirtualRegister() and isPhysicalRegister() cannot handle stack
 307   /// slots, so if a variable may contains a stack slot, always check
 308   /// isStackSlot() first.
 309   ///
 310   static bool isStackSlot(unsigned Reg) {
 311     return int(Reg) >= (1 << 30);
 312   }
 313
 314   /// stackSlot2Index - Compute the frame index from a register value
 315   /// representing a stack slot.
 316   static int stackSlot2Index(unsigned Reg) {
 317     assert(isStackSlot(Reg) && "Not a stack slot");
 318     return int(Reg - (1u << 30));
 319   }
 320
 321   /// index2StackSlot - Convert a non-negative frame index to a stack slot
 322   /// register value.
 323   static unsigned index2StackSlot(int FI) {
 324     assert(FI >= 0 && "Cannot hold a negative frame index.");
 325     return FI + (1u << 30);
 326   }
 327
 328   /// isPhysicalRegister - Return true if the specified register number is in
 329   /// the physical register namespace.
 330   static bool isPhysicalRegister(unsigned Reg) {
 331     assert(!isStackSlot(Reg) && "Not a register! Check isStackSlot() first.");
 332     return int(Reg) > 0;
 333   }
 334
 335   /// isVirtualRegister - Return true if the specified register number is in
 336   /// the virtual register namespace.
 337   static bool isVirtualRegister(unsigned Reg) {
 338     assert(!isStackSlot(Reg) && "Not a register! Check isStackSlot() first.");
 339     return int(Reg) < 0;
 340   }
 341
 342   /// virtReg2Index - Convert a virtual register number to a 0-based index.
 343   /// The first virtual register in a function will get the index 0.
 344   static unsigned virtReg2Index(unsigned Reg) {
 345     assert(isVirtualRegister(Reg) && "Not a virtual register");
 346     return Reg & ~(1u << 31);
 347   }
 348
 349   /// index2VirtReg - Convert a 0-based index to a virtual register number.
 350   /// This is the inverse operation of VirtReg2IndexFunctor below.
 351   static unsigned index2VirtReg(unsigned Index) {
 352     return Index | (1u << 31);
 353   }
 354
 355   /// getMinimalPhysRegClass - Returns the Register Class of a physical
 356   /// register of the given type, picking the most sub register class of
 357   /// the right type that contains this physreg.
 358   const TargetRegisterClass *
 359     getMinimalPhysRegClass(unsigned Reg, EVT VT = MVT::Other) const;
 360
 361   /// getAllocatableSet - Returns a bitset indexed by register number
 362   /// indicating if a register is allocatable or not. If a register class is
 363   /// specified, returns the subset for the class.
 364   BitVector getAllocatableSet(const MachineFunction &MF,
 365                               const TargetRegisterClass *RC = NULL) const;
 366
 367   /// getCostPerUse - Return the additional cost of using this register instead
 368   /// of other registers in its class.
 369   unsigned getCostPerUse(unsigned RegNo) const {
 370     return InfoDesc[RegNo].CostPerUse;
 371   }
 372
 373   /// isInAllocatableClass - Return true if the register is in the allocation
 374   /// of any register class.
 375   bool isInAllocatableClass(unsigned RegNo) const {
 376     return InfoDesc[RegNo].inAllocatableClass;
 377   }
 378
 379   /// getSubRegIndexName - Return the human-readable symbolic target-specific
 380   /// name for the specified SubRegIndex.
 381   const char *getSubRegIndexName(unsigned SubIdx) const {
 382     assert(SubIdx && "This is not a subregister index");
 383     return SubRegIndexNames[SubIdx-1];
 384   }
 385
 386   /// regsOverlap - Returns true if the two registers are equal or alias each
 387   /// other. The registers may be virtual register.
 388   bool regsOverlap(unsigned regA, unsigned regB) const {
 389     if (regA == regB) return true;
 390     if (isVirtualRegister(regA) || isVirtualRegister(regB))
 391       return false;
 392     for (const unsigned *regList = getOverlaps(regA)+1; *regList; ++regList) {
 393       if (*regList == regB) return true;
 394     }
 395     return false;
 396   }
 397
 398   /// isSubRegister - Returns true if regB is a sub-register of regA.
 399   ///
 400   bool isSubRegister(unsigned regA, unsigned regB) const {
 401     return isSuperRegister(regB, regA);
 402   }
 403
 404   /// isSuperRegister - Returns true if regB is a super-register of regA.
 405   ///
 406   bool isSuperRegister(unsigned regA, unsigned regB) const {
 407     for (const unsigned *regList = getSuperRegisters(regA); *regList;++regList){
 408       if (*regList == regB) return true;
 409     }
 410     return false;
 411   }
 412
 413   /// getCalleeSavedRegs - Return a null-terminated list of all of the
 414   /// callee saved registers on this target. The register should be in the
 415   /// order of desired callee-save stack frame offset. The first register is
 416   /// closed to the incoming stack pointer if stack grows down, and vice versa.
 417   virtual const unsigned* getCalleeSavedRegs(const MachineFunction *MF = 0)
 418                                                                       const = 0;
 419
 420
 421   /// getReservedRegs - Returns a bitset indexed by physical register number
 422   /// indicating if a register is a special register that has particular uses
 423   /// and should be considered unavailable at all times, e.g. SP, RA. This is
 424   /// used by register scavenger to determine what registers are free.
 425   virtual BitVector getReservedRegs(const MachineFunction &MF) const = 0;
 426
 427   /// getSubReg - Returns the physical register number of sub-register "Index"
 428   /// for physical register RegNo. Return zero if the sub-register does not
 429   /// exist.
 430   virtual unsigned getSubReg(unsigned RegNo, unsigned Index) const = 0;
 431
 432   /// getSubRegIndex - For a given register pair, return the sub-register index
 433   /// if the second register is a sub-register of the first. Return zero
 434   /// otherwise.
 435   virtual unsigned getSubRegIndex(unsigned RegNo, unsigned SubRegNo) const = 0;
 436
 437   /// getMatchingSuperReg - Return a super-register of the specified register
 438   /// Reg so its sub-register of index SubIdx is Reg.
 439   unsigned getMatchingSuperReg(unsigned Reg, unsigned SubIdx,
 440                                const TargetRegisterClass *RC) const {
 441     for (const unsigned *SRs = getSuperRegisters(Reg); unsigned SR = *SRs;++SRs)
 442       if (Reg == getSubReg(SR, SubIdx) && RC->contains(SR))
 443         return SR;
 444     return 0;
 445   }
 446
 447   /// canCombineSubRegIndices - Given a register class and a list of
 448   /// subregister indices, return true if it's possible to combine the
 449   /// subregister indices into one that corresponds to a larger
 450   /// subregister. Return the new subregister index by reference. Note the
 451   /// new index may be zero if the given subregisters can be combined to
 452   /// form the whole register.
 453   virtual bool canCombineSubRegIndices(const TargetRegisterClass *RC,
 454                                        SmallVectorImpl<unsigned> &SubIndices,
 455                                        unsigned &NewSubIdx) const {
 456     return 0;
 457   }
 458
 459   /// getMatchingSuperRegClass - Return a subclass of the specified register
 460   /// class A so that each register in it has a sub-register of the
 461   /// specified sub-register index which is in the specified register class B.
 462   virtual const TargetRegisterClass *
 463   getMatchingSuperRegClass(const TargetRegisterClass *A,
 464                            const TargetRegisterClass *B, unsigned Idx) const {
 465     return 0;
 466   }
 467
 468   /// composeSubRegIndices - Return the subregister index you get from composing
 469   /// two subregister indices.
 470   ///
 471   /// If R:a:b is the same register as R:c, then composeSubRegIndices(a, b)
 472   /// returns c. Note that composeSubRegIndices does not tell you about illegal
 473   /// compositions. If R does not have a subreg a, or R:a does not have a subreg
 474   /// b, composeSubRegIndices doesn't tell you.
 475   ///
 476   /// The ARM register Q0 has two D subregs dsub_0:D0 and dsub_1:D1. It also has
 477   /// ssub_0:S0 - ssub_3:S3 subregs.
 478   /// If you compose subreg indices dsub_1, ssub_0 you get ssub_2.
 479   ///
 480   virtual unsigned composeSubRegIndices(unsigned a, unsigned b) const {
 481     // This default implementation is correct for most targets.
 482     return b;
 483   }
 484
 485   //===--------------------------------------------------------------------===//
 486   // Register Class Information
 487   //
 488
 489   /// Register class iterators
 490   ///
 491   regclass_iterator regclass_begin() const { return RegClassBegin; }
 492   regclass_iterator regclass_end() const { return RegClassEnd; }
 493
 494   unsigned getNumRegClasses() const {
 495     return (unsigned)(regclass_end()-regclass_begin());
 496   }
 497
 498   /// getRegClass - Returns the register class associated with the enumeration
 499   /// value.  See class TargetOperandInfo.
 500   const TargetRegisterClass *getRegClass(unsigned i) const {
 501     assert(i < getNumRegClasses() && "Register Class ID out of range");
 502     return RegClassBegin[i];
 503   }
 504
 505   /// getPointerRegClass - Returns a TargetRegisterClass used for pointer
 506   /// values.  If a target supports multiple different pointer register classes,
 507   /// kind specifies which one is indicated.
 508   virtual const TargetRegisterClass *getPointerRegClass(unsigned Kind=0) const {
 509     assert(0 && "Target didn't implement getPointerRegClass!");
 510     return 0; // Must return a value in order to compile with VS 2005
 511   }
 512
 513   /// getCrossCopyRegClass - Returns a legal register class to copy a register
 514   /// in the specified class to or from. If it is possible to copy the register
 515   /// directly without using a cross register class copy, return the specified
 516   /// RC. Returns NULL if it is not possible to copy between a two registers of
 517   /// the specified class.
 518   virtual const TargetRegisterClass *
 519   getCrossCopyRegClass(const TargetRegisterClass *RC) const {
 520     return RC;
 521   }
 522
 523   /// getLargestLegalSuperClass - Returns the largest super class of RC that is
 524   /// legal to use in the current sub-target and has the same spill size.
 525   /// The returned register class can be used to create virtual registers which
 526   /// means that all its registers can be copied and spilled.
 527   virtual const TargetRegisterClass*
 528   getLargestLegalSuperClass(const TargetRegisterClass *RC) const {
 529     /// The default implementation is very conservative and doesn't allow the
 530     /// register allocator to inflate register classes.
 531     return RC;
 532   }
 533
 534   /// getRegPressureLimit - Return the register pressure "high water mark" for
 535   /// the specific register class. The scheduler is in high register pressure
 536   /// mode (for the specific register class) if it goes over the limit.
 537   virtual unsigned getRegPressureLimit(const TargetRegisterClass *RC,
 538                                        MachineFunction &MF) const {
 539     return 0;
 540   }
 541
 542   /// getRawAllocationOrder - Returns the register allocation order for a
 543   /// specified register class with a target-dependent hint. The returned list
 544   /// may contain reserved registers that cannot be allocated.
 545   ///
 546   /// Register allocators need only call this function to resolve
 547   /// target-dependent hints, but it should work without hinting as well.
 548   virtual ArrayRef<unsigned>
 549   getRawAllocationOrder(const TargetRegisterClass *RC,
 550                         unsigned HintType, unsigned HintReg,
 551                         const MachineFunction &MF) const {
 552     return RC->getRawAllocationOrder(MF);
 553   }
 554
 555   /// ResolveRegAllocHint - Resolves the specified register allocation hint
 556   /// to a physical register. Returns the physical register if it is successful.
 557   virtual unsigned ResolveRegAllocHint(unsigned Type, unsigned Reg,
 558                                        const MachineFunction &MF) const {
 559     if (Type == 0 && Reg && isPhysicalRegister(Reg))
 560       return Reg;
 561     return 0;
 562   }
 563
 564   /// avoidWriteAfterWrite - Return true if the register allocator should avoid
 565   /// writing a register from RC in two consecutive instructions.
 566   /// This can avoid pipeline stalls on certain architectures.
 567   /// It does cause increased register pressure, though.
 568   virtual bool avoidWriteAfterWrite(const TargetRegisterClass *RC) const {
 569     return false;
 570   }
 571
 572   /// UpdateRegAllocHint - A callback to allow target a chance to update
 573   /// register allocation hints when a register is "changed" (e.g. coalesced)
 574   /// to another register. e.g. On ARM, some virtual registers should target
 575   /// register pairs, if one of pair is coalesced to another register, the
 576   /// allocation hint of the other half of the pair should be changed to point
 577   /// to the new register.
 578   virtual void UpdateRegAllocHint(unsigned Reg, unsigned NewReg,
 579                                   MachineFunction &MF) const {
 580     // Do nothing.
 581   }
 582
 583   /// requiresRegisterScavenging - returns true if the target requires (and can
 584   /// make use of) the register scavenger.
 585   virtual bool requiresRegisterScavenging(const MachineFunction &MF) const {
 586     return false;
 587   }
 588
 589   /// useFPForScavengingIndex - returns true if the target wants to use
 590   /// frame pointer based accesses to spill to the scavenger emergency spill
 591   /// slot.
 592   virtual bool useFPForScavengingIndex(const MachineFunction &MF) const {
 593     return true;
 594   }
 595
 596   /// requiresFrameIndexScavenging - returns true if the target requires post
 597   /// PEI scavenging of registers for materializing frame index constants.
 598   virtual bool requiresFrameIndexScavenging(const MachineFunction &MF) const {
 599     return false;
 600   }
 601
 602   /// requiresVirtualBaseRegisters - Returns true if the target wants the
 603   /// LocalStackAllocation pass to be run and virtual base registers
 604   /// used for more efficient stack access.
 605   virtual bool requiresVirtualBaseRegisters(const MachineFunction &MF) const {
 606     return false;
 607   }
 608
 609   /// hasReservedSpillSlot - Return true if target has reserved a spill slot in
 610   /// the stack frame of the given function for the specified register. e.g. On
 611   /// x86, if the frame register is required, the first fixed stack object is
 612   /// reserved as its spill slot. This tells PEI not to create a new stack frame
 613   /// object for the given register. It should be called only after
 614   /// processFunctionBeforeCalleeSavedScan().
 615   virtual bool hasReservedSpillSlot(const MachineFunction &MF, unsigned Reg,
 616                                     int &FrameIdx) const {
 617     return false;
 618   }
 619
 620   /// needsStackRealignment - true if storage within the function requires the
 621   /// stack pointer to be aligned more than the normal calling convention calls
 622   /// for.
 623   virtual bool needsStackRealignment(const MachineFunction &MF) const {
 624     return false;
 625   }
 626
 627   /// getFrameIndexInstrOffset - Get the offset from the referenced frame
 628   /// index in the instruction, if there is one.
 629   virtual int64_t getFrameIndexInstrOffset(const MachineInstr *MI,
 630                                            int Idx) const {
 631     return 0;
 632   }
 633
 634   /// needsFrameBaseReg - Returns true if the instruction's frame index
 635   /// reference would be better served by a base register other than FP
 636   /// or SP. Used by LocalStackFrameAllocation to determine which frame index
 637   /// references it should create new base registers for.
 638   virtual bool needsFrameBaseReg(MachineInstr *MI, int64_t Offset) const {
 639     return false;
 640   }
 641
 642   /// materializeFrameBaseRegister - Insert defining instruction(s) for
 643   /// BaseReg to be a pointer to FrameIdx before insertion point I.
 644   virtual void materializeFrameBaseRegister(MachineBasicBlock *MBB,
 645                                             unsigned BaseReg, int FrameIdx,
 646                                             int64_t Offset) const {
 647     assert(0 && "materializeFrameBaseRegister does not exist on this target");
 648   }
 649
 650   /// resolveFrameIndex - Resolve a frame index operand of an instruction
 651   /// to reference the indicated base register plus offset instead.
 652   virtual void resolveFrameIndex(MachineBasicBlock::iterator I,
 653                                  unsigned BaseReg, int64_t Offset) const {
 654     assert(0 && "resolveFrameIndex does not exist on this target");
 655   }
 656
 657   /// isFrameOffsetLegal - Determine whether a given offset immediate is
 658   /// encodable to resolve a frame index.
 659   virtual bool isFrameOffsetLegal(const MachineInstr *MI,
 660                                   int64_t Offset) const {
 661     assert(0 && "isFrameOffsetLegal does not exist on this target");
 662     return false; // Must return a value in order to compile with VS 2005
 663   }
 664
 665   /// getCallFrameSetup/DestroyOpcode - These methods return the opcode of the
 666   /// frame setup/destroy instructions if they exist (-1 otherwise).  Some
 667   /// targets use pseudo instructions in order to abstract away the difference
 668   /// between operating with a frame pointer and operating without, through the
 669   /// use of these two instructions.
 670   ///
 671   int getCallFrameSetupOpcode() const { return CallFrameSetupOpcode; }
 672   int getCallFrameDestroyOpcode() const { return CallFrameDestroyOpcode; }
 673
 674   /// eliminateCallFramePseudoInstr - This method is called during prolog/epilog
 675   /// code insertion to eliminate call frame setup and destroy pseudo
 676   /// instructions (but only if the Target is using them).  It is responsible
 677   /// for eliminating these instructions, replacing them with concrete
 678   /// instructions.  This method need only be implemented if using call frame
 679   /// setup/destroy pseudo instructions.
 680   ///
 681   virtual void
 682   eliminateCallFramePseudoInstr(MachineFunction &MF,
 683                                 MachineBasicBlock &MBB,
 684                                 MachineBasicBlock::iterator MI) const {
 685     assert(getCallFrameSetupOpcode()== -1 && getCallFrameDestroyOpcode()== -1 &&
 686            "eliminateCallFramePseudoInstr must be implemented if using"
 687            " call frame setup/destroy pseudo instructions!");
 688     assert(0 && "Call Frame Pseudo Instructions do not exist on this target!");
 689   }
 690
 691
 692   /// saveScavengerRegister - Spill the register so it can be used by the
 693   /// register scavenger. Return true if the register was spilled, false
 694   /// otherwise. If this function does not spill the register, the scavenger
 695   /// will instead spill it to the emergency spill slot.
 696   ///
 697   virtual bool saveScavengerRegister(MachineBasicBlock &MBB,
 698                                      MachineBasicBlock::iterator I,
 699                                      MachineBasicBlock::iterator &UseMI,
 700                                      const TargetRegisterClass *RC,
 701                                      unsigned Reg) const {
 702     return false;
 703   }
 704
 705   /// eliminateFrameIndex - This method must be overriden to eliminate abstract
 706   /// frame indices from instructions which may use them.  The instruction
 707   /// referenced by the iterator contains an MO_FrameIndex operand which must be
 708   /// eliminated by this method.  This method may modify or replace the
 709   /// specified instruction, as long as it keeps the iterator pointing at the
 710   /// finished product. SPAdj is the SP adjustment due to call frame setup
 711   /// instruction.
 712   virtual void eliminateFrameIndex(MachineBasicBlock::iterator MI,
 713                                    int SPAdj, RegScavenger *RS=NULL) const = 0;
 714
 715   //===--------------------------------------------------------------------===//
 716   /// Debug information queries.
 717
 718   /// getDwarfRegNum - Map a target register to an equivalent dwarf register
 719   /// number.  Returns -1 if there is no equivalent value.  The second
 720   /// parameter allows targets to use different numberings for EH info and
 721   /// debugging info.
 722   virtual int getDwarfRegNum(unsigned RegNum, bool isEH) const = 0;
 723
 724   virtual int getLLVMRegNum(unsigned RegNum, bool isEH) const = 0;
 725
 726   /// getFrameRegister - This method should return the register used as a base
 727   /// for values allocated in the current stack frame.
 728   virtual unsigned getFrameRegister(const MachineFunction &MF) const = 0;
 729
 730   /// getRARegister - This method should return the register where the return
 731   /// address can be found.
 732   virtual unsigned getRARegister() const = 0;
 733
 734   /// getSEHRegNum - Map a target register to an equivalent SEH register
 735   /// number.  Returns -1 if there is no equivalent value.
 736   virtual int getSEHRegNum(unsigned i) const {
 737     return i;
 738   }
 739 };
 740
 741
 742 // This is useful when building IndexedMaps keyed on virtual registers
 743 struct VirtReg2IndexFunctor : public std::unary_function<unsigned, unsigned> {
 744   unsigned operator()(unsigned Reg) const {
 745     return TargetRegisterInfo::virtReg2Index(Reg);
 746   }
 747 };
 748
 749 /// getCommonSubClass - find the largest common subclass of A and B. Return NULL
 750 /// if there is no common subclass.
 751 const TargetRegisterClass *getCommonSubClass(const TargetRegisterClass *A,
 752                                              const TargetRegisterClass *B);
 753
 754 /// PrintReg - Helper class for printing registers on a raw_ostream.
 755 /// Prints virtual and physical registers with or without a TRI instance.
 756 ///
 757 /// The format is:
 758 ///   %noreg          - NoRegister
 759 ///   %vreg5          - a virtual register.
 760 ///   %vreg5:sub_8bit - a virtual register with sub-register index (with TRI).
 761 ///   %EAX            - a physical register
 762 ///   %physreg17      - a physical register when no TRI instance given.
 763 ///
 764 /// Usage: OS << PrintReg(Reg, TRI) << '\n';
 765 ///
 766 class PrintReg {
 767   const TargetRegisterInfo *TRI;
 768   unsigned Reg;
 769   unsigned SubIdx;
 770 public:
 771   PrintReg(unsigned reg, const TargetRegisterInfo *tri = 0, unsigned subidx = 0)
 772     : TRI(tri), Reg(reg), SubIdx(subidx) {}
 773   void print(raw_ostream&) const;
 774 };
 775
 776 static inline raw_ostream &operator<<(raw_ostream &OS, const PrintReg &PR) {
 777   PR.print(OS);
 778   return OS;
 779 }
 780
 781 } // End llvm namespace
 782
 783 #endif