Home | History | Annotate | Download | only in Mips
      1 //=- Mips32r6InstrFormats.td - Mips32r6 Instruction Formats -*- 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 // This file describes Mips32r6 instruction formats.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 class R6MMR6Rel;
     15 
     16 def MipsR62MicroMipsR6 : InstrMapping {
     17   let FilterClass = "R6MMR6Rel";
     18   // Instructions with the same BaseOpcode and isNVStore values form a row.
     19   let RowFields = ["BaseOpcode"];
     20   // Instructions with the same predicate sense form a column.
     21   let ColFields = ["Arch"];
     22   // The key column is the unpredicated instructions.
     23   let KeyCol = ["mipsr6"];
     24   // Value columns are PredSense=true and PredSense=false
     25   let ValueCols = [["mipsr6"], ["micromipsr6"]];
     26 }
     27 
     28 class MipsR6Arch<string opstr> {
     29   string Arch = "mipsr6";
     30   string BaseOpcode = opstr;
     31 }
     32 
     33 class MipsR6Inst : MipsInst<(outs), (ins), "", [], NoItinerary, FrmOther>,
     34                    PredicateControl {
     35   let DecoderNamespace = "Mips32r6_64r6";
     36   let EncodingPredicates = [HasStdEnc];
     37 }
     38 
     39 //===----------------------------------------------------------------------===//
     40 //
     41 // Field Values
     42 //
     43 //===----------------------------------------------------------------------===//
     44 
     45 class OPGROUP<bits<6> Val> {
     46   bits<6> Value = Val;
     47 }
     48 def OPGROUP_COP1     : OPGROUP<0b010001>;
     49 def OPGROUP_COP2     : OPGROUP<0b010010>;
     50 def OPGROUP_ADDI     : OPGROUP<0b001000>;
     51 def OPGROUP_AUI      : OPGROUP<0b001111>;
     52 def OPGROUP_BLEZ     : OPGROUP<0b000110>;
     53 def OPGROUP_BGTZ     : OPGROUP<0b000111>;
     54 def OPGROUP_BLEZL    : OPGROUP<0b010110>;
     55 def OPGROUP_BGTZL    : OPGROUP<0b010111>;
     56 def OPGROUP_DADDI    : OPGROUP<0b011000>;
     57 def OPGROUP_DAUI     : OPGROUP<0b011101>;
     58 def OPGROUP_PCREL    : OPGROUP<0b111011>;
     59 def OPGROUP_REGIMM   : OPGROUP<0b000001>;
     60 def OPGROUP_SPECIAL  : OPGROUP<0b000000>;
     61 // The spec occasionally names this value LL, LLD, SC, or SCD.
     62 def OPGROUP_SPECIAL3 : OPGROUP<0b011111>;
     63 // The spec names this constant LWC2, LDC2, SWC2, and SDC2 in different places.
     64 def OPGROUP_COP2LDST : OPGROUP<0b010010>;
     65 
     66 class OPCODE2<bits<2> Val> {
     67   bits<2> Value = Val;
     68 }
     69 def OPCODE2_ADDIUPC : OPCODE2<0b00>;
     70 def OPCODE2_LWPC    : OPCODE2<0b01>;
     71 def OPCODE2_LWUPC   : OPCODE2<0b10>;
     72 
     73 class OPCODE3<bits<3> Val> {
     74   bits<3> Value = Val;
     75 }
     76 def OPCODE3_LDPC : OPCODE3<0b110>;
     77 
     78 class OPCODE5<bits<5> Val> {
     79   bits<5> Value = Val;
     80 }
     81 def OPCODE5_ALUIPC : OPCODE5<0b11111>;
     82 def OPCODE5_AUIPC  : OPCODE5<0b11110>;
     83 def OPCODE5_DAHI : OPCODE5<0b00110>;
     84 def OPCODE5_DATI : OPCODE5<0b11110>;
     85 def OPCODE5_BC1EQZ : OPCODE5<0b01001>;
     86 def OPCODE5_BC1NEZ : OPCODE5<0b01101>;
     87 def OPCODE5_BC2EQZ : OPCODE5<0b01001>;
     88 def OPCODE5_BC2NEZ : OPCODE5<0b01101>;
     89 def OPCODE5_BGEZAL : OPCODE5<0b10001>;
     90 // The next four constants are unnamed in the spec. These names are taken from
     91 // the OPGROUP names they are used with.
     92 def OPCODE5_LDC2   : OPCODE5<0b01110>;
     93 def OPCODE5_LWC2   : OPCODE5<0b01010>;
     94 def OPCODE5_SDC2   : OPCODE5<0b01111>;
     95 def OPCODE5_SWC2   : OPCODE5<0b01011>;
     96 
     97 class OPCODE6<bits<6> Val> {
     98   bits<6> Value = Val;
     99 }
    100 def OPCODE6_ALIGN    : OPCODE6<0b100000>;
    101 def OPCODE6_DALIGN   : OPCODE6<0b100100>;
    102 def OPCODE6_BITSWAP  : OPCODE6<0b100000>;
    103 def OPCODE6_DBITSWAP : OPCODE6<0b100100>;
    104 def OPCODE6_JALR     : OPCODE6<0b001001>;
    105 def OPCODE6_CACHE    : OPCODE6<0b100101>;
    106 def OPCODE6_PREF     : OPCODE6<0b110101>;
    107 // The next four constants are unnamed in the spec. These names are taken from
    108 // the OPGROUP names they are used with.
    109 def OPCODE6_LL       : OPCODE6<0b110110>;
    110 def OPCODE6_LLD      : OPCODE6<0b110111>;
    111 def OPCODE6_SC       : OPCODE6<0b100110>;
    112 def OPCODE6_SCD      : OPCODE6<0b100111>;
    113 def OPCODE6_CLO      : OPCODE6<0b010001>;
    114 def OPCODE6_CLZ      : OPCODE6<0b010000>;
    115 def OPCODE6_DCLO     : OPCODE6<0b010011>;
    116 def OPCODE6_DCLZ     : OPCODE6<0b010010>;
    117 def OPCODE6_LSA      : OPCODE6<0b000101>;
    118 def OPCODE6_DLSA     : OPCODE6<0b010101>;
    119 def OPCODE6_SDBBP    : OPCODE6<0b001110>;
    120 
    121 class FIELD_FMT<bits<5> Val> {
    122   bits<5> Value = Val;
    123 }
    124 def FIELD_FMT_S : FIELD_FMT<0b10000>;
    125 def FIELD_FMT_D : FIELD_FMT<0b10001>;
    126 
    127 class FIELD_CMP_COND<bits<5> Val> {
    128   bits<5> Value = Val;
    129 }
    130 // Note: The CMP_COND_FMT names differ from the C_COND_FMT names.
    131 def FIELD_CMP_COND_AF   : FIELD_CMP_COND<0b00000>;
    132 def FIELD_CMP_COND_UN   : FIELD_CMP_COND<0b00001>;
    133 def FIELD_CMP_COND_EQ   : FIELD_CMP_COND<0b00010>;
    134 def FIELD_CMP_COND_UEQ  : FIELD_CMP_COND<0b00011>;
    135 def FIELD_CMP_COND_LT   : FIELD_CMP_COND<0b00100>;
    136 def FIELD_CMP_COND_ULT  : FIELD_CMP_COND<0b00101>;
    137 def FIELD_CMP_COND_LE   : FIELD_CMP_COND<0b00110>;
    138 def FIELD_CMP_COND_ULE  : FIELD_CMP_COND<0b00111>;
    139 def FIELD_CMP_COND_SAF  : FIELD_CMP_COND<0b01000>;
    140 def FIELD_CMP_COND_SUN  : FIELD_CMP_COND<0b01001>;
    141 def FIELD_CMP_COND_SEQ  : FIELD_CMP_COND<0b01010>;
    142 def FIELD_CMP_COND_SUEQ : FIELD_CMP_COND<0b01011>;
    143 def FIELD_CMP_COND_SLT  : FIELD_CMP_COND<0b01100>;
    144 def FIELD_CMP_COND_SULT : FIELD_CMP_COND<0b01101>;
    145 def FIELD_CMP_COND_SLE  : FIELD_CMP_COND<0b01110>;
    146 def FIELD_CMP_COND_SULE : FIELD_CMP_COND<0b01111>;
    147 
    148 class FIELD_CMP_FORMAT<bits<5> Val> {
    149   bits<5> Value = Val;
    150 }
    151 def FIELD_CMP_FORMAT_S : FIELD_CMP_FORMAT<0b10100>;
    152 def FIELD_CMP_FORMAT_D : FIELD_CMP_FORMAT<0b10101>;
    153 
    154 //===----------------------------------------------------------------------===//
    155 //
    156 // Disambiguators
    157 //
    158 //===----------------------------------------------------------------------===//
    159 //
    160 // Some encodings are ambiguous except by comparing field values.
    161 
    162 class DecodeDisambiguates<string Name> {
    163   string DecoderMethod = !strconcat("Decode", Name);
    164 }
    165 
    166 class DecodeDisambiguatedBy<string Name> : DecodeDisambiguates<Name> {
    167   string DecoderNamespace = "Mips32r6_64r6_Ambiguous";
    168 }
    169 
    170 //===----------------------------------------------------------------------===//
    171 //
    172 // Encoding Formats
    173 //
    174 //===----------------------------------------------------------------------===//
    175 
    176 class AUI_FM : MipsR6Inst {
    177   bits<5> rs;
    178   bits<5> rt;
    179   bits<16> imm;
    180 
    181   bits<32> Inst;
    182 
    183   let Inst{31-26} = OPGROUP_AUI.Value;
    184   let Inst{25-21} = rs;
    185   let Inst{20-16} = rt;
    186   let Inst{15-0} = imm;
    187 }
    188 
    189 class DAUI_FM : AUI_FM {
    190   let Inst{31-26} = OPGROUP_DAUI.Value;
    191 }
    192 
    193 class BAL_FM : MipsR6Inst {
    194   bits<16> offset;
    195 
    196   bits<32> Inst;
    197 
    198   let Inst{31-26} = OPGROUP_REGIMM.Value;
    199   let Inst{25-21} = 0b00000;
    200   let Inst{20-16} = OPCODE5_BGEZAL.Value;
    201   let Inst{15-0} = offset;
    202 }
    203 
    204 class COP1_2R_FM<bits<6> funct, FIELD_FMT Format> : MipsR6Inst {
    205   bits<5> fs;
    206   bits<5> fd;
    207 
    208   bits<32> Inst;
    209 
    210   let Inst{31-26} = OPGROUP_COP1.Value;
    211   let Inst{25-21} = Format.Value;
    212   let Inst{20-16} = 0b00000;
    213   let Inst{15-11} = fs;
    214   let Inst{10-6}  = fd;
    215   let Inst{5-0}   = funct;
    216 }
    217 
    218 class COP1_3R_FM<bits<6> funct, FIELD_FMT Format> : MipsR6Inst {
    219   bits<5> ft;
    220   bits<5> fs;
    221   bits<5> fd;
    222 
    223   bits<32> Inst;
    224 
    225   let Inst{31-26} = OPGROUP_COP1.Value;
    226   let Inst{25-21} = Format.Value;
    227   let Inst{20-16} = ft;
    228   let Inst{15-11} = fs;
    229   let Inst{10-6} = fd;
    230   let Inst{5-0} = funct;
    231 }
    232 
    233 class COP1_BCCZ_FM<OPCODE5 Operation> : MipsR6Inst {
    234   bits<5> ft;
    235   bits<16> offset;
    236 
    237   bits<32> Inst;
    238 
    239   let Inst{31-26} = OPGROUP_COP1.Value;
    240   let Inst{25-21} = Operation.Value;
    241   let Inst{20-16} = ft;
    242   let Inst{15-0} = offset;
    243 }
    244 
    245 class COP2_BCCZ_FM<OPCODE5 Operation> : MipsR6Inst {
    246   bits<5> ct;
    247   bits<16> offset;
    248 
    249   bits<32> Inst;
    250 
    251   let Inst{31-26} = OPGROUP_COP2.Value;
    252   let Inst{25-21} = Operation.Value;
    253   let Inst{20-16} = ct;
    254   let Inst{15-0} = offset;
    255 }
    256 
    257 class PCREL16_FM<OPCODE5 Operation> : MipsR6Inst {
    258   bits<5> rs;
    259   bits<16> imm;
    260 
    261   bits<32> Inst;
    262 
    263   let Inst{31-26} = OPGROUP_PCREL.Value;
    264   let Inst{25-21} = rs;
    265   let Inst{20-16} = Operation.Value;
    266   let Inst{15-0} = imm;
    267 }
    268 
    269 class PCREL19_FM<OPCODE2 Operation> : MipsR6Inst {
    270   bits<5> rs;
    271   bits<19> imm;
    272 
    273   bits<32> Inst;
    274 
    275   let Inst{31-26} = OPGROUP_PCREL.Value;
    276   let Inst{25-21} = rs;
    277   let Inst{20-19} = Operation.Value;
    278   let Inst{18-0} = imm;
    279 }
    280 
    281 class PCREL18_FM<OPCODE3 Operation> : MipsR6Inst {
    282   bits<5> rs;
    283   bits<18> imm;
    284 
    285   bits<32> Inst;
    286 
    287   let Inst{31-26} = OPGROUP_PCREL.Value;
    288   let Inst{25-21} = rs;
    289   let Inst{20-18} = Operation.Value;
    290   let Inst{17-0} = imm;
    291 }
    292 
    293 class SPECIAL3_2R_FM<OPCODE6 Operation> : MipsR6Inst {
    294   bits<5> rd;
    295   bits<5> rt;
    296 
    297   bits<32> Inst;
    298 
    299   let Inst{31-26} = OPGROUP_SPECIAL3.Value;
    300   let Inst{25-21} = 0b00000;
    301   let Inst{20-16} = rt;
    302   let Inst{15-11} = rd;
    303   let Inst{10-6}  = 0b00000;
    304   let Inst{5-0}   = Operation.Value;
    305 }
    306 
    307 class SPECIAL3_MEM_FM<OPCODE6 Operation> : MipsR6Inst {
    308   bits<21> addr;
    309   bits<5> hint;
    310   bits<5> base = addr{20-16};
    311   bits<9> offset = addr{8-0};
    312 
    313   bits<32> Inst;
    314 
    315   let Inst{31-26} = OPGROUP_SPECIAL3.Value;
    316   let Inst{25-21} = base;
    317   let Inst{20-16} = hint;
    318   let Inst{15-7}  = offset;
    319   let Inst{6}     = 0;
    320   let Inst{5-0}   = Operation.Value;
    321 }
    322 
    323 class SPECIAL_2R_FM<OPCODE6 Operation> : MipsR6Inst {
    324   bits<5> rd;
    325   bits<5> rs;
    326 
    327   bits<32> Inst;
    328 
    329   let Inst{31-26} = OPGROUP_SPECIAL.Value;
    330   let Inst{25-21} = rs;
    331   let Inst{20-16} = 0b00000;
    332   let Inst{15-11} = rd;
    333   let Inst{10-6}  = 0b00001;
    334   let Inst{5-0}   = Operation.Value;
    335 }
    336 
    337 class SPECIAL_3R_FM<bits<5> mulop, bits<6> funct> : MipsR6Inst {
    338   bits<5> rd;
    339   bits<5> rs;
    340   bits<5> rt;
    341 
    342   bits<32> Inst;
    343 
    344   let Inst{31-26} = OPGROUP_SPECIAL.Value;
    345   let Inst{25-21} = rs;
    346   let Inst{20-16} = rt;
    347   let Inst{15-11} = rd;
    348   let Inst{10-6}  = mulop;
    349   let Inst{5-0}   = funct;
    350 }
    351 
    352 class SPECIAL_SDBBP_FM : MipsR6Inst {
    353   bits<20> code_;
    354 
    355   bits<32> Inst;
    356 
    357   let Inst{31-26} = OPGROUP_SPECIAL.Value;
    358   let Inst{25-6}  = code_;
    359   let Inst{5-0}   = OPCODE6_SDBBP.Value;
    360 }
    361 
    362 // This class is ambiguous with other branches:
    363 //   BEQC/BNEC require that rs > rt
    364 class CMP_BRANCH_2R_OFF16_FM<OPGROUP funct> : MipsR6Inst {
    365   bits<5> rs;
    366   bits<5> rt;
    367   bits<16> offset;
    368 
    369   bits<32> Inst;
    370 
    371   let Inst{31-26} = funct.Value;
    372   let Inst{25-21} = rs;
    373   let Inst{20-16} = rt;
    374   let Inst{15-0} = offset;
    375 }
    376 
    377 // This class is ambiguous with other branches:
    378 //   BLEZC/BGEZC/BEQZALC/BNEZALC/BGTZALC require that rs == 0 && rt != 0
    379 // The '1R_RT' in the name means 1 register in the rt field.
    380 class CMP_BRANCH_1R_RT_OFF16_FM<OPGROUP funct> : MipsR6Inst {
    381   bits<5> rt;
    382   bits<16> offset;
    383 
    384   bits<32> Inst;
    385 
    386   let Inst{31-26} = funct.Value;
    387   let Inst{25-21} = 0b00000;
    388   let Inst{20-16} = rt;
    389   let Inst{15-0} = offset;
    390 }
    391 
    392 // This class is ambiguous with other branches:
    393 //   BLTZC/BGTZC/BLTZALC/BGEZALC require that rs == rt && rt != 0
    394 // The '1R_BOTH' in the name means 1 register in both the rs and rt fields.
    395 class CMP_BRANCH_1R_BOTH_OFF16_FM<OPGROUP funct> : MipsR6Inst {
    396   bits<5> rt;
    397   bits<16> offset;
    398 
    399   bits<32> Inst;
    400 
    401   let Inst{31-26} = funct.Value;
    402   let Inst{25-21} = rt;
    403   let Inst{20-16} = rt;
    404   let Inst{15-0} = offset;
    405 }
    406 
    407 class CMP_BRANCH_OFF21_FM<bits<6> funct> : MipsR6Inst {
    408   bits<5> rs; // rs != 0
    409   bits<21> offset;
    410 
    411   bits<32> Inst;
    412 
    413   let Inst{31-26} = funct;
    414   let Inst{25-21} = rs;
    415   let Inst{20-0} = offset;
    416 }
    417 
    418 class JMP_IDX_COMPACT_FM<bits<6> funct> : MipsR6Inst {
    419   bits<5> rt;
    420   bits<16> offset;
    421 
    422   bits<32> Inst;
    423 
    424   let Inst{31-26} = funct;
    425   let Inst{25-21} = 0b00000;
    426   let Inst{20-16} = rt;
    427   let Inst{15-0} = offset;
    428 }
    429 
    430 class BRANCH_OFF26_FM<bits<6> funct> : MipsR6Inst {
    431   bits<32> Inst;
    432   bits<26> offset;
    433 
    434   let Inst{31-26} = funct;
    435   let Inst{25-0} = offset;
    436 }
    437 
    438 class SPECIAL3_ALIGN_FM<OPCODE6 Operation> : MipsR6Inst {
    439   bits<5> rd;
    440   bits<5> rs;
    441   bits<5> rt;
    442   bits<2> bp;
    443 
    444   bits<32> Inst;
    445 
    446   let Inst{31-26} = OPGROUP_SPECIAL3.Value;
    447   let Inst{25-21} = rs;
    448   let Inst{20-16} = rt;
    449   let Inst{15-11} = rd;
    450   let Inst{10-8}  = 0b010;
    451   let Inst{7-6}   = bp;
    452   let Inst{5-0}   = Operation.Value;
    453 }
    454 
    455 class SPECIAL3_DALIGN_FM<OPCODE6 Operation> : MipsR6Inst {
    456   bits<5> rd;
    457   bits<5> rs;
    458   bits<5> rt;
    459   bits<3> bp;
    460 
    461   bits<32> Inst;
    462 
    463   let Inst{31-26} = OPGROUP_SPECIAL3.Value;
    464   let Inst{25-21} = rs;
    465   let Inst{20-16} = rt;
    466   let Inst{15-11} = rd;
    467   let Inst{10-9}  = 0b01;
    468   let Inst{8-6}   = bp;
    469   let Inst{5-0}   = Operation.Value;
    470 }
    471 
    472 class SPECIAL3_LL_SC_FM<OPCODE6 Operation> : MipsR6Inst {
    473   bits<5> rt;
    474   bits<21> addr;
    475   bits<5> base = addr{20-16};
    476   bits<9> offset = addr{8-0};
    477 
    478   bits<32> Inst;
    479 
    480   let Inst{31-26} = OPGROUP_SPECIAL3.Value;
    481   let Inst{25-21} = base;
    482   let Inst{20-16} = rt;
    483   let Inst{15-7} = offset;
    484   let Inst{5-0} = Operation.Value;
    485 
    486   string DecoderMethod = "DecodeSpecial3LlSc";
    487 }
    488 
    489 class SPECIAL_LSA_FM<OPCODE6 Operation> : MipsR6Inst {
    490   bits<5> rd;
    491   bits<5> rs;
    492   bits<5> rt;
    493   bits<2> imm2;
    494 
    495   bits<32> Inst;
    496 
    497   let Inst{31-26} = OPGROUP_SPECIAL.Value;
    498   let Inst{25-21} = rs;
    499   let Inst{20-16} = rt;
    500   let Inst{15-11} = rd;
    501   let Inst{10-8}  = 0b000;
    502   let Inst{7-6}   = imm2;
    503   let Inst{5-0}   = Operation.Value;
    504 }
    505 
    506 class REGIMM_FM<OPCODE5 Operation> : MipsR6Inst {
    507   bits<5> rs;
    508   bits<16> imm;
    509 
    510   bits<32> Inst;
    511 
    512   let Inst{31-26} = OPGROUP_REGIMM.Value;
    513   let Inst{25-21} = rs;
    514   let Inst{20-16} = Operation.Value;
    515   let Inst{15-0} = imm;
    516 }
    517 
    518 class COP1_CMP_CONDN_FM<FIELD_CMP_FORMAT Format,
    519                         FIELD_CMP_COND Cond> : MipsR6Inst {
    520   bits<5> fd;
    521   bits<5> fs;
    522   bits<5> ft;
    523 
    524   bits<32> Inst;
    525 
    526   let Inst{31-26} = OPGROUP_COP1.Value;
    527   let Inst{25-21} = Format.Value;
    528   let Inst{20-16} = ft;
    529   let Inst{15-11} = fs;
    530   let Inst{10-6}  = fd;
    531   let Inst{5}     = 0;
    532   let Inst{4-0}   = Cond.Value;
    533 }
    534 
    535 class JR_HB_R6_FM<OPCODE6 Operation> : MipsR6Inst {
    536   bits<5> rs;
    537 
    538   bits<32> Inst;
    539 
    540   let Inst{31-26} = OPGROUP_SPECIAL.Value;
    541   let Inst{25-21} = rs;
    542   let Inst{20-16} = 0;
    543   let Inst{15-11} = 0;
    544   let Inst{10} = 1;
    545   let Inst{9-6} = 0;
    546   let Inst{5-0} = Operation.Value;
    547 }
    548 
    549 class COP2LDST_FM<OPCODE5 Operation> : MipsR6Inst {
    550   bits<5> rt;
    551   bits<21> addr;
    552   bits<5> base = addr{20-16};
    553   bits<11> offset = addr{10-0};
    554 
    555   bits<32> Inst;
    556 
    557   let Inst{31-26} = OPGROUP_COP2LDST.Value;
    558   let Inst{25-21} = Operation.Value;
    559   let Inst{20-16} = rt;
    560   let Inst{15-11} = base;
    561   let Inst{10-0}  = offset;
    562 }
    563