lib/Target/Alpha/AlphaInstrFormats.td

   1 //===- AlphaInstrFormats.td - Alpha Instruction Formats ----*- 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 //
  11 //===----------------------------------------------------------------------===//
  12
  13 //3.3:
  14 //Memory
  15 //Branch
  16 //Operate
  17 //Floating-point
  18 //PALcode
  19
  20 def u8imm   : Operand<i64>;
  21 def s14imm  : Operand<i64>;
  22 def s16imm  : Operand<i64>;
  23 def s21imm  : Operand<i64>;
  24 def s64imm  : Operand<i64>;
  25
  26 //===----------------------------------------------------------------------===//
  27 // Instruction format superclass
  28 //===----------------------------------------------------------------------===//
  29 // Alpha instruction baseline
  30 class InstAlphaAlt<bits<6> op, string asmstr> : Instruction {
  31   field bits<32> Inst;
  32   let Namespace = "Alpha";
  33   let AsmString = asmstr;
  34   let Inst{31-26} = op;
  35 }
  36
  37 class InstAlpha<bits<6> op, dag OL, string asmstr>
  38 : InstAlphaAlt<op, asmstr> { // Alpha instruction baseline
  39   let OperandList = OL;
  40 }
  41
  42 //3.3.1
  43 class MForm<bits<6> opcode, string asmstr>
  44         : InstAlpha<opcode, (ops GPRC:$RA, s16imm:$DISP, GPRC:$RB), asmstr> {
  45   bits<5> Ra;
  46   bits<16> disp;
  47   bits<5> Rb;
  48
  49   let Inst{25-21} = Ra;
  50   let Inst{20-16} = Rb;
  51   let Inst{15-0} = disp;
  52 }
  53
  54 class MgForm<bits<6> opcode, string asmstr>
  55         : InstAlpha<opcode, (ops GPRC:$RA, s16imm:$DISP, GPRC:$RB, s16imm:$NUM), asmstr> {
  56   bits<5> Ra;
  57   bits<16> disp;
  58   bits<5> Rb;
  59
  60   let Inst{25-21} = Ra;
  61   let Inst{20-16} = Rb;
  62   let Inst{15-0} = disp;
  63 }
  64
  65 class MbrForm<bits<6> opcode, bits<2> TB, dag OL, string asmstr> : InstAlpha<opcode, OL, asmstr> {
  66   bits<5> Ra;
  67   bits<5> Rb;
  68   bits<14> disp;
  69
  70   let Inst{25-21} = Ra;
  71   let Inst{20-16} = Rb;
  72   let Inst{15-14} = TB;
  73   let Inst{13-0} = disp;
  74 }
  75
  76 //3.3.2
  77 let isBranch = 1, isTerminator = 1 in
  78 class BForm<bits<6> opcode, string asmstr>
  79     : InstAlpha<opcode, (ops GPRC:$RA, s21imm:$DISP), asmstr> {
  80   bits<5> Ra;
  81   bits<21> disp;
  82
  83   let Inst{25-21} = Ra;
  84   let Inst{20-0} = disp;
  85 }
  86 class BFormD<bits<6> opcode, string asmstr>
  87     : InstAlpha<opcode, (ops s21imm:$DISP), asmstr> {
  88   bits<5> Ra = 31;
  89   bits<21> disp;
  90
  91   let Inst{25-21} = Ra;
  92   let Inst{20-0} = disp;
  93 }
  94
  95 let isBranch = 1, isTerminator = 1 in
  96 class FBForm<bits<6> opcode, string asmstr>
  97     : InstAlpha<opcode, (ops F8RC:$RA, s21imm:$DISP), asmstr> {
  98   bits<5> Ra;
  99   bits<21> disp;
 100
 101   let Inst{25-21} = Ra;
 102   let Inst{20-0} = disp;
 103 }
 104
 105 //3.3.3
 106 class OForm<bits<6> opcode, bits<7> fun, string asmstr, list<dag> pattern>
 107         : InstAlpha<opcode, (ops GPRC:$RC, GPRC:$RA, GPRC:$RB), asmstr> {
 108   let Pattern = pattern;
 109
 110   bits<5> Rc;
 111   bits<5> Ra;
 112   bits<5> Rb;
 113   bits<7> Function = fun;
 114
 115   let Inst{25-21} = Ra;
 116   let Inst{20-16} = Rb;
 117   let Inst{15-13} = 0;
 118   let Inst{12} = 0;
 119   let Inst{11-5} = Function;
 120   let Inst{4-0} = Rc;
 121 }
 122
 123 class OForm2<bits<6> opcode, bits<7> fun, string asmstr, list<dag> pattern>
 124         : InstAlpha<opcode, (ops GPRC:$RC, GPRC:$RB), asmstr> {
 125   let Pattern = pattern;
 126
 127   bits<5> Rc;
 128   bits<5> Rb;
 129   bits<7> Function = fun;
 130
 131   let Inst{25-21} = 31;
 132   let Inst{20-16} = Rb;
 133   let Inst{15-13} = 0;
 134   let Inst{12} = 0;
 135   let Inst{11-5} = Function;
 136   let Inst{4-0} = Rc;
 137 }
 138
 139 class OForm4<bits<6> opcode, bits<7> fun, string asmstr>
 140         : InstAlpha<opcode, (ops GPRC:$RDEST, GPRC:$RSRC2, GPRC:$RSRC, GPRC:$RCOND), asmstr> {
 141   bits<5> Rc;
 142   bits<5> Rb;
 143   bits<5> Ra;
 144   bits<7> Function = fun;
 145
 146   let isTwoAddress = 1;
 147   let Inst{25-21} = Ra;
 148   let Inst{20-16} = Rb;
 149   let Inst{15-13} = 0;
 150   let Inst{12} = 0;
 151   let Inst{11-5} = Function;
 152   let Inst{4-0} = Rc;
 153 }
 154
 155
 156 class OFormL<bits<6> opcode, bits<7> fun, string asmstr, list<dag> pattern>
 157         : InstAlpha<opcode, (ops GPRC:$RC, GPRC:$RA, u8imm:$L), asmstr> {
 158   let Pattern = pattern;
 159
 160   bits<5> Rc;
 161   bits<5> Ra;
 162   bits<8> LIT;
 163   bits<7> Function = fun;
 164
 165   let Inst{25-21} = Ra;
 166   let Inst{20-13} = LIT;
 167   let Inst{12} = 1;
 168   let Inst{11-5} = Function;
 169   let Inst{4-0} = Rc;
 170 }
 171
 172 class OForm4L<bits<6> opcode, bits<7> fun, string asmstr>
 173         : InstAlpha<opcode, (ops GPRC:$RDEST, GPRC:$RSRC2, u8imm:$L, GPRC:$RCOND), asmstr> {
 174   bits<5> Rc;
 175   bits<8> LIT;
 176   bits<5> Ra;
 177   bits<7> Function = fun;
 178
 179   let isTwoAddress = 1;
 180   let Inst{25-21} = Ra;
 181   let Inst{20-13} = LIT;
 182   let Inst{12} = 1;
 183   let Inst{11-5} = Function;
 184   let Inst{4-0} = Rc;
 185 }
 186
 187 //3.3.4
 188 class FPForm<bits<6> opcode, bits<11> fun, string asmstr, list<dag> pattern>
 189         : InstAlphaAlt<opcode, asmstr> {
 190   let Pattern = pattern;
 191
 192   bits<5> Fc;
 193   bits<5> Fa;
 194   bits<5> Fb;
 195   bits<11> Function = fun;
 196
 197   let Inst{25-21} = Fa;
 198   let Inst{20-16} = Fb;
 199   let Inst{15-5} = Function;
 200   let Inst{4-0} = Fc;
 201 }
 202
 203 //3.3.5
 204 class PALForm<bits<6> opcode, dag OL, string asmstr> : InstAlpha<opcode, OL, asmstr> {
 205   bits<26> Function;
 206
 207   let Inst{25-0} = Function;
 208 }
 209
 210
 211 // Pseudo instructions.
 212 class PseudoInstAlpha<dag OL, string nm> : InstAlpha<0, OL, nm>  {
 213 }