| //===-- M68kInstrFormats.td - M68k Instruction Formats -----*- tablegen -*-===// |
| // The LLVM Compiler Infrastructure |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| //===----------------------------------------------------------------------===// |
| /// |
| /// \file |
| /// This file contains M68k instruction formats. |
| /// |
| /// Since M68k has quite a lot memory addressing modes there are more |
| /// instruction prefixes than just i, r and m: |
| /// TSF Since Form Letter Description |
| /// 00 M68000 Dn or An r any register |
| /// 01 M68000 Dn d data register direct |
| /// 02 M68000 An a address register direct |
| /// 03 M68000 (An) j address register indirect |
| /// 04 M68000 (An)+ o address register indirect with postincrement |
| /// 05 M68000 -(An) e address register indirect with predecrement |
| /// 06 M68000 (i,An) p address register indirect with displacement |
| /// 10 M68000 (i,An,Xn.L) f address register indirect with index and scale = 1 |
| /// 07 M68000 (i,An,Xn.W) F address register indirect with index and scale = 1 |
| /// 12 M68020 (i,An,Xn.L,SCALE) g address register indirect with index |
| /// 11 M68020 (i,An,Xn.W,SCALE) G address register indirect with index |
| /// 14 M68020 ([bd,An],Xn.L,SCALE,od) u memory indirect postindexed mode |
| /// 13 M68020 ([bd,An],Xn.W,SCALE,od) U memory indirect postindexed mode |
| /// 16 M68020 ([bd,An,Xn.L,SCALE],od) v memory indirect preindexed mode |
| /// 15 M68020 ([bd,An,Xn.W,SCALE],od) V memory indirect preindexed mode |
| /// 20 M68000 abs.L b absolute long address |
| /// 17 M68000 abs.W B absolute short address |
| /// 21 M68000 (i,PC) q program counter with displacement |
| /// 23 M68000 (i,PC,Xn.L) k program counter with index and scale = 1 |
| /// 22 M68000 (i,PC,Xn.W) K program counter with index and scale = 1 |
| /// 25 M68020 (i,PC,Xn.L,SCALE) l program counter with index |
| /// 24 M68020 (i,PC,Xn.W,SCALE) L program counter with index |
| /// 27 M68020 ([bd,PC],Xn.L,SCALE,od) x program counter memory indirect postindexed mode |
| /// 26 M68020 ([bd,PC],Xn.W,SCALE,od) X program counter memory indirect postindexed mode |
| /// 31 M68020 ([bd,PC,Xn.L,SCALE],od) y program counter memory indirect preindexed mode |
| /// 30 M68020 ([bd,PC,Xn.W,SCALE],od) Y program counter memory indirect preindexed mode |
| /// 32 M68000 #immediate i immediate data |
| /// |
| /// NOTE that long form is always lowercase, word variants are capitalized |
| /// |
| /// Operand can be qualified with size where appropriate to force a particular |
| /// instruction encoding, e.g.: |
| /// (i8,An,Xn.W) f8 1 extension word |
| /// (i16,An,Xn.W) f16 2 extension words |
| /// (i32,An,Xn.W) f32 3 extension words |
| /// |
| /// Form without size qualifier will adapt to operand size automatically, e.g.: |
| /// (i,An,Xn.W) f 1, 2 or 3 extension words |
| /// |
| /// Some forms already imply a particular size of their operands, e.g.: |
| /// (i,An) p 1 extension word and i is 16bit |
| /// |
| /// Operand order follows x86 Intel order(destination before source), e.g.: |
| /// MOV8df MOVE (4,A0,D0), D1 |
| /// |
| /// Number after instruction mnemonics determines the size of the data |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| /// ??? Is it possible to use this stuff for disassembling? |
| /// NOTE 1: In case of conditional beads(DA, DAReg), cond part is able to |
| /// consume any bit, though a more general instructions must be chosen, e.g. |
| /// d -> r, a -> r |
| |
| //===----------------------------------------------------------------------===// |
| // Encoding primitives |
| //===----------------------------------------------------------------------===// |
| |
| class MxBead<bits<4> type, bit b4 = 0, bit b5 = 0, bit b6 = 0, bit b7 = 0> { |
| bits<8> Value = 0b00000000; |
| let Value{3-0} = type; |
| let Value{4} = b4; |
| let Value{5} = b5; |
| let Value{6} = b6; |
| let Value{7} = b7; |
| } |
| |
| /// System beads, allow to control beading flow |
| def MxBeadTerm : MxBead<0x0, 0, 0, 0, 0>; |
| def MxBeadIgnore : MxBead<0x0, 1, 0, 0, 0>; |
| |
| /// Add plain bit to the instruction |
| class MxBead1Bit <bits<1> b> : MxBead<0x1, b>; |
| class MxBead2Bits <bits<2> b> : MxBead<0x2, b{0}, b{1}>; |
| class MxBead3Bits <bits<3> b> : MxBead<0x3, b{0}, b{1}, b{2}>; |
| class MxBead4Bits <bits<4> b> : MxBead<0x4, b{0}, b{1}, b{2}, b{3}>; |
| |
| /// bits<3> o - operand number |
| /// bit a - use alternative, used to select index register or |
| /// outer displacement/immediate |
| /// suffix NP means non-padded |
| class MxBeadDAReg <bits<3> o, bit a = 0> : MxBead<0x5, o{0}, o{1}, o{2}, a>; |
| class MxBeadDA <bits<3> o, bit a = 0> : MxBead<0x6, o{0}, o{1}, o{2}, a>; |
| class MxBeadReg <bits<3> o, bit a = 0> : MxBead<0x7, o{0}, o{1}, o{2}, a>; |
| class MxBeadDReg <bits<3> o, bit a = 0> : MxBead<0x8, o{0}, o{1}, o{2}, a>; |
| class MxBead8Disp <bits<3> o, bit a = 0> : MxBead<0x9, o{0}, o{1}, o{2}, a>; |
| |
| /// Add Immediate to the instruction. 8-bit version is padded with zeros to fit |
| /// the word. |
| class MxBead8Imm <bits<3> o, bit a = 0> : MxBead<0xA, o{0}, o{1}, o{2}, a>; |
| class MxBead16Imm <bits<3> o, bit a = 0> : MxBead<0xB, o{0}, o{1}, o{2}, a>; |
| class MxBead32Imm <bits<3> o, bit a = 0> : MxBead<0xC, o{0}, o{1}, o{2}, a>; |
| |
| /// Encodes an immediate 0-7(alt. 1-8) into 3 bit field |
| class MxBead3Imm <bits<3> o, bit a = 0> : MxBead<0xD, o{0}, o{1}, o{2}, a>; |
| |
| |
| class MxEncoding<MxBead n0 = MxBeadTerm, MxBead n1 = MxBeadTerm, |
| MxBead n2 = MxBeadTerm, MxBead n3 = MxBeadTerm, |
| MxBead n4 = MxBeadTerm, MxBead n5 = MxBeadTerm, |
| MxBead n6 = MxBeadTerm, MxBead n7 = MxBeadTerm, |
| MxBead n8 = MxBeadTerm, MxBead n9 = MxBeadTerm, |
| MxBead n10 = MxBeadTerm, MxBead n11 = MxBeadTerm, |
| MxBead n12 = MxBeadTerm, MxBead n13 = MxBeadTerm, |
| MxBead n14 = MxBeadTerm, MxBead n15 = MxBeadTerm, |
| MxBead n16 = MxBeadTerm, MxBead n17 = MxBeadTerm, |
| MxBead n18 = MxBeadTerm, MxBead n19 = MxBeadTerm, |
| MxBead n20 = MxBeadTerm, MxBead n21 = MxBeadTerm, |
| MxBead n22 = MxBeadTerm, MxBead n23 = MxBeadTerm> { |
| bits <192> Value; |
| let Value{7-0} = n0.Value; |
| let Value{15-8} = n1.Value; |
| let Value{23-16} = n2.Value; |
| let Value{31-24} = n3.Value; |
| let Value{39-32} = n4.Value; |
| let Value{47-40} = n5.Value; |
| let Value{55-48} = n6.Value; |
| let Value{63-56} = n7.Value; |
| let Value{71-64} = n8.Value; |
| let Value{79-72} = n9.Value; |
| let Value{87-80} = n10.Value; |
| let Value{95-88} = n11.Value; |
| let Value{103-96} = n12.Value; |
| let Value{111-104} = n13.Value; |
| let Value{119-112} = n14.Value; |
| let Value{127-120} = n15.Value; |
| let Value{135-128} = n16.Value; |
| let Value{143-136} = n17.Value; |
| let Value{151-144} = n18.Value; |
| let Value{159-152} = n19.Value; |
| let Value{167-160} = n20.Value; |
| let Value{175-168} = n21.Value; |
| let Value{183-176} = n22.Value; |
| let Value{191-184} = n23.Value; |
| } |
| |
| class MxEncFixed<bits<16> value> : MxEncoding { |
| let Value{7-0} = MxBead4Bits<value{3-0}>.Value; |
| let Value{15-8} = MxBead4Bits<value{7-4}>.Value; |
| let Value{23-16} = MxBead4Bits<value{11-8}>.Value; |
| let Value{31-24} = MxBead4Bits<value{15-12}>.Value; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Encoding composites |
| // |
| // These must be lowered to MxEncoding by instr specific wrappers |
| // |
| // HERE BE DRAGONS... |
| //===----------------------------------------------------------------------===// |
| |
| class MxEncByte<bits<8> value> : MxEncoding { |
| MxBead4Bits LO = MxBead4Bits<value{3-0}>; |
| MxBead4Bits HI = MxBead4Bits<value{7-4}>; |
| } |
| |
| def MxEncEmpty : MxEncoding; |
| |
| |
| /// M68k Standard Effective Address layout: |
| /// |
| /// :-------------------: |
| /// | 5 4 3 | 2 1 0 | |
| /// | mode | reg | |
| /// :-------------------: |
| /// |
| /// If the EA is a direct register mode, bits 4 and 5 are 0, and the register |
| /// number will be encoded in bit 0 - 3. Since the first address register's |
| /// (A0) register number is 8, we can easily tell data registers from |
| /// address registers by only inspecting bit 3 (i.e. if bit 3 is set, it's an |
| /// address register). |
| /// |
| /// |
| /// But MOVE instruction uses reversed layout for destination EA: |
| /// |
| /// :-------------------: |
| /// | 5 4 3 | 2 1 0 | |
| /// | reg | mode | |
| /// :-------------------: |
| /// |
| /// And this complicates things a bit because the DA bit is now separated from |
| /// the register and we have to encode those separately using MxBeadDA<opN> |
| /// |
| class MxEncEA<MxBead reg, MxBead mode, MxBead da = MxBeadIgnore> { |
| MxBead Reg = reg; |
| MxBead Mode = mode; |
| MxBead DA = da; |
| } |
| |
| class MxEncMemOp { |
| dag EA = (ascend); |
| dag Supplement = (ascend); |
| } |
| |
| // FIXME: Is there a way to factorize the addressing mode suffix (i.e. |
| // 'r', 'd', 'a' etc.) and use something like multiclass to replace? |
| def MxEncEAr_0: MxEncEA<MxBeadDAReg<0>, MxBead2Bits<0b00>>; |
| def MxEncEAd_0: MxEncEA<MxBeadDReg<0>, MxBead2Bits<0b00>, MxBead1Bit<0>>; |
| def MxEncEAa_0: MxEncEA<MxBeadReg<0>, MxBead2Bits<0b00>, MxBead1Bit<1>>; |
| def MxEncEAj_0: MxEncEA<MxBeadReg<0>, MxBead2Bits<0b01>, MxBead1Bit<0>>; |
| def MxEncEAo_0: MxEncEA<MxBeadReg<0>, MxBead2Bits<0b01>, MxBead1Bit<1>>; |
| def MxEncEAe_0: MxEncEA<MxBeadReg<0>, MxBead2Bits<0b10>, MxBead1Bit<0>>; |
| def MxEncEAp_0: MxEncEA<MxBeadReg<0>, MxBead2Bits<0b10>, MxBead1Bit<1>>; |
| def MxEncEAf_0: MxEncEA<MxBeadReg<0>, MxBead2Bits<0b11>, MxBead1Bit<0>>; |
| |
| def MxEncEAa_0_reflected : MxEncEA<MxBeadReg<0>, MxBead3Bits<0b001>>; |
| def MxEncEAr_0_reflected : MxEncEA<MxBeadReg<0>, MxBead2Bits<0b00>, MxBeadDA<0>>; |
| |
| def MxEncEAr_1: MxEncEA<MxBeadDAReg<1>, MxBead2Bits<0b00>>; |
| def MxEncEAd_1: MxEncEA<MxBeadDReg<1>, MxBead2Bits<0b00>, MxBead1Bit<0>>; |
| def MxEncEAa_1: MxEncEA<MxBeadReg<1>, MxBead2Bits<0b00>, MxBead1Bit<1>>; |
| def MxEncEAj_1: MxEncEA<MxBeadReg<1>, MxBead2Bits<0b01>, MxBead1Bit<0>>; |
| def MxEncEAo_1: MxEncEA<MxBeadReg<1>, MxBead2Bits<0b01>, MxBead1Bit<1>>; |
| def MxEncEAe_1: MxEncEA<MxBeadReg<1>, MxBead2Bits<0b10>, MxBead1Bit<0>>; |
| def MxEncEAp_1: MxEncEA<MxBeadReg<1>, MxBead2Bits<0b10>, MxBead1Bit<1>>; |
| def MxEncEAf_1: MxEncEA<MxBeadReg<1>, MxBead2Bits<0b11>, MxBead1Bit<0>>; |
| |
| def MxEncEAr_2: MxEncEA<MxBeadDAReg<2>, MxBead2Bits<0b00>>; |
| def MxEncEAd_2: MxEncEA<MxBeadDReg<2>, MxBead2Bits<0b00>, MxBead1Bit<0>>; |
| def MxEncEAa_2: MxEncEA<MxBeadReg<2>, MxBead2Bits<0b00>, MxBead1Bit<1>>; |
| def MxEncEAj_2: MxEncEA<MxBeadReg<2>, MxBead2Bits<0b01>, MxBead1Bit<0>>; |
| def MxEncEAo_2: MxEncEA<MxBeadReg<2>, MxBead2Bits<0b01>, MxBead1Bit<1>>; |
| def MxEncEAe_2: MxEncEA<MxBeadReg<2>, MxBead2Bits<0b10>, MxBead1Bit<0>>; |
| def MxEncEAp_2: MxEncEA<MxBeadReg<2>, MxBead2Bits<0b10>, MxBead1Bit<1>>; |
| def MxEncEAf_2: MxEncEA<MxBeadReg<2>, MxBead2Bits<0b11>, MxBead1Bit<0>>; |
| |
| def MxEncEAb : MxEncEA<MxBead3Bits<0b001>, MxBead2Bits<0b11>, MxBead1Bit<1>>; |
| def MxEncEAq : MxEncEA<MxBead3Bits<0b010>, MxBead2Bits<0b11>, MxBead1Bit<1>>; |
| def MxEncEAk : MxEncEA<MxBead3Bits<0b011>, MxBead2Bits<0b11>, MxBead1Bit<1>>; |
| def MxEncEAi : MxEncEA<MxBead3Bits<0b100>, MxBead2Bits<0b11>, MxBead1Bit<1>>; |
| |
| class MxEncBriefExt<string reg_opnd, string disp_opnd, |
| bit size_w_l = false, int scale = 1, |
| string disp_encoder = ""> { |
| dag Value = (descend |
| // D/A + REGISTER |
| (operand "$"#reg_opnd, 4), |
| // W/L |
| size_w_l, |
| // SCALE |
| !cond( |
| !eq(scale, 1) : 0b00, |
| !eq(scale, 2) : 0b01, |
| !eq(scale, 4) : 0b10, |
| !eq(scale, 8) : 0b11 |
| ), |
| 0b0, |
| // Displacement |
| (operand "$"#disp_opnd, 8, (encoder disp_encoder)) |
| ); |
| } |
| |
| class MxEncAddrMode_d<string reg_opnd> : MxEncMemOp { |
| let EA = (descend /*MODE*/0b000, |
| /*REGISTER*/(operand "$"#reg_opnd, 3)); |
| } |
| |
| class MxEncAddrMode_a<string reg_opnd> : MxEncMemOp { |
| let EA = (descend /*MODE*/0b001, |
| /*REGISTER*/(operand "$"#reg_opnd, 3)); |
| } |
| |
| class MxEncAddrMode_r<string reg_opnd> : MxEncMemOp { |
| let EA = (descend /*MODE without the last bit*/0b00, |
| /*REGISTER with D/A bit*/(operand "$"#reg_opnd, 4)); |
| } |
| |
| class MxEncAddrMode_k<string opnd_name> : MxEncMemOp { |
| let EA = (descend /*MODE*/0b111, |
| /*REGISTER*/0b011); |
| |
| let Supplement = MxEncBriefExt<opnd_name#".index", opnd_name#".disp", |
| /*W/L*/true, /*SCALE*/1, |
| "encodePCRelImm<8>">.Value; |
| } |
| |
| class MxEncAddrMode_q<string opnd_name> : MxEncMemOp { |
| let EA = (descend /*MODE*/0b111, |
| /*REGISTER*/0b010); |
| |
| // 16-bit Displacement |
| let Supplement = (operand "$"#opnd_name, 16, |
| (encoder "encodePCRelImm<16>")); |
| } |
| |
| class MxEncAddrMode_p<string opnd_name> : MxEncMemOp { |
| let EA = (descend /*MODE*/0b101, |
| /*REGISTER*/(operand "$"#opnd_name#".reg", 3)); |
| |
| // 16-bit Displacement |
| let Supplement = (operand "$"#opnd_name#".disp", 16, |
| (encoder "encodeRelocImm<16>")); |
| } |
| |
| class MxEncAddrMode_f<string opnd_name> : MxEncMemOp { |
| let EA = (descend /*MODE*/0b110, |
| /*REGISTER*/(operand "$"#opnd_name#".reg", 3)); |
| |
| let Supplement = MxEncBriefExt<opnd_name#".index", opnd_name#".disp", |
| /*W/L*/true, /*SCALE*/1, |
| "encodeRelocImm<8>">.Value; |
| } |
| |
| class MxEncAddrMode_j<string reg_opnd> : MxEncMemOp { |
| let EA = (descend /*MODE*/0b010, |
| /*REGISTER*/(operand "$"#reg_opnd, 3)); |
| } |
| |
| class MxEncAddrMode_i<string opnd_name, int size> : MxEncMemOp { |
| let EA = (descend /*MODE*/0b111, |
| /*REGISTER*/0b100); |
| |
| // Immediate |
| let Supplement = |
| !cond( |
| !eq(size, 8) : (descend 0b00000000, (operand "$"#opnd_name, 8, |
| (encoder "encodeRelocImm<8>"))), |
| !eq(size, 16) : (operand "$"#opnd_name, 16, |
| (encoder "encodeRelocImm<16>")), |
| !eq(size, 32) : (operand "$"#opnd_name, 32, |
| (encoder "encodeRelocImm<32>"), |
| (decoder "DecodeImm32")) |
| ); |
| } |
| |
| // abs.W -> size_w_l = false |
| // abs.L -> size_w_l = true |
| class MxEncAddrMode_abs<string opnd_name, bit size_w_l = false> : MxEncMemOp { |
| let EA = (descend /*MODE*/0b111, |
| // Wrap the REGISTER part in another dag to make sure |
| // the dag assigned to EA only has two arguments. Such |
| // that it's easier for MOV instructions to reverse |
| // on its destination part. |
| /*REGISTER*/(descend 0b00, size_w_l)); |
| |
| // Absolute address |
| let Supplement = !if(size_w_l, |
| // abs.L |
| (operand "$"#opnd_name, 32, (encoder "encodeRelocImm<32>"), |
| (decoder "DecodeImm32")), |
| // abs.W |
| (operand "$"#opnd_name, 16, (encoder "encodeRelocImm<16>")) |
| ); |
| } |
| |
| class MxEncAddrMode_o<string reg_opnd> : MxEncMemOp { |
| let EA = (descend /*MODE*/0b011, |
| /*REGISTER*/(operand "$"#reg_opnd, 3)); |
| } |
| |
| class MxEncAddrMode_e<string reg_opnd> : MxEncMemOp { |
| let EA = (descend /*MODE*/0b100, |
| /*REGISTER*/(operand "$"#reg_opnd, 3)); |
| } |
| |
| // Allows you to specify each bit of opcode |
| class MxEncOpMode<MxBead b0, MxBead b1 = MxBeadIgnore, MxBead b2 = MxBeadIgnore> { |
| MxBead B0 = b0; |
| MxBead B1 = b1; |
| MxBead B2 = b2; |
| } |
| |
| // op EA, Dn |
| def MxOpMode8dEA : MxEncOpMode<MxBead3Bits<0b000>>; |
| def MxOpMode16dEA : MxEncOpMode<MxBead3Bits<0b001>>; |
| def MxOpMode32dEA : MxEncOpMode<MxBead3Bits<0b010>>; |
| |
| // op EA, An |
| def MxOpMode16aEA : MxEncOpMode<MxBead3Bits<0b011>>; |
| def MxOpMode32aEA : MxEncOpMode<MxBead3Bits<0b111>>; |
| |
| // op EA, Rn |
| // As you might noticed this guy is special... Since M68k differentiates |
| // between Data and Address registers we required to use different OPMODE codes |
| // for Address registers DST operands. One way of dealing with it is to use |
| // separate tablegen instructions, but in this case it would force Register |
| // Allocator to use specific Register Classes and eventually will lead to |
| // superfluous moves. Another approach is to use reg-variadic encoding which will |
| // change OPMODE base on Register Class used. Luckily, all the bits that differ go |
| // from 0 to 1 and can be encoded with MxBeadDA. |
| // Basically, if the register used is of Data type these encodings will be |
| // the same as MxOpMode{16,32}dEA above and used with regular instructions(e.g. ADD, |
| // SUB), but if the register is of Address type the appropriate bits will flip and |
| // the instructions become of *A type(e.g ADDA, SUBA). |
| def MxOpMode16rEA : MxEncOpMode<MxBead1Bit<1>, MxBeadDA<0>, MxBead1Bit<0>>; |
| def MxOpMode32rEA : MxEncOpMode<MxBeadDA<0>, MxBead1Bit<1>, MxBeadDA<0>>; |
| |
| // op Dn, EA |
| def MxOpMode8EAd : MxEncOpMode<MxBead3Bits<0b100>>; |
| def MxOpMode16EAd : MxEncOpMode<MxBead3Bits<0b101>>; |
| def MxOpMode32EAd : MxEncOpMode<MxBead3Bits<0b110>>; |
| |
| |
| // Represents two types of extension word: |
| // - Imm extension word |
| // - Brief extension word |
| class MxEncExt<MxBead imm = MxBeadIgnore, MxBead b8 = MxBeadIgnore, |
| MxBead scale = MxBeadIgnore, MxBead wl = MxBeadIgnore, |
| MxBead daReg = MxBeadIgnore> { |
| MxBead Imm = imm; |
| MxBead B8 = b8; |
| MxBead Scale = scale; |
| MxBead WL = wl; |
| MxBead DAReg = daReg; |
| } |
| |
| def MxExtEmpty : MxEncExt; |
| |
| // These handle encoding of displacement fields, absolute addresses and |
| // immediate values, since encoding for these categories is mainly the same, |
| // with exception of some weird immediates. |
| def MxExtI8_0 : MxEncExt<MxBead8Imm<0>>; |
| def MxExtI16_0 : MxEncExt<MxBead16Imm<0>>; |
| def MxExtI32_0 : MxEncExt<MxBead32Imm<0>>; |
| |
| def MxExtI8_1 : MxEncExt<MxBead8Imm<1>>; |
| def MxExtI16_1 : MxEncExt<MxBead16Imm<1>>; |
| def MxExtI32_1 : MxEncExt<MxBead32Imm<1>>; |
| |
| def MxExtI8_2 : MxEncExt<MxBead8Imm<2>>; |
| def MxExtI16_2 : MxEncExt<MxBead16Imm<2>>; |
| def MxExtI32_2 : MxEncExt<MxBead32Imm<2>>; |
| |
| // NOTE They are all using Long Xn |
| def MxExtBrief_0 : MxEncExt<MxBead8Disp<0>, MxBead1Bit<0b0>, |
| MxBead2Bits<0b00>, MxBead1Bit<1>, |
| MxBeadDAReg<0, 1>>; |
| |
| def MxExtBrief_1 : MxEncExt<MxBead8Disp<1>, MxBead1Bit<0b0>, |
| MxBead2Bits<0b00>, MxBead1Bit<1>, |
| MxBeadDAReg<1, 1>>; |
| |
| def MxExtBrief_2 : MxEncExt<MxBead8Disp<2>, MxBead1Bit<0b0>, |
| MxBead2Bits<0b00>, MxBead1Bit<1>, |
| MxBeadDAReg<2, 1>>; |
| |
| def MxExtBrief_3 : MxEncExt<MxBead8Disp<3>, MxBead1Bit<0b0>, |
| MxBead2Bits<0b00>, MxBead1Bit<1>, |
| MxBeadDAReg<3, 1>>; |
| |
| def MxExtBrief_4 : MxEncExt<MxBead8Disp<4>, MxBead1Bit<0b0>, |
| MxBead2Bits<0b00>, MxBead1Bit<1>, |
| MxBeadDAReg<4, 1>>; |
| |
| class MxEncSize<bits<2> value> : MxBead2Bits<value>; |
| def MxEncSize8 : MxEncSize<0b00>; |
| def MxEncSize16 : MxEncSize<0b01>; |
| def MxEncSize32 : MxEncSize<0b10>; |
| def MxEncSize64 : MxEncSize<0b11>; |
| |
| // TODO: Remove "New" in the name after the codebead-based |
| // representation is deprecated. |
| class MxNewEncSize<bits<2> value> { |
| bits<2> Value = value; |
| } |
| def MxNewEncSize8 : MxNewEncSize<0b00>; |
| def MxNewEncSize16 : MxNewEncSize<0b01>; |
| def MxNewEncSize32 : MxNewEncSize<0b10>; |
| def MxNewEncSize64 : MxNewEncSize<0b11>; |
| |
| // M68k INSTRUCTION. Most instructions specify the location of an operand by |
| // using the effective address field in the operation word. The effective address |
| // is composed of two 3-bit fields: the mode field and the register field. The |
| // value in the mode field selects the different address modes. The register |
| // field contains the number of a register. The effective address field may |
| // require additional information to fully specify the operand. This additional |
| // information, called the effective address extension, is contained in the |
| // following word or words and is considered part of the instruction. The |
| // effective address modes are grouped into three categories: register direct, |
| // memory addressing, and special. |
| class MxInst<dag outs, dag ins, |
| string asmStr = "", |
| list<dag> pattern = [], |
| MxEncoding beads = MxEncEmpty, |
| InstrItinClass itin = NoItinerary> |
| : Instruction { |
| let Namespace = "M68k"; |
| let OutOperandList = outs; |
| let InOperandList = ins; |
| let AsmString = asmStr; |
| let Pattern = pattern; |
| let Itinerary = itin; |
| |
| // Byte stream |
| field bits<192> Beads = beads.Value; |
| dag Inst = (ascend); |
| |
| // Number of bytes |
| let Size = 0; |
| |
| let UseLogicalOperandMappings = 1; |
| } |
| |
| // M68k PSEUDO INSTRUCTION |
| class MxPseudo<dag outs, dag ins, list<dag> pattern = []> |
| : MxInst<outs, ins, "; error: this should not be emitted", pattern> { |
| let isPseudo = 1; |
| } |
