lib/Target/MBlaze/MBlazeRegisterInfo.td

   1 //===- MBlazeRegisterInfo.td - MBlaze Register defs --------*- tablegen -*-===//
   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 //===----------------------------------------------------------------------===//
  11 //  Declarations that describe the MicroBlaze register file
  12 //===----------------------------------------------------------------------===//
  13
  14 // We have banks of 32 registers each.
  15 class MBlazeReg<string n> : Register<n> {
  16   field bits<5> Num;
  17   let Namespace = "MBlaze";
  18 }
  19
  20 // MBlaze CPU Registers
  21 class MBlazeGPRReg<bits<5> num, string n> : MBlazeReg<n> {
  22   let Num = num;
  23 }
  24
  25 // MBlaze 32-bit (aliased) FPU Registers
  26 /*
  27 class FPR<bits<5> num, string n, list<Register> aliases> : MBlazeReg<n> {
  28   let Num = num;
  29   let Aliases = aliases;
  30 }
  31 */
  32
  33 //===----------------------------------------------------------------------===//
  34 //  Registers
  35 //===----------------------------------------------------------------------===//
  36
  37 let Namespace = "MBlaze" in {
  38
  39   // General Purpose Registers
  40   def R0  : MBlazeGPRReg< 0,  "r0">,   DwarfRegNum<[0]>;
  41   def R1  : MBlazeGPRReg< 1,  "r1">,   DwarfRegNum<[1]>;
  42   def R2  : MBlazeGPRReg< 2,  "r2">,   DwarfRegNum<[2]>;
  43   def R3  : MBlazeGPRReg< 3,  "r3">,   DwarfRegNum<[3]>;
  44   def R4  : MBlazeGPRReg< 4,  "r4">,   DwarfRegNum<[5]>;
  45   def R5  : MBlazeGPRReg< 5,  "r5">,   DwarfRegNum<[5]>;
  46   def R6  : MBlazeGPRReg< 6,  "r6">,   DwarfRegNum<[6]>;
  47   def R7  : MBlazeGPRReg< 7,  "r7">,   DwarfRegNum<[7]>;
  48   def R8  : MBlazeGPRReg< 8,  "r8">,   DwarfRegNum<[8]>;
  49   def R9  : MBlazeGPRReg< 9,  "r9">,   DwarfRegNum<[9]>;
  50   def R10 : MBlazeGPRReg< 10, "r10">,  DwarfRegNum<[10]>;
  51   def R11 : MBlazeGPRReg< 11, "r11">,  DwarfRegNum<[11]>;
  52   def R12 : MBlazeGPRReg< 12, "r12">,  DwarfRegNum<[12]>;
  53   def R13 : MBlazeGPRReg< 13, "r13">,  DwarfRegNum<[13]>;
  54   def R14 : MBlazeGPRReg< 14, "r14">,  DwarfRegNum<[14]>;
  55   def R15 : MBlazeGPRReg< 15, "r15">,  DwarfRegNum<[15]>;
  56   def R16 : MBlazeGPRReg< 16, "r16">,  DwarfRegNum<[16]>;
  57   def R17 : MBlazeGPRReg< 17, "r17">,  DwarfRegNum<[17]>;
  58   def R18 : MBlazeGPRReg< 18, "r18">,  DwarfRegNum<[18]>;
  59   def R19 : MBlazeGPRReg< 19, "r19">,  DwarfRegNum<[19]>;
  60   def R20 : MBlazeGPRReg< 20, "r20">,  DwarfRegNum<[20]>;
  61   def R21 : MBlazeGPRReg< 21, "r21">,  DwarfRegNum<[21]>;
  62   def R22 : MBlazeGPRReg< 22, "r22">,  DwarfRegNum<[22]>;
  63   def R23 : MBlazeGPRReg< 23, "r23">,  DwarfRegNum<[23]>;
  64   def R24 : MBlazeGPRReg< 24, "r24">,  DwarfRegNum<[24]>;
  65   def R25 : MBlazeGPRReg< 25, "r25">,  DwarfRegNum<[25]>;
  66   def R26 : MBlazeGPRReg< 26, "r26">,  DwarfRegNum<[26]>;
  67   def R27 : MBlazeGPRReg< 27, "r27">,  DwarfRegNum<[27]>;
  68   def R28 : MBlazeGPRReg< 28, "r28">,  DwarfRegNum<[28]>;
  69   def R29 : MBlazeGPRReg< 29, "r29">,  DwarfRegNum<[29]>;
  70   def R30 : MBlazeGPRReg< 30, "r30">,  DwarfRegNum<[30]>;
  71   def R31 : MBlazeGPRReg< 31, "r31">,  DwarfRegNum<[31]>;
  72
  73   /// MBlaze Single point precision FPU Registers
  74   /*
  75   def F0  : FPR< 0,  "f0", [R0]>,  DwarfRegNum<[32]>;
  76   def F1  : FPR< 1,  "f1", [R1]>,  DwarfRegNum<[33]>;
  77   def F2  : FPR< 2,  "f2", [R2]>,  DwarfRegNum<[34]>;
  78   def F3  : FPR< 3,  "f3", [R3]>,  DwarfRegNum<[35]>;
  79   def F4  : FPR< 4,  "f4", [R4]>,  DwarfRegNum<[36]>;
  80   def F5  : FPR< 5,  "f5", [R5]>,  DwarfRegNum<[37]>;
  81   def F6  : FPR< 6,  "f6", [R6]>,  DwarfRegNum<[38]>;
  82   def F7  : FPR< 7,  "f7", [R7]>,  DwarfRegNum<[39]>;
  83   def F8  : FPR< 8,  "f8", [R8]>,  DwarfRegNum<[40]>;
  84   def F9  : FPR< 9,  "f9", [R9]>,  DwarfRegNum<[41]>;
  85   def F10 : FPR<10, "f10", [R10]>, DwarfRegNum<[42]>;
  86   def F11 : FPR<11, "f11", [R11]>, DwarfRegNum<[43]>;
  87   def F12 : FPR<12, "f12", [R12]>, DwarfRegNum<[44]>;
  88   def F13 : FPR<13, "f13", [R13]>, DwarfRegNum<[45]>;
  89   def F14 : FPR<14, "f14", [R14]>, DwarfRegNum<[46]>;
  90   def F15 : FPR<15, "f15", [R15]>, DwarfRegNum<[47]>;
  91   def F16 : FPR<16, "f16", [R16]>, DwarfRegNum<[48]>;
  92   def F17 : FPR<17, "f17", [R17]>, DwarfRegNum<[49]>;
  93   def F18 : FPR<18, "f18", [R18]>, DwarfRegNum<[50]>;
  94   def F19 : FPR<19, "f19", [R19]>, DwarfRegNum<[51]>;
  95   def F20 : FPR<20, "f20", [R20]>, DwarfRegNum<[52]>;
  96   def F21 : FPR<21, "f21", [R21]>, DwarfRegNum<[53]>;
  97   def F22 : FPR<22, "f22", [R22]>, DwarfRegNum<[54]>;
  98   def F23 : FPR<23, "f23", [R23]>, DwarfRegNum<[55]>;
  99   def F24 : FPR<24, "f24", [R24]>, DwarfRegNum<[56]>;
 100   def F25 : FPR<25, "f25", [R25]>, DwarfRegNum<[57]>;
 101   def F26 : FPR<26, "f26", [R26]>, DwarfRegNum<[58]>;
 102   def F27 : FPR<27, "f27", [R27]>, DwarfRegNum<[59]>;
 103   def F28 : FPR<28, "f28", [R28]>, DwarfRegNum<[60]>;
 104   def F29 : FPR<29, "f29", [R29]>, DwarfRegNum<[61]>;
 105   def F30 : FPR<30, "f30", [R30]>, DwarfRegNum<[62]>;
 106   def F31 : FPR<31, "f31", [R31]>, DwarfRegNum<[63]>;
 107   */
 108 }
 109
 110 //===----------------------------------------------------------------------===//
 111 // Register Classes
 112 //===----------------------------------------------------------------------===//
 113
 114 def GPR : RegisterClass<"MBlaze", [i32,f32], 32,
 115   [
 116   // Return Values and Arguments
 117   R3, R4, R5, R6, R7, R8, R9, R10,
 118
 119   // Not preserved across procedure calls
 120   R11, R12,
 121
 122   // Callee save
 123   R20, R21, R22, R23, R24, R25, R26, R27, R28, R29, R30, R31,
 124
 125   // Reserved
 126   R0,  // Always zero
 127   R1,  // The stack pointer
 128   R2,  // Read-only small data area anchor
 129   R13, // Read-write small data area anchor
 130   R14, // Return address for interrupts
 131   R15, // Return address for sub-routines
 132   R16, // Return address for trap
 133   R17, // Return address for exceptions
 134   R18, // Reserved for assembler
 135   R19  // The frame-pointer
 136   ]>
 137 {
 138   let MethodProtos = [{
 139     iterator allocation_order_end(const MachineFunction &MF) const;
 140   }];
 141   let MethodBodies = [{
 142     GPRClass::iterator
 143     GPRClass::allocation_order_end(const MachineFunction &MF) const {
 144       // The last 10 registers on the list above are reserved
 145       return end()-10;
 146     }
 147   }];
 148 }
 149
 150 /*
 151 def FGR32 : RegisterClass<"MBlaze", [f32], 32,
 152   [
 153   // Return Values and Arguments
 154   F3, F4, F5, F6, F7, F8, F9, F10,
 155
 156   // Not preserved across procedure calls
 157   F11, F12,
 158
 159   // Callee save
 160   F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30, F31,
 161
 162   // Reserved
 163   F0,  // Always zero
 164   F1,  // The stack pointer
 165   F2,  // Read-only small data area anchor
 166   F13, // Read-write small data area anchor
 167   F14, // Return address for interrupts
 168   F15, // Return address for sub-routines
 169   F16, // Return address for trap
 170   F17, // Return address for exceptions
 171   F18, // Reserved for assembler
 172   F19  // The frame pointer
 173   ]>
 174 {
 175   let MethodProtos = [{
 176     iterator allocation_order_end(const MachineFunction &MF) const;
 177   }];
 178   let MethodBodies = [{
 179     FGR32Class::iterator
 180     FGR32Class::allocation_order_end(const MachineFunction &MF) const {
 181       // The last 10 registers on the list above are reserved
 182       return end()-10;
 183     }
 184   }];
 185 }
 186 */