llvm/lib/Target/Hexagon/HexagonInstrFormats.td

   1 //==- HexagonInstrFormats.td - Hexagon Instruction Formats --*- tablegen -*-==//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // Addressing modes for load/store instructions
  10 class AddrModeType<bits<3> value> {
  11   bits<3> Value = value;
  12 }
  13
  14 def NoAddrMode     : AddrModeType<0>;  // No addressing mode
  15 def Absolute       : AddrModeType<1>;  // Absolute addressing mode
  16 def AbsoluteSet    : AddrModeType<2>;  // Absolute set addressing mode
  17 def BaseImmOffset  : AddrModeType<3>;  // Indirect with offset
  18 def BaseLongOffset : AddrModeType<4>;  // Indirect with long offset
  19 def BaseRegOffset  : AddrModeType<5>;  // Indirect with register offset
  20 def PostInc        : AddrModeType<6>;  // Post increment addressing mode
  21
  22 class MemAccessSize<bits<4> value> {
  23   bits<4> Value = value;
  24 }
  25
  26 // These numbers must match the MemAccessSize enumeration values in
  27 // HexagonBaseInfo.h.
  28 def NoMemAccess      : MemAccessSize<0>;
  29 def ByteAccess       : MemAccessSize<1>;
  30 def HalfWordAccess   : MemAccessSize<2>;
  31 def WordAccess       : MemAccessSize<3>;
  32 def DoubleWordAccess : MemAccessSize<4>;
  33 def HVXVectorAccess  : MemAccessSize<5>;
  34
  35
  36 //===----------------------------------------------------------------------===//
  37 //                         Instruction Class Declaration +
  38 //===----------------------------------------------------------------------===//
  39
  40 // "Parse" bits are explicitly NOT defined in the opcode space to prevent
  41 //  TableGen from using them for generation of the decoder tables.
  42 class OpcodeHexagon {
  43   field bits<32> Inst = ?; // Default to an invalid insn.
  44   bits<4> IClass = 0; // ICLASS
  45   bits<1> zero = 0;
  46
  47   let Inst{31-28} = IClass;
  48 }
  49
  50 class InstHexagon<dag outs, dag ins, string asmstr, list<dag> pattern,
  51                   string cstr, InstrItinClass itin, IType type>
  52   : Instruction {
  53   let Namespace = "Hexagon";
  54
  55   dag OutOperandList = outs;
  56   dag InOperandList = ins;
  57   let AsmString = asmstr;
  58   let Pattern = pattern;
  59   let Constraints = cstr;
  60   let Itinerary = itin;
  61   let Size = 4;
  62
  63   // SoftFail is a field the disassembler can use to provide a way for
  64   // instructions to not match without killing the whole decode process. It is
  65   // mainly used for ARM, but Tablegen expects this field to exist or it fails
  66   // to build the decode table.
  67   field bits<32> SoftFail = 0;
  68
  69   // *** Must match MCTargetDesc/HexagonBaseInfo.h ***
  70
  71   // Instruction type according to the ISA.
  72   IType Type = type;
  73   let TSFlags{6-0} = Type.Value;
  74
  75   // Solo instructions, i.e., those that cannot be in a packet with others.
  76   bits<1> isSolo = 0;
  77   let TSFlags{7} = isSolo;
  78   // Packed only with A or X-type instructions.
  79   bits<1> isSoloAX = 0;
  80   let TSFlags{8} = isSoloAX;
  81   // Restricts slot 1 to ALU-only instructions.
  82   bits<1> isRestrictSlot1AOK = 0;
  83   let TSFlags{9} = isRestrictSlot1AOK;
  84
  85   // Predicated instructions.
  86   bits<1> isPredicated = 0;
  87   let TSFlags{10} = isPredicated;
  88   bits<1> isPredicatedFalse = 0;
  89   let TSFlags{11} = isPredicatedFalse;
  90   bits<1> isPredicatedNew = 0;
  91   let TSFlags{12} = isPredicatedNew;
  92   bits<1> isPredicateLate = 0;
  93   let TSFlags{13} = isPredicateLate; // Late predicate producer insn.
  94
  95   // New-value insn helper fields.
  96   bits<1> isNewValue = 0;
  97   let TSFlags{14} = isNewValue; // New-value consumer insn.
  98   bits<1> hasNewValue = 0;
  99   let TSFlags{15} = hasNewValue; // New-value producer insn.
 100   bits<3> opNewValue = 0;
 101   let TSFlags{18-16} = opNewValue; // New-value produced operand.
 102   bits<1> isNVStorable = 0;
 103   let TSFlags{19} = isNVStorable; // Store that can become new-value store.
 104   bits<1> isNVStore = 0;
 105   let TSFlags{20} = isNVStore; // New-value store insn.
 106   bits<1> isCVLoadable = 0;
 107   let TSFlags{21} = isCVLoadable; // Load that can become cur-value load.
 108   bits<1> isCVLoad = 0;
 109   let TSFlags{22} = isCVLoad; // Cur-value load insn.
 110
 111   // Immediate extender helper fields.
 112   bits<1> isExtendable = 0;
 113   let TSFlags{23} = isExtendable; // Insn may be extended.
 114   bits<1> isExtended = 0;
 115   let TSFlags{24} = isExtended; // Insn must be extended.
 116   bits<3> opExtendable = 0;
 117   let TSFlags{27-25} = opExtendable; // Which operand may be extended.
 118   bits<1> isExtentSigned = 0;
 119   let TSFlags{28} = isExtentSigned; // Signed or unsigned range.
 120   bits<5> opExtentBits = 0;
 121   let TSFlags{33-29} = opExtentBits; //Number of bits of range before extending.
 122   bits<2> opExtentAlign = 0;
 123   let TSFlags{35-34} = opExtentAlign; // Alignment exponent before extending.
 124
 125   bit cofMax1 = 0;
 126   let TSFlags{36} = cofMax1;
 127   bit cofRelax1 = 0;
 128   let TSFlags{37} = cofRelax1;
 129   bit cofRelax2 = 0;
 130   let TSFlags{38} = cofRelax2;
 131
 132   bit isRestrictNoSlot1Store = 0;
 133   let TSFlags{39} = isRestrictNoSlot1Store;
 134
 135   // Addressing mode for load/store instructions.
 136   AddrModeType addrMode = NoAddrMode;
 137   let TSFlags{44-42} = addrMode.Value;
 138
 139   // Memory access size for mem access instructions (load/store)
 140   MemAccessSize accessSize = NoMemAccess;
 141   let TSFlags{48-45} = accessSize.Value;
 142
 143   bits<1> isTaken = 0;
 144   let TSFlags {49} = isTaken; // Branch prediction.
 145
 146   bits<1> isFP = 0;
 147   let TSFlags {50} = isFP; // Floating-point.
 148
 149   bits<1> isSomeOK = 0;
 150   let TSFlags {51} = isSomeOK; // Relax some grouping constraints.
 151
 152   bits<1> hasNewValue2 = 0;
 153   let TSFlags{52} = hasNewValue2; // Second New-value producer insn.
 154   bits<3> opNewValue2 = 0;
 155   let TSFlags{55-53} = opNewValue2; // Second New-value produced operand.
 156
 157   bits<1> isAccumulator = 0;
 158   let TSFlags{56} = isAccumulator;
 159
 160   bits<1> prefersSlot3 = 0;
 161   let TSFlags{57} = prefersSlot3; // Complex XU
 162
 163   bits<1> hasTmpDst = 0;
 164   let TSFlags{60} = hasTmpDst;  // v65 : 'fake" register VTMP is set
 165
 166   bit CVINew = 0;
 167   let TSFlags{62} = CVINew;
 168
 169   bit isCVI = 0;
 170   let TSFlags{63} = isCVI;
 171
 172   // Fields used for relation models.
 173   bit isNonTemporal = 0;
 174   string isNT = ""; // set to "true" for non-temporal vector stores.
 175   string BaseOpcode = "";
 176   string CextOpcode = "";
 177   string PredSense = "";
 178   string PNewValue = "";
 179   string NValueST  = "";    // Set to "true" for new-value stores.
 180   string InputType = "";    // Input is "imm" or "reg" type.
 181   string isFloat = "false"; // Set to "true" for the floating-point load/store.
 182   string isBrTaken = !if(isTaken, "true", "false"); // Set to "true"/"false" for jump instructions
 183
 184   let PredSense = !if(isPredicated, !if(isPredicatedFalse, "false", "true"),
 185                                     "");
 186   let PNewValue = !if(isPredicatedNew, "new", "");
 187   let NValueST = !if(isNVStore, "true", "false");
 188   let isNT = !if(isNonTemporal, "true", "false");
 189
 190   let hasSideEffects = 0;
 191   // *** Must match MCTargetDesc/HexagonBaseInfo.h ***
 192 }
 193
 194 class HInst<dag outs, dag ins, string asmstr, InstrItinClass itin, IType type> :
 195       InstHexagon<outs, ins, asmstr, [], "", itin, type>;
 196
 197 //===----------------------------------------------------------------------===//
 198 //                         Instruction Classes Definitions +
 199 //===----------------------------------------------------------------------===//
 200
 201 let mayLoad = 1 in
 202 class LDInst<dag outs, dag ins, string asmstr, list<dag> pattern = [],
 203              string cstr = "", InstrItinClass itin = LD_tc_ld_SLOT01>
 204   : InstHexagon<outs, ins, asmstr, pattern, cstr, itin, TypeLD>, OpcodeHexagon;
 205
 206 class CONSTLDInst<dag outs, dag ins, string asmstr, list<dag> pattern = [],
 207              string cstr = "", InstrItinClass itin = LD_tc_ld_SLOT01>
 208   : InstHexagon<outs, ins, asmstr, pattern, cstr, itin, TypeLD>, OpcodeHexagon;
 209
 210 let mayStore = 1 in
 211 class STInst<dag outs, dag ins, string asmstr, list<dag> pattern = [],
 212              string cstr = "", InstrItinClass itin = ST_tc_st_SLOT01>
 213   : InstHexagon<outs, ins, asmstr, pattern, cstr, itin, TypeST>, OpcodeHexagon;
 214
 215 let isCodeGenOnly = 1, isPseudo = 1 in
 216 class Endloop<dag outs, dag ins, string asmstr, list<dag> pattern = [],
 217               string cstr = "", InstrItinClass itin = tc_ENDLOOP>
 218   : InstHexagon<outs, ins, asmstr, pattern, cstr, itin, TypeENDLOOP>,
 219     OpcodeHexagon;
 220
 221 let isCodeGenOnly = 1, isPseudo = 1 in
 222 class Pseudo<dag outs, dag ins, string asmstr, list<dag> pattern = [],
 223              string cstr = "">
 224   : InstHexagon<outs, ins, asmstr, pattern, cstr, PSEUDO, TypePSEUDO>,
 225     OpcodeHexagon;
 226
 227 let isCodeGenOnly = 1, isPseudo = 1 in
 228 class PseudoM<dag outs, dag ins, string asmstr, list<dag> pattern = [],
 229               string cstr="">
 230   : InstHexagon<outs, ins, asmstr, pattern, cstr, PSEUDOM, TypePSEUDO>,
 231     OpcodeHexagon;
 232
 233 //===----------------------------------------------------------------------===//
 234 //                         Special Instructions -
 235 //===----------------------------------------------------------------------===//
 236
 237 // The 'invalid_decode' instruction is used by the disassembler to
 238 // show an instruction that didn't decode correctly.  This feature
 239 // is only leveraged in a special disassembler mode that's activated
 240 // by a command line flag.
 241 def tc_invalid : InstrItinClass;
 242 class Enc_invalid : OpcodeHexagon {
 243 }
 244 def invalid_decode : HInst<
 245 (outs ),
 246 (ins ),
 247 "<invalid>",
 248 tc_invalid, TypeALU32_2op>, Enc_invalid {
 249 let Inst{13-0} = 0b00000000000000;
 250 let Inst{31-16} = 0b0000000000000000;
 251 let isCodeGenOnly = 1;
 252 }
 253
 254 //===----------------------------------------------------------------------===//
 255 //                      Duplex Instruction Class Declaration
 256 //===----------------------------------------------------------------------===//
 257
 258 class OpcodeDuplex {
 259   field bits<32> Inst = ?; // Default to an invalid insn.
 260   bits<4> IClass = 0; // ICLASS
 261   bits<13> ISubHi = 0; // Low sub-insn
 262   bits<13> ISubLo = 0; // High sub-insn
 263
 264   let Inst{31-29} = IClass{3-1};
 265   let Inst{13}    = IClass{0};
 266   let Inst{15-14} = 0;
 267   let Inst{28-16} = ISubHi;
 268   let Inst{12-0}  = ISubLo;
 269 }
 270
 271 class InstDuplex<bits<4> iClass, list<dag> pattern = [],
 272                  string cstr = "">
 273   : Instruction, OpcodeDuplex {
 274   let Namespace = "Hexagon";
 275   IType Type = TypeDUPLEX;  // uses slot 0,1
 276   let isCodeGenOnly = 1;
 277   let hasSideEffects = 0;
 278   dag OutOperandList = (outs);
 279   dag InOperandList = (ins);
 280   let IClass = iClass;
 281   let Constraints = cstr;
 282   let Itinerary = DUPLEX;
 283   let Size = 4;
 284
 285   // SoftFail is a field the disassembler can use to provide a way for
 286   // instructions to not match without killing the whole decode process. It is
 287   // mainly used for ARM, but Tablegen expects this field to exist or it fails
 288   // to build the decode table.
 289   field bits<32> SoftFail = 0;
 290
 291   // *** Must match MCTargetDesc/HexagonBaseInfo.h ***
 292
 293   let TSFlags{6-0} = Type.Value;
 294
 295   // Predicated instructions.
 296   bits<1> isPredicated = 0;
 297   let TSFlags{7} = isPredicated;
 298   bits<1> isPredicatedFalse = 0;
 299   let TSFlags{8} = isPredicatedFalse;
 300   bits<1> isPredicatedNew = 0;
 301   let TSFlags{9} = isPredicatedNew;
 302
 303   // New-value insn helper fields.
 304   bits<1> isNewValue = 0;
 305   let TSFlags{10} = isNewValue; // New-value consumer insn.
 306   bits<1> hasNewValue = 0;
 307   let TSFlags{11} = hasNewValue; // New-value producer insn.
 308   bits<3> opNewValue = 0;
 309   let TSFlags{14-12} = opNewValue; // New-value produced operand.
 310   bits<1> isNVStorable = 0;
 311   let TSFlags{15} = isNVStorable; // Store that can become new-value store.
 312   bits<1> isNVStore = 0;
 313   let TSFlags{16} = isNVStore; // New-value store insn.
 314
 315   // Immediate extender helper fields.
 316   bits<1> isExtendable = 0;
 317   let TSFlags{17} = isExtendable; // Insn may be extended.
 318   bits<1> isExtended = 0;
 319   let TSFlags{18} = isExtended; // Insn must be extended.
 320   bits<3> opExtendable = 0;
 321   let TSFlags{21-19} = opExtendable; // Which operand may be extended.
 322   bits<1> isExtentSigned = 0;
 323   let TSFlags{22} = isExtentSigned; // Signed or unsigned range.
 324   bits<5> opExtentBits = 0;
 325   let TSFlags{27-23} = opExtentBits; //Number of bits of range before extending.
 326   bits<2> opExtentAlign = 0;
 327   let TSFlags{29-28} = opExtentAlign; // Alignment exponent before extending.
 328 }
 329
 330 //===----------------------------------------------------------------------===//
 331 //                         Instruction Classes Definitions -
 332 //===----------------------------------------------------------------------===//
 333
 334 include "HexagonInstrFormatsV60.td"
 335 include "HexagonInstrFormatsV65.td"