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   unsigned getSubRegIndex(unsigned RegNo, unsigned SubRegNo) const;
00022 };
00023 
00024 namespace X86 { // Register classes
00025   enum {
00026     CCRRegClassID = 1,
00027     CONTROL_REG_32RegClassID = 2,
00028     CONTROL_REG_64RegClassID = 3,
00029     DEBUG_REGRegClassID = 4,
00030     FR32RegClassID = 5,
00031     FR64RegClassID = 6,
00032     GR16RegClassID = 7,
00033     GR16_ABCDRegClassID = 8,
00034     GR16_NOREXRegClassID = 9,
00035     GR32RegClassID = 10,
00036     GR32_ABCDRegClassID = 11,
00037     GR32_ADRegClassID = 12,
00038     GR32_NOREXRegClassID = 13,
00039     GR32_NOSPRegClassID = 14,
00040     GR64RegClassID = 15,
00041     GR64_ABCDRegClassID = 16,
00042     GR64_NOREXRegClassID = 17,
00043     GR64_NOREX_NOSPRegClassID = 18,
00044     GR64_NOSPRegClassID = 19,
00045     GR8RegClassID = 20,
00046     GR8_ABCD_HRegClassID = 21,
00047     GR8_ABCD_LRegClassID = 22,
00048     GR8_NOREXRegClassID = 23,
00049     RFP32RegClassID = 24,
00050     RFP64RegClassID = 25,
00051     RFP80RegClassID = 26,
00052     RSTRegClassID = 27,
00053     SEGMENT_REGRegClassID = 28,
00054     VR128RegClassID = 29,
00055     VR256RegClassID = 30,
00056     VR64RegClassID = 31
00057   };
00058 
00059   struct CCRClass : public TargetRegisterClass {
00060     CCRClass();
00061   };
00062   extern CCRClass CCRRegClass;
00063   static TargetRegisterClass * const CCRRegisterClass = &CCRRegClass;
00064   struct CONTROL_REG_32Class : public TargetRegisterClass {
00065     CONTROL_REG_32Class();
00066   };
00067   extern CONTROL_REG_32Class  CONTROL_REG_32RegClass;
00068   static TargetRegisterClass * const CONTROL_REG_32RegisterClass = &CONTROL_REG_32RegClass;
00069   struct CONTROL_REG_64Class : public TargetRegisterClass {
00070     CONTROL_REG_64Class();
00071   };
00072   extern CONTROL_REG_64Class  CONTROL_REG_64RegClass;
00073   static TargetRegisterClass * const CONTROL_REG_64RegisterClass = &CONTROL_REG_64RegClass;
00074   struct DEBUG_REGClass : public TargetRegisterClass {
00075     DEBUG_REGClass();
00076   };
00077   extern DEBUG_REGClass DEBUG_REGRegClass;
00078   static TargetRegisterClass * const DEBUG_REGRegisterClass = &DEBUG_REGRegClass;
00079   struct FR32Class : public TargetRegisterClass {
00080     FR32Class();
00081 
00082     iterator allocation_order_end(const MachineFunction &MF) const;
00083     };
00084   extern FR32Class  FR32RegClass;
00085   static TargetRegisterClass * const FR32RegisterClass = &FR32RegClass;
00086   struct FR64Class : public TargetRegisterClass {
00087     FR64Class();
00088 
00089     iterator allocation_order_end(const MachineFunction &MF) const;
00090     };
00091   extern FR64Class  FR64RegClass;
00092   static TargetRegisterClass * const FR64RegisterClass = &FR64RegClass;
00093   struct GR16Class : public TargetRegisterClass {
00094     GR16Class();
00095 
00096     iterator allocation_order_begin(const MachineFunction &MF) const;
00097     iterator allocation_order_end(const MachineFunction &MF) const;
00098     };
00099   extern GR16Class  GR16RegClass;
00100   static TargetRegisterClass * const GR16RegisterClass = &GR16RegClass;
00101   struct GR16_ABCDClass : public TargetRegisterClass {
00102     GR16_ABCDClass();
00103   };
00104   extern GR16_ABCDClass GR16_ABCDRegClass;
00105   static TargetRegisterClass * const GR16_ABCDRegisterClass = &GR16_ABCDRegClass;
00106   struct GR16_NOREXClass : public TargetRegisterClass {
00107     GR16_NOREXClass();
00108 
00109     iterator allocation_order_end(const MachineFunction &MF) const;
00110     };
00111   extern GR16_NOREXClass  GR16_NOREXRegClass;
00112   static TargetRegisterClass * const GR16_NOREXRegisterClass = &GR16_NOREXRegClass;
00113   struct GR32Class : public TargetRegisterClass {
00114     GR32Class();
00115 
00116     iterator allocation_order_begin(const MachineFunction &MF) const;
00117     iterator allocation_order_end(const MachineFunction &MF) const;
00118     };
00119   extern GR32Class  GR32RegClass;
00120   static TargetRegisterClass * const GR32RegisterClass = &GR32RegClass;
00121   struct GR32_ABCDClass : public TargetRegisterClass {
00122     GR32_ABCDClass();
00123   };
00124   extern GR32_ABCDClass GR32_ABCDRegClass;
00125   static TargetRegisterClass * const GR32_ABCDRegisterClass = &GR32_ABCDRegClass;
00126   struct GR32_ADClass : public TargetRegisterClass {
00127     GR32_ADClass();
00128   };
00129   extern GR32_ADClass GR32_ADRegClass;
00130   static TargetRegisterClass * const GR32_ADRegisterClass = &GR32_ADRegClass;
00131   struct GR32_NOREXClass : public TargetRegisterClass {
00132     GR32_NOREXClass();
00133 
00134     iterator allocation_order_end(const MachineFunction &MF) const;
00135     };
00136   extern GR32_NOREXClass  GR32_NOREXRegClass;
00137   static TargetRegisterClass * const GR32_NOREXRegisterClass = &GR32_NOREXRegClass;
00138   struct GR32_NOSPClass : public TargetRegisterClass {
00139     GR32_NOSPClass();
00140 
00141     iterator allocation_order_begin(const MachineFunction &MF) const;
00142     iterator allocation_order_end(const MachineFunction &MF) const;
00143     };
00144   extern GR32_NOSPClass GR32_NOSPRegClass;
00145   static TargetRegisterClass * const GR32_NOSPRegisterClass = &GR32_NOSPRegClass;
00146   struct GR64Class : public TargetRegisterClass {
00147     GR64Class();
00148 
00149     iterator allocation_order_end(const MachineFunction &MF) const;
00150     };
00151   extern GR64Class  GR64RegClass;
00152   static TargetRegisterClass * const GR64RegisterClass = &GR64RegClass;
00153   struct GR64_ABCDClass : public TargetRegisterClass {
00154     GR64_ABCDClass();
00155   };
00156   extern GR64_ABCDClass GR64_ABCDRegClass;
00157   static TargetRegisterClass * const GR64_ABCDRegisterClass = &GR64_ABCDRegClass;
00158   struct GR64_NOREXClass : public TargetRegisterClass {
00159     GR64_NOREXClass();
00160 
00161     iterator allocation_order_end(const MachineFunction &MF) const;
00162     };
00163   extern GR64_NOREXClass  GR64_NOREXRegClass;
00164   static TargetRegisterClass * const GR64_NOREXRegisterClass = &GR64_NOREXRegClass;
00165   struct GR64_NOREX_NOSPClass : public TargetRegisterClass {
00166     GR64_NOREX_NOSPClass();
00167 
00168     iterator allocation_order_end(const MachineFunction &MF) const;
00169     };
00170   extern GR64_NOREX_NOSPClass GR64_NOREX_NOSPRegClass;
00171   static TargetRegisterClass * const GR64_NOREX_NOSPRegisterClass = &GR64_NOREX_NOSPRegClass;
00172   struct GR64_NOSPClass : public TargetRegisterClass {
00173     GR64_NOSPClass();
00174 
00175     iterator allocation_order_end(const MachineFunction &MF) const;
00176     };
00177   extern GR64_NOSPClass GR64_NOSPRegClass;
00178   static TargetRegisterClass * const GR64_NOSPRegisterClass = &GR64_NOSPRegClass;
00179   struct GR8Class : public TargetRegisterClass {
00180     GR8Class();
00181 
00182     iterator allocation_order_begin(const MachineFunction &MF) const;
00183     iterator allocation_order_end(const MachineFunction &MF) const;
00184     };
00185   extern GR8Class GR8RegClass;
00186   static TargetRegisterClass * const GR8RegisterClass = &GR8RegClass;
00187   struct GR8_ABCD_HClass : public TargetRegisterClass {
00188     GR8_ABCD_HClass();
00189   };
00190   extern GR8_ABCD_HClass  GR8_ABCD_HRegClass;
00191   static TargetRegisterClass * const GR8_ABCD_HRegisterClass = &GR8_ABCD_HRegClass;
00192   struct GR8_ABCD_LClass : public TargetRegisterClass {
00193     GR8_ABCD_LClass();
00194   };
00195   extern GR8_ABCD_LClass  GR8_ABCD_LRegClass;
00196   static TargetRegisterClass * const GR8_ABCD_LRegisterClass = &GR8_ABCD_LRegClass;
00197   struct GR8_NOREXClass : public TargetRegisterClass {
00198     GR8_NOREXClass();
00199 
00200     iterator allocation_order_begin(const MachineFunction &MF) const;
00201     iterator allocation_order_end(const MachineFunction &MF) const;
00202     };
00203   extern GR8_NOREXClass GR8_NOREXRegClass;
00204   static TargetRegisterClass * const GR8_NOREXRegisterClass = &GR8_NOREXRegClass;
00205   struct RFP32Class : public TargetRegisterClass {
00206     RFP32Class();
00207   };
00208   extern RFP32Class RFP32RegClass;
00209   static TargetRegisterClass * const RFP32RegisterClass = &RFP32RegClass;
00210   struct RFP64Class : public TargetRegisterClass {
00211     RFP64Class();
00212   };
00213   extern RFP64Class RFP64RegClass;
00214   static TargetRegisterClass * const RFP64RegisterClass = &RFP64RegClass;
00215   struct RFP80Class : public TargetRegisterClass {
00216     RFP80Class();
00217   };
00218   extern RFP80Class RFP80RegClass;
00219   static TargetRegisterClass * const RFP80RegisterClass = &RFP80RegClass;
00220   struct RSTClass : public TargetRegisterClass {
00221     RSTClass();
00222 
00223     iterator allocation_order_end(const MachineFunction &MF) const;
00224     };
00225   extern RSTClass RSTRegClass;
00226   static TargetRegisterClass * const RSTRegisterClass = &RSTRegClass;
00227   struct SEGMENT_REGClass : public TargetRegisterClass {
00228     SEGMENT_REGClass();
00229   };
00230   extern SEGMENT_REGClass SEGMENT_REGRegClass;
00231   static TargetRegisterClass * const SEGMENT_REGRegisterClass = &SEGMENT_REGRegClass;
00232   struct VR128Class : public TargetRegisterClass {
00233     VR128Class();
00234 
00235     iterator allocation_order_end(const MachineFunction &MF) const;
00236     };
00237   extern VR128Class VR128RegClass;
00238   static TargetRegisterClass * const VR128RegisterClass = &VR128RegClass;
00239   struct VR256Class : public TargetRegisterClass {
00240     VR256Class();
00241   };
00242   extern VR256Class VR256RegClass;
00243   static TargetRegisterClass * const VR256RegisterClass = &VR256RegClass;
00244   struct VR64Class : public TargetRegisterClass {
00245     VR64Class();
00246   };
00247   extern VR64Class  VR64RegClass;
00248   static TargetRegisterClass * const VR64RegisterClass = &VR64RegClass;
00249 } // end of namespace X86
00250 
00251 } // End llvm namespace