lib/Target/Alpha/AlphaRegisterInfo.td

   1 //===- AlphaRegisterInfo.td - The Alpha Register File ------*- tablegen -*-===//
   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 describes the Alpha register set.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 class AlphaReg<string n> : Register<n> {
  15   field bits<5> Num;
  16   let Namespace = "Alpha";
  17 }
  18
  19 // We identify all our registers with a 5-bit ID, for consistency's sake.
  20
  21 // GPR - One of the 32 32-bit general-purpose registers
  22 class GPR<bits<5> num, string n> : AlphaReg<n> {
  23   let Num = num;
  24 }
  25
  26 // FPR - One of the 32 64-bit floating-point registers
  27 class FPR<bits<5> num, string n> : AlphaReg<n> {
  28   let Num = num;
  29 }
  30
  31 //#define FP    $15
  32 //#define RA    $26
  33 //#define PV    $27
  34 //#define GP    $29
  35 //#define SP    $30
  36
  37 // General-purpose registers
  38 def R0  : GPR< 0,  "$0">, DwarfRegNum<0>;
  39 def R1  : GPR< 1,  "$1">, DwarfRegNum<1>;
  40 def R2  : GPR< 2,  "$2">, DwarfRegNum<2>;
  41 def R3  : GPR< 3,  "$3">, DwarfRegNum<3>;
  42 def R4  : GPR< 4,  "$4">, DwarfRegNum<4>;
  43 def R5  : GPR< 5,  "$5">, DwarfRegNum<5>;
  44 def R6  : GPR< 6,  "$6">, DwarfRegNum<6>;
  45 def R7  : GPR< 7,  "$7">, DwarfRegNum<7>;
  46 def R8  : GPR< 8,  "$8">, DwarfRegNum<8>;
  47 def R9  : GPR< 9,  "$9">, DwarfRegNum<9>;
  48 def R10 : GPR<10, "$10">, DwarfRegNum<10>;
  49 def R11 : GPR<11, "$11">, DwarfRegNum<11>;
  50 def R12 : GPR<12, "$12">, DwarfRegNum<12>;
  51 def R13 : GPR<13, "$13">, DwarfRegNum<13>;
  52 def R14 : GPR<14, "$14">, DwarfRegNum<14>;
  53 def R15 : GPR<15, "$15">, DwarfRegNum<15>;
  54 def R16 : GPR<16, "$16">, DwarfRegNum<16>;
  55 def R17 : GPR<17, "$17">, DwarfRegNum<17>;
  56 def R18 : GPR<18, "$18">, DwarfRegNum<18>;
  57 def R19 : GPR<19, "$19">, DwarfRegNum<19>;
  58 def R20 : GPR<20, "$20">, DwarfRegNum<20>;
  59 def R21 : GPR<21, "$21">, DwarfRegNum<21>;
  60 def R22 : GPR<22, "$22">, DwarfRegNum<22>;
  61 def R23 : GPR<23, "$23">, DwarfRegNum<23>;
  62 def R24 : GPR<24, "$24">, DwarfRegNum<24>;
  63 def R25 : GPR<25, "$25">, DwarfRegNum<25>;
  64 def R26 : GPR<26, "$26">, DwarfRegNum<26>;
  65 def R27 : GPR<27, "$27">, DwarfRegNum<27>;
  66 def R28 : GPR<28, "$28">, DwarfRegNum<28>;
  67 def R29 : GPR<29, "$29">, DwarfRegNum<29>;
  68 def R30 : GPR<30, "$30">, DwarfRegNum<30>;
  69 def R31 : GPR<31, "$31">, DwarfRegNum<31>;
  70
  71 // Floating-point registers
  72 def F0  : FPR< 0,  "$f0">, DwarfRegNum<33>;
  73 def F1  : FPR< 1,  "$f1">, DwarfRegNum<34>;
  74 def F2  : FPR< 2,  "$f2">, DwarfRegNum<35>;
  75 def F3  : FPR< 3,  "$f3">, DwarfRegNum<36>;
  76 def F4  : FPR< 4,  "$f4">, DwarfRegNum<37>;
  77 def F5  : FPR< 5,  "$f5">, DwarfRegNum<38>;
  78 def F6  : FPR< 6,  "$f6">, DwarfRegNum<39>;
  79 def F7  : FPR< 7,  "$f7">, DwarfRegNum<40>;
  80 def F8  : FPR< 8,  "$f8">, DwarfRegNum<41>;
  81 def F9  : FPR< 9,  "$f9">, DwarfRegNum<42>;
  82 def F10 : FPR<10, "$f10">, DwarfRegNum<43>;
  83 def F11 : FPR<11, "$f11">, DwarfRegNum<44>;
  84 def F12 : FPR<12, "$f12">, DwarfRegNum<45>;
  85 def F13 : FPR<13, "$f13">, DwarfRegNum<46>;
  86 def F14 : FPR<14, "$f14">, DwarfRegNum<47>;
  87 def F15 : FPR<15, "$f15">, DwarfRegNum<48>;
  88 def F16 : FPR<16, "$f16">, DwarfRegNum<49>;
  89 def F17 : FPR<17, "$f17">, DwarfRegNum<50>;
  90 def F18 : FPR<18, "$f18">, DwarfRegNum<51>;
  91 def F19 : FPR<19, "$f19">, DwarfRegNum<52>;
  92 def F20 : FPR<20, "$f20">, DwarfRegNum<53>;
  93 def F21 : FPR<21, "$f21">, DwarfRegNum<54>;
  94 def F22 : FPR<22, "$f22">, DwarfRegNum<55>;
  95 def F23 : FPR<23, "$f23">, DwarfRegNum<56>;
  96 def F24 : FPR<24, "$f24">, DwarfRegNum<57>;
  97 def F25 : FPR<25, "$f25">, DwarfRegNum<58>;
  98 def F26 : FPR<26, "$f26">, DwarfRegNum<59>;
  99 def F27 : FPR<27, "$f27">, DwarfRegNum<60>;
 100 def F28 : FPR<28, "$f28">, DwarfRegNum<61>;
 101 def F29 : FPR<29, "$f29">, DwarfRegNum<62>;
 102 def F30 : FPR<30, "$f30">, DwarfRegNum<63>;
 103 def F31 : FPR<31, "$f31">, DwarfRegNum<64>;
 104
 105   // //#define FP    $15
 106   // //#define RA    $26
 107   // //#define PV    $27
 108   // //#define GP    $29
 109   // //#define SP    $30
 110   // $28 is undefined after any and all calls
 111
 112 /// Register classes
 113 def GPRC : RegisterClass<"Alpha", [i64], 64,
 114      // Volatile
 115      [R0, R1, R2, R3, R4, R5, R6, R7, R8, R16, R17, R18, R19, R20, R21, R22,
 116       R23, R24, R25, R28,
 117      //Special meaning, but volatile
 118      R27, //procedure address
 119      R26, //return address
 120      R29, //global offset table address
 121      // Non-volatile
 122      R9, R10, R11, R12, R13, R14,
 123 // Don't allocate 15, 30, 31
 124      R15, R30, R31 ]> //zero
 125 {
 126   let MethodProtos = [{
 127     iterator allocation_order_end(const MachineFunction &MF) const;
 128   }];
 129   let MethodBodies = [{
 130     GPRCClass::iterator
 131     GPRCClass::allocation_order_end(const MachineFunction &MF) const {
 132         return end()-3;
 133     }
 134   }];
 135 }
 136
 137 def F4RC : RegisterClass<"Alpha", [f32], 64, [F0, F1,
 138         F10, F11, F12, F13, F14, F15, F16, F17, F18, F19,
 139         F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30,
 140         // Saved:
 141         F2, F3, F4, F5, F6, F7, F8, F9,
 142         F31 ]> //zero
 143 {
 144   let MethodProtos = [{
 145     iterator allocation_order_end(const MachineFunction &MF) const;
 146   }];
 147   let MethodBodies = [{
 148     F4RCClass::iterator
 149     F4RCClass::allocation_order_end(const MachineFunction &MF) const {
 150         return end()-1;
 151     }
 152   }];
 153 }
 154
 155 def F8RC : RegisterClass<"Alpha", [f64], 64, [F0, F1,
 156         F10, F11, F12, F13, F14, F15, F16, F17, F18, F19,
 157         F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30,
 158         // Saved:
 159         F2, F3, F4, F5, F6, F7, F8, F9,
 160         F31 ]> //zero
 161 {
 162   let MethodProtos = [{
 163     iterator allocation_order_end(const MachineFunction &MF) const;
 164   }];
 165   let MethodBodies = [{
 166     F8RCClass::iterator
 167     F8RCClass::allocation_order_end(const MachineFunction &MF) const {
 168         return end()-1;
 169     }
 170   }];
 171 }