LLVM API Documentation

X86GenRegisterInfo.h.inc

Go to the documentation of this file.
00001 //===- TableGen'erated file -------------------------------------*- C++ -*-===//
00002 //
00003 // Register Information Header Fragment
00004 //
00005 // Automatically generated file, do not edit!
00006 //
00007 //===----------------------------------------------------------------------===//
00008 
00009 #include "llvm/Target/TargetRegisterInfo.h"
00010 #include <string>
00011 
00012 namespace llvm {
00013 
00014 struct X86GenRegisterInfo : public TargetRegisterInfo {
00015   explicit X86GenRegisterInfo(int CallFrameSetupOpcode = -1, int CallFrameDestroyOpcode = -1);
00016   virtual int getDwarfRegNumFull(unsigned RegNum, unsigned Flavour) const;
00017   virtual int getDwarfRegNum(unsigned RegNum, bool isEH) const = 0;
00018   virtual bool needsStackRealignment(const MachineFunction &) const
00019      { return false; }
00020   unsigned getSubReg(unsigned RegNo, unsigned Index) const;
00021 };
00022 
00023 namespace X86 { // Register classes
00024   enum {
00025     CCRRegClassID = 1,
00026     FR32RegClassID = 2,
00027     FR64RegClassID = 3,
00028     GR16RegClassID = 4,
00029     GR16_ABCDRegClassID = 5,
00030     GR16_NOREXRegClassID = 6,
00031     GR32RegClassID = 7,
00032     GR32_ABCDRegClassID = 8,
00033     GR32_ADRegClassID = 9,
00034     GR32_NOREXRegClassID = 10,
00035     GR32_NOSPRegClassID = 11,
00036     GR64RegClassID = 12,
00037     GR64_ABCDRegClassID = 13,
00038     GR64_NOREXRegClassID = 14,
00039     GR64_NOREX_NOSPRegClassID = 15,
00040     GR64_NOSPRegClassID = 16,
00041     GR8RegClassID = 17,
00042     GR8_ABCD_HRegClassID = 18,
00043     GR8_ABCD_LRegClassID = 19,
00044     GR8_NOREXRegClassID = 20,
00045     RFP32RegClassID = 21,
00046     RFP64RegClassID = 22,
00047     RFP80RegClassID = 23,
00048     RSTRegClassID = 24,
00049     VR128RegClassID = 25,
00050     VR256RegClassID = 26,
00051     VR64RegClassID = 27
00052   };
00053 
00054   struct CCRClass : public TargetRegisterClass {
00055     CCRClass();
00056   };
00057   extern CCRClass CCRRegClass;
00058   static TargetRegisterClass * const CCRRegisterClass = &CCRRegClass;
00059   struct FR32Class : public TargetRegisterClass {
00060     FR32Class();
00061 
00062     iterator allocation_order_end(const MachineFunction &MF) const;
00063     };
00064   extern FR32Class  FR32RegClass;
00065   static TargetRegisterClass * const FR32RegisterClass = &FR32RegClass;
00066   struct FR64Class : public TargetRegisterClass {
00067     FR64Class();
00068 
00069     iterator allocation_order_end(const MachineFunction &MF) const;
00070     };
00071   extern FR64Class  FR64RegClass;
00072   static TargetRegisterClass * const FR64RegisterClass = &FR64RegClass;
00073   struct GR16Class : public TargetRegisterClass {
00074     GR16Class();
00075 
00076     iterator allocation_order_begin(const MachineFunction &MF) const;
00077     iterator allocation_order_end(const MachineFunction &MF) const;
00078     };
00079   extern GR16Class  GR16RegClass;
00080   static TargetRegisterClass * const GR16RegisterClass = &GR16RegClass;
00081   struct GR16_ABCDClass : public TargetRegisterClass {
00082     GR16_ABCDClass();
00083   };
00084   extern GR16_ABCDClass GR16_ABCDRegClass;
00085   static TargetRegisterClass * const GR16_ABCDRegisterClass = &GR16_ABCDRegClass;
00086   struct GR16_NOREXClass : public TargetRegisterClass {
00087     GR16_NOREXClass();
00088 
00089     iterator allocation_order_end(const MachineFunction &MF) const;
00090     };
00091   extern GR16_NOREXClass  GR16_NOREXRegClass;
00092   static TargetRegisterClass * const GR16_NOREXRegisterClass = &GR16_NOREXRegClass;
00093   struct GR32Class : public TargetRegisterClass {
00094     GR32Class();
00095 
00096     iterator allocation_order_begin(const MachineFunction &MF) const;
00097     iterator allocation_order_end(const MachineFunction &MF) const;
00098     };
00099   extern GR32Class  GR32RegClass;
00100   static TargetRegisterClass * const GR32RegisterClass = &GR32RegClass;
00101   struct GR32_ABCDClass : public TargetRegisterClass {
00102     GR32_ABCDClass();
00103   };
00104   extern GR32_ABCDClass GR32_ABCDRegClass;
00105   static TargetRegisterClass * const GR32_ABCDRegisterClass = &GR32_ABCDRegClass;
00106   struct GR32_ADClass : public TargetRegisterClass {
00107     GR32_ADClass();
00108   };
00109   extern GR32_ADClass GR32_ADRegClass;
00110   static TargetRegisterClass * const GR32_ADRegisterClass = &GR32_ADRegClass;
00111   struct GR32_NOREXClass : public TargetRegisterClass {
00112     GR32_NOREXClass();
00113 
00114     iterator allocation_order_end(const MachineFunction &MF) const;
00115     };
00116   extern GR32_NOREXClass  GR32_NOREXRegClass;
00117   static TargetRegisterClass * const GR32_NOREXRegisterClass = &GR32_NOREXRegClass;
00118   struct GR32_NOSPClass : public TargetRegisterClass {
00119     GR32_NOSPClass();
00120 
00121     iterator allocation_order_begin(const MachineFunction &MF) const;
00122     iterator allocation_order_end(const MachineFunction &MF) const;
00123     };
00124   extern GR32_NOSPClass GR32_NOSPRegClass;
00125   static TargetRegisterClass * const GR32_NOSPRegisterClass = &GR32_NOSPRegClass;
00126   struct GR64Class : public TargetRegisterClass {
00127     GR64Class();
00128 
00129     iterator allocation_order_end(const MachineFunction &MF) const;
00130     };
00131   extern GR64Class  GR64RegClass;
00132   static TargetRegisterClass * const GR64RegisterClass = &GR64RegClass;
00133   struct GR64_ABCDClass : public TargetRegisterClass {
00134     GR64_ABCDClass();
00135   };
00136   extern GR64_ABCDClass GR64_ABCDRegClass;
00137   static TargetRegisterClass * const GR64_ABCDRegisterClass = &GR64_ABCDRegClass;
00138   struct GR64_NOREXClass : public TargetRegisterClass {
00139     GR64_NOREXClass();
00140 
00141     iterator allocation_order_end(const MachineFunction &MF) const;
00142     };
00143   extern GR64_NOREXClass  GR64_NOREXRegClass;
00144   static TargetRegisterClass * const GR64_NOREXRegisterClass = &GR64_NOREXRegClass;
00145   struct GR64_NOREX_NOSPClass : public TargetRegisterClass {
00146     GR64_NOREX_NOSPClass();
00147 
00148     iterator allocation_order_end(const MachineFunction &MF) const;
00149     };
00150   extern GR64_NOREX_NOSPClass GR64_NOREX_NOSPRegClass;
00151   static TargetRegisterClass * const GR64_NOREX_NOSPRegisterClass = &GR64_NOREX_NOSPRegClass;
00152   struct GR64_NOSPClass : public TargetRegisterClass {
00153     GR64_NOSPClass();
00154 
00155     iterator allocation_order_end(const MachineFunction &MF) const;
00156     };
00157   extern GR64_NOSPClass GR64_NOSPRegClass;
00158   static TargetRegisterClass * const GR64_NOSPRegisterClass = &GR64_NOSPRegClass;
00159   struct GR8Class : public TargetRegisterClass {
00160     GR8Class();
00161 
00162     iterator allocation_order_begin(const MachineFunction &MF) const;
00163     iterator allocation_order_end(const MachineFunction &MF) const;
00164     };
00165   extern GR8Class GR8RegClass;
00166   static TargetRegisterClass * const GR8RegisterClass = &GR8RegClass;
00167   struct GR8_ABCD_HClass : public TargetRegisterClass {
00168     GR8_ABCD_HClass();
00169   };
00170   extern GR8_ABCD_HClass  GR8_ABCD_HRegClass;
00171   static TargetRegisterClass * const GR8_ABCD_HRegisterClass = &GR8_ABCD_HRegClass;
00172   struct GR8_ABCD_LClass : public TargetRegisterClass {
00173     GR8_ABCD_LClass();
00174   };
00175   extern GR8_ABCD_LClass  GR8_ABCD_LRegClass;
00176   static TargetRegisterClass * const GR8_ABCD_LRegisterClass = &GR8_ABCD_LRegClass;
00177   struct GR8_NOREXClass : public TargetRegisterClass {
00178     GR8_NOREXClass();
00179 
00180     iterator allocation_order_begin(const MachineFunction &MF) const;
00181     iterator allocation_order_end(const MachineFunction &MF) const;
00182     };
00183   extern GR8_NOREXClass GR8_NOREXRegClass;
00184   static TargetRegisterClass * const GR8_NOREXRegisterClass = &GR8_NOREXRegClass;
00185   struct RFP32Class : public TargetRegisterClass {
00186     RFP32Class();
00187   };
00188   extern RFP32Class RFP32RegClass;
00189   static TargetRegisterClass * const RFP32RegisterClass = &RFP32RegClass;
00190   struct RFP64Class : public TargetRegisterClass {
00191     RFP64Class();
00192   };
00193   extern RFP64Class RFP64RegClass;
00194   static TargetRegisterClass * const RFP64RegisterClass = &RFP64RegClass;
00195   struct RFP80Class : public TargetRegisterClass {
00196     RFP80Class();
00197   };
00198   extern RFP80Class RFP80RegClass;
00199   static TargetRegisterClass * const RFP80RegisterClass = &RFP80RegClass;
00200   struct RSTClass : public TargetRegisterClass {
00201     RSTClass();
00202 
00203     iterator allocation_order_end(const MachineFunction &MF) const;
00204     };
00205   extern RSTClass RSTRegClass;
00206   static TargetRegisterClass * const RSTRegisterClass = &RSTRegClass;
00207   struct VR128Class : public TargetRegisterClass {
00208     VR128Class();
00209 
00210     iterator allocation_order_end(const MachineFunction &MF) const;
00211     };
00212   extern VR128Class VR128RegClass;
00213   static TargetRegisterClass * const VR128RegisterClass = &VR128RegClass;
00214   struct VR256Class : public TargetRegisterClass {
00215     VR256Class();
00216   };
00217   extern VR256Class VR256RegClass;
00218   static TargetRegisterClass * const VR256RegisterClass = &VR256RegClass;
00219   struct VR64Class : public TargetRegisterClass {
00220     VR64Class();
00221   };
00222   extern VR64Class  VR64RegClass;
00223   static TargetRegisterClass * const VR64RegisterClass = &VR64RegClass;
00224 } // end of namespace X86
00225 
00226 } // End llvm namespace