[llvm] [AVR] Refactor ADIW/SBIW/MOVW instruction descriptions (NFCI) (PR #156876)
Sergei Barannikov via llvm-commits
llvm-commits at lists.llvm.org
Thu Sep 4 06:00:58 PDT 2025
https://github.com/s-barannikov updated https://github.com/llvm/llvm-project/pull/156876
>From 9e54cd155b09ffce47613eb05e7efc60b32fa2c4 Mon Sep 17 00:00:00 2001
From: Sergei Barannikov <barannikov88 at gmail.com>
Date: Thu, 4 Sep 2025 15:29:31 +0300
Subject: [PATCH] [AVR] Refactor ADIW/SBIW/MOVW instruction descriptions
* Remove custom decoders for these instructions
* Instead, provide decoders for DREGS/IWREGS register classes
* Remove unnecessary RdRr suffix from instruction names
* Change register pair encodings to simplify instruction descriptions
---
llvm/lib/Target/AVR/AVRExpandPseudoInsts.cpp | 28 +++++-----
llvm/lib/Target/AVR/AVRInstrFormats.td | 20 +++----
llvm/lib/Target/AVR/AVRInstrInfo.cpp | 12 ++--
llvm/lib/Target/AVR/AVRInstrInfo.td | 9 ++-
llvm/lib/Target/AVR/AVRRegisterInfo.cpp | 6 +-
llvm/lib/Target/AVR/AVRRegisterInfo.td | 40 ++++++++------
.../AVR/Disassembler/AVRDisassembler.cpp | 55 ++++++++-----------
llvm/test/CodeGen/AVR/pseudo/ASRWNRd.mir | 8 +--
llvm/test/CodeGen/AVR/pseudo/LSLWNRd.mir | 4 +-
llvm/test/CodeGen/AVR/pseudo/LSRWNRd.mir | 4 +-
llvm/test/CodeGen/AVR/pseudo/SEXT.mir | 4 +-
llvm/test/CodeGen/AVR/pseudo/ZEXT.mir | 4 +-
12 files changed, 93 insertions(+), 101 deletions(-)
diff --git a/llvm/lib/Target/AVR/AVRExpandPseudoInsts.cpp b/llvm/lib/Target/AVR/AVRExpandPseudoInsts.cpp
index 90505aa82aa46..b5422113ed0a8 100644
--- a/llvm/lib/Target/AVR/AVRExpandPseudoInsts.cpp
+++ b/llvm/lib/Target/AVR/AVRExpandPseudoInsts.cpp
@@ -871,7 +871,7 @@ bool AVRExpandPseudo::expandLPMWELPMW(Block &MBB, BlockIt MBBI, bool IsELPM) {
unsigned Opc = IsELPM ? AVR::ELPM : AVR::LPM;
// Load low byte, and copy to the low destination register.
auto MIBLO = buildMI(MBB, MBBI, Opc);
- buildMI(MBB, MBBI, AVR::MOVRdRr)
+ buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstLoReg, RegState::Define)
.addReg(AVR::R0, RegState::Kill);
MIBLO.setMemRefs(MI.memoperands());
@@ -899,7 +899,7 @@ bool AVRExpandPseudo::expandLPMWELPMW(Block &MBB, BlockIt MBBI, bool IsELPM) {
}
// Load high byte, and copy to the high destination register.
auto MIBHI = buildMI(MBB, MBBI, Opc);
- buildMI(MBB, MBBI, AVR::MOVRdRr)
+ buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstHiReg, RegState::Define)
.addReg(AVR::R0, RegState::Kill);
MIBHI.setMemRefs(MI.memoperands());
@@ -970,7 +970,7 @@ bool AVRExpandPseudo::expandLPMBELPMB(Block &MBB, BlockIt MBBI, bool IsELPM) {
// 'Z' register, and its operand[1] is the implicit 'R0' register.
unsigned Opc = IsELPM ? AVR::ELPM : AVR::LPM;
auto MILB = buildMI(MBB, MBBI, Opc);
- buildMI(MBB, MBBI, AVR::MOVRdRr)
+ buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstReg, RegState::Define)
.addReg(AVR::R0, RegState::Kill);
MILB.setMemRefs(MI.memoperands());
@@ -1681,7 +1681,7 @@ bool AVRExpandPseudo::expandLSLW8Rd(Block &MBB, BlockIt MBBI) {
TRI->splitReg(DstReg, DstLoReg, DstHiReg);
// mov Rh, Rl
- buildMI(MBB, MBBI, AVR::MOVRdRr)
+ buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstHiReg, RegState::Define | getDeadRegState(DstIsDead))
.addReg(DstLoReg);
@@ -1708,7 +1708,7 @@ bool AVRExpandPseudo::expandLSLW12Rd(Block &MBB, BlockIt MBBI) {
TRI->splitReg(DstReg, DstLoReg, DstHiReg);
// mov Rh, Rl
- buildMI(MBB, MBBI, AVR::MOVRdRr)
+ buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstHiReg, RegState::Define | getDeadRegState(DstIsDead))
.addReg(DstLoReg);
@@ -1879,7 +1879,7 @@ bool AVRExpandPseudo::expandLSRW8Rd(Block &MBB, BlockIt MBBI) {
TRI->splitReg(DstReg, DstLoReg, DstHiReg);
// Move upper byte to lower byte.
- buildMI(MBB, MBBI, AVR::MOVRdRr)
+ buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstLoReg, RegState::Define | getDeadRegState(DstIsDead))
.addReg(DstHiReg);
@@ -1906,7 +1906,7 @@ bool AVRExpandPseudo::expandLSRW12Rd(Block &MBB, BlockIt MBBI) {
TRI->splitReg(DstReg, DstLoReg, DstHiReg);
// Move upper byte to lower byte.
- buildMI(MBB, MBBI, AVR::MOVRdRr)
+ buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstLoReg, RegState::Define | getDeadRegState(DstIsDead))
.addReg(DstHiReg);
@@ -2042,7 +2042,7 @@ bool AVRExpandPseudo::expandASRW7Rd(Block &MBB, BlockIt MBBI) {
.addReg(DstLoReg, RegState::Kill);
// mov r24, r25
- buildMI(MBB, MBBI, AVR::MOVRdRr)
+ buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstLoReg, RegState::Define | getDeadRegState(DstIsDead))
.addReg(DstHiReg);
@@ -2078,7 +2078,7 @@ bool AVRExpandPseudo::expandASRW8Rd(Block &MBB, BlockIt MBBI) {
TRI->splitReg(DstReg, DstLoReg, DstHiReg);
// Move upper byte to lower byte.
- buildMI(MBB, MBBI, AVR::MOVRdRr)
+ buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstLoReg, RegState::Define | getDeadRegState(DstIsDead))
.addReg(DstHiReg);
@@ -2137,7 +2137,7 @@ bool AVRExpandPseudo::expandASRW14Rd(Block &MBB, BlockIt MBBI) {
.addReg(DstHiReg, RegState::Kill);
// mov r25, r24
- buildMI(MBB, MBBI, AVR::MOVRdRr)
+ buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstHiReg, RegState::Define | getDeadRegState(DstIsDead))
.addReg(DstLoReg);
@@ -2187,7 +2187,7 @@ bool AVRExpandPseudo::expandASRW15Rd(Block &MBB, BlockIt MBBI) {
MISBC->getOperand(4).setIsKill();
// mov r24, r25
- buildMI(MBB, MBBI, AVR::MOVRdRr)
+ buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstLoReg, RegState::Define | getDeadRegState(DstIsDead))
.addReg(DstHiReg);
@@ -2424,12 +2424,12 @@ template <> bool AVRExpandPseudo::expand<AVR::SEXT>(Block &MBB, BlockIt MBBI) {
TRI->splitReg(DstReg, DstLoReg, DstHiReg);
if (SrcReg != DstLoReg)
- buildMI(MBB, MBBI, AVR::MOVRdRr)
+ buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstLoReg, RegState::Define | getDeadRegState(DstIsDead))
.addReg(SrcReg);
if (SrcReg != DstHiReg) {
- auto MOV = buildMI(MBB, MBBI, AVR::MOVRdRr)
+ auto MOV = buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstHiReg, RegState::Define)
.addReg(SrcReg);
if (SrcReg != DstLoReg && SrcIsKill)
@@ -2476,7 +2476,7 @@ template <> bool AVRExpandPseudo::expand<AVR::ZEXT>(Block &MBB, BlockIt MBBI) {
TRI->splitReg(DstReg, DstLoReg, DstHiReg);
if (SrcReg != DstLoReg) {
- buildMI(MBB, MBBI, AVR::MOVRdRr)
+ buildMI(MBB, MBBI, AVR::MOV)
.addReg(DstLoReg, RegState::Define | getDeadRegState(DstIsDead))
.addReg(SrcReg, getKillRegState(SrcIsKill));
}
diff --git a/llvm/lib/Target/AVR/AVRInstrFormats.td b/llvm/lib/Target/AVR/AVRInstrFormats.td
index e1e65b56370cc..0ea9d4245b9a2 100644
--- a/llvm/lib/Target/AVR/AVRInstrFormats.td
+++ b/llvm/lib/Target/AVR/AVRInstrFormats.td
@@ -220,18 +220,16 @@ class FLPMX<bit e, bit p, dag outs, dag ins, string asmstr, list<dag> pattern>
// MOVWRdRr special encoding: <|0000|0001|dddd|rrrr|>
// d = destination = 4 bits
// r = source = 4 bits
-// (Only accepts even registers)
+// (Only accepts register pairs)
//===----------------------------------------------------------------------===//
-class FMOVWRdRr<dag outs, dag ins, string asmstr, list<dag> pattern>
+class FMOVW<dag outs, dag ins, string asmstr, list<dag> pattern>
: AVRInst16<outs, ins, asmstr, pattern> {
- bits<5> rd;
- bits<5> rr;
+ bits<4> rd;
+ bits<4> rr;
let Inst{15 - 8} = 0b00000001;
- let Inst{7 - 4} = rd{4 - 1};
- let Inst{3 - 0} = rr{4 - 1};
-
- let DecoderMethod = "decodeFMOVWRdRr";
+ let Inst{7 - 4} = rd;
+ let Inst{3 - 0} = rr;
}
//===----------------------------------------------------------------------===//
@@ -286,16 +284,14 @@ class FFMULRdRr<bits<2> f, dag outs, dag ins, string asmstr, list<dag> pattern>
//===----------------------------------------------------------------------===//
class FWRdK<bit f, dag outs, dag ins, string asmstr, list<dag> pattern>
: AVRInst16<outs, ins, asmstr, pattern> {
- bits<5> rd; // accept 5 bits but only encode bits 1 and 2
+ bits<2> rd;
bits<6> k;
let Inst{15 - 9} = 0b1001011;
let Inst{8} = f;
let Inst{7 - 6} = k{5 - 4};
- let Inst{5 - 4} = rd{2 - 1};
+ let Inst{5 - 4} = rd;
let Inst{3 - 0} = k{3 - 0};
-
- let DecoderMethod = "decodeFWRdK";
}
//===----------------------------------------------------------------------===//
diff --git a/llvm/lib/Target/AVR/AVRInstrInfo.cpp b/llvm/lib/Target/AVR/AVRInstrInfo.cpp
index 601068bf17933..236ca490ef7de 100644
--- a/llvm/lib/Target/AVR/AVRInstrInfo.cpp
+++ b/llvm/lib/Target/AVR/AVRInstrInfo.cpp
@@ -45,7 +45,7 @@ void AVRInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
// If our AVR has `movw`, let's emit that; otherwise let's emit two separate
// `mov`s.
if (STI.hasMOVW() && AVR::DREGSMOVWRegClass.contains(DestReg, SrcReg)) {
- BuildMI(MBB, MI, DL, get(AVR::MOVWRdRr), DestReg)
+ BuildMI(MBB, MI, DL, get(AVR::MOVW), DestReg)
.addReg(SrcReg, getKillRegState(KillSrc));
} else {
Register DestLo, DestHi, SrcLo, SrcHi;
@@ -59,20 +59,20 @@ void AVRInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
// verifier, when subreg liveness is enabled.
// TODO: Eliminate these unnecessary copies.
if (DestLo == SrcHi) {
- BuildMI(MBB, MI, DL, get(AVR::MOVRdRr), DestHi)
+ BuildMI(MBB, MI, DL, get(AVR::MOV), DestHi)
.addReg(SrcHi, getKillRegState(KillSrc) | RegState::Undef);
- BuildMI(MBB, MI, DL, get(AVR::MOVRdRr), DestLo)
+ BuildMI(MBB, MI, DL, get(AVR::MOV), DestLo)
.addReg(SrcLo, getKillRegState(KillSrc) | RegState::Undef);
} else {
- BuildMI(MBB, MI, DL, get(AVR::MOVRdRr), DestLo)
+ BuildMI(MBB, MI, DL, get(AVR::MOV), DestLo)
.addReg(SrcLo, getKillRegState(KillSrc) | RegState::Undef);
- BuildMI(MBB, MI, DL, get(AVR::MOVRdRr), DestHi)
+ BuildMI(MBB, MI, DL, get(AVR::MOV), DestHi)
.addReg(SrcHi, getKillRegState(KillSrc) | RegState::Undef);
}
}
} else {
if (AVR::GPR8RegClass.contains(DestReg, SrcReg)) {
- Opc = AVR::MOVRdRr;
+ Opc = AVR::MOV;
} else if (SrcReg == AVR::SP && AVR::DREGSRegClass.contains(DestReg)) {
Opc = AVR::SPREAD;
} else if (DestReg == AVR::SP && AVR::DREGSRegClass.contains(SrcReg)) {
diff --git a/llvm/lib/Target/AVR/AVRInstrInfo.td b/llvm/lib/Target/AVR/AVRInstrInfo.td
index 958e1383acef2..880e3e35ced48 100644
--- a/llvm/lib/Target/AVR/AVRInstrInfo.td
+++ b/llvm/lib/Target/AVR/AVRInstrInfo.td
@@ -848,12 +848,11 @@ let isBranch = 1, isTerminator = 1, Uses = [SREG] in {
//===----------------------------------------------------------------------===//
// 8 and 16-bit register move instructions.
let hasSideEffects = 0 in {
- def MOVRdRr : FRdRr<0b0010, 0b11, (outs GPR8:$rd), (ins GPR8:$rr),
- "mov\t$rd, $rr", []>;
+ def MOV : FRdRr<0b0010, 0b11, (outs GPR8:$rd), (ins GPR8:$rr),
+ "mov\t$rd, $rr", []>;
- def MOVWRdRr : FMOVWRdRr<(outs DREGS:$rd), (ins DREGS:$rr), "movw\t$rd, $rr",
- []>,
- Requires<[HasMOVW]>;
+ def MOVW : FMOVW<(outs DREGS:$rd), (ins DREGS:$rr), "movw\t$rd, $rr", []>,
+ Requires<[HasMOVW]>;
}
// Load immediate values into registers.
diff --git a/llvm/lib/Target/AVR/AVRRegisterInfo.cpp b/llvm/lib/Target/AVR/AVRRegisterInfo.cpp
index 051affe7110dd..7b894d0876c65 100644
--- a/llvm/lib/Target/AVR/AVRRegisterInfo.cpp
+++ b/llvm/lib/Target/AVR/AVRRegisterInfo.cpp
@@ -169,12 +169,12 @@ bool AVRRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
// Copy the frame pointer.
if (STI.hasMOVW()) {
- BuildMI(MBB, MI, dl, TII.get(AVR::MOVWRdRr), DstReg).addReg(AVR::R29R28);
+ BuildMI(MBB, MI, dl, TII.get(AVR::MOVW), DstReg).addReg(AVR::R29R28);
} else {
Register DstLoReg, DstHiReg;
splitReg(DstReg, DstLoReg, DstHiReg);
- BuildMI(MBB, MI, dl, TII.get(AVR::MOVRdRr), DstLoReg).addReg(AVR::R28);
- BuildMI(MBB, MI, dl, TII.get(AVR::MOVRdRr), DstHiReg).addReg(AVR::R29);
+ BuildMI(MBB, MI, dl, TII.get(AVR::MOV), DstLoReg).addReg(AVR::R28);
+ BuildMI(MBB, MI, dl, TII.get(AVR::MOV), DstHiReg).addReg(AVR::R29);
}
assert(Offset > 0 && "Invalid offset");
diff --git a/llvm/lib/Target/AVR/AVRRegisterInfo.td b/llvm/lib/Target/AVR/AVRRegisterInfo.td
index 21b4aedea44cd..182f92c684dc0 100644
--- a/llvm/lib/Target/AVR/AVRRegisterInfo.td
+++ b/llvm/lib/Target/AVR/AVRRegisterInfo.td
@@ -68,33 +68,37 @@ def R31 : AVRReg<31, "r31", [], ["zh"]>, DwarfRegNum<[31]>;
def SPL : AVRReg<32, "SPL">, DwarfRegNum<[32]>;
def SPH : AVRReg<33, "SPH">, DwarfRegNum<[33]>;
+// 16 bit GPR pairs.
let SubRegIndices = [sub_lo, sub_hi], CoveredBySubRegs = 1 in {
- // 16 bit GPR pairs.
- def SP : AVRReg<32, "SP", [SPL, SPH]>, DwarfRegNum<[32]>;
+ // The value 16 for the encoding is arbitrary. SP register is not encoded
+ // into instructions, they use it implicitly depending on the opcode.
+ def SP : AVRReg<16, "SP", [SPL, SPH]>, DwarfRegNum<[32]>;
// The pointer registers (X,Y,Z) are a special case because they
// are printed as a `high:low` pair when a DREG is expected,
// but printed using `X`, `Y`, `Z` when a pointer register is expected.
+ // DREG registers are only used in ADIW, SBIW and MOVW instructions.
let RegAltNameIndices = [ptr] in {
- def R31R30 : AVRReg<30, "r31:r30", [R30, R31], ["Z"]>, DwarfRegNum<[30]>;
- def R29R28 : AVRReg<28, "r29:r28", [R28, R29], ["Y"]>, DwarfRegNum<[28]>;
- def R27R26 : AVRReg<26, "r27:r26", [R26, R27], ["X"]>, DwarfRegNum<[26]>;
+ def R31R30 : AVRReg<15, "r31:r30", [R30, R31], ["Z"]>, DwarfRegNum<[30]>;
+ def R29R28 : AVRReg<14, "r29:r28", [R28, R29], ["Y"]>, DwarfRegNum<[28]>;
+ def R27R26 : AVRReg<13, "r27:r26", [R26, R27], ["X"]>, DwarfRegNum<[26]>;
}
- def R25R24 : AVRReg<24, "r25:r24", [R24, R25]>, DwarfRegNum<[24]>;
- def R23R22 : AVRReg<22, "r23:r22", [R22, R23]>, DwarfRegNum<[22]>;
- def R21R20 : AVRReg<20, "r21:r20", [R20, R21]>, DwarfRegNum<[20]>;
- def R19R18 : AVRReg<18, "r19:r18", [R18, R19]>, DwarfRegNum<[18]>;
- def R17R16 : AVRReg<16, "r17:r16", [R16, R17]>, DwarfRegNum<[16]>;
- def R15R14 : AVRReg<14, "r15:r14", [R14, R15]>, DwarfRegNum<[14]>;
- def R13R12 : AVRReg<12, "r13:r12", [R12, R13]>, DwarfRegNum<[12]>;
- def R11R10 : AVRReg<10, "r11:r10", [R10, R11]>, DwarfRegNum<[10]>;
- def R9R8 : AVRReg<8, "r9:r8", [R8, R9]>, DwarfRegNum<[8]>;
- def R7R6 : AVRReg<6, "r7:r6", [R6, R7]>, DwarfRegNum<[6]>;
- def R5R4 : AVRReg<4, "r5:r4", [R4, R5]>, DwarfRegNum<[4]>;
- def R3R2 : AVRReg<2, "r3:r2", [R2, R3]>, DwarfRegNum<[2]>;
+ def R25R24 : AVRReg<12, "r25:r24", [R24, R25]>, DwarfRegNum<[24]>;
+ def R23R22 : AVRReg<11, "r23:r22", [R22, R23]>, DwarfRegNum<[22]>;
+ def R21R20 : AVRReg<10, "r21:r20", [R20, R21]>, DwarfRegNum<[20]>;
+ def R19R18 : AVRReg<9, "r19:r18", [R18, R19]>, DwarfRegNum<[18]>;
+ def R17R16 : AVRReg<8, "r17:r16", [R16, R17]>, DwarfRegNum<[16]>;
+ def R15R14 : AVRReg<7, "r15:r14", [R14, R15]>, DwarfRegNum<[14]>;
+ def R13R12 : AVRReg<6, "r13:r12", [R12, R13]>, DwarfRegNum<[12]>;
+ def R11R10 : AVRReg<5, "r11:r10", [R10, R11]>, DwarfRegNum<[10]>;
+ def R9R8 : AVRReg<4, "r9:r8", [R8, R9]>, DwarfRegNum<[8]>;
+ def R7R6 : AVRReg<3, "r7:r6", [R6, R7]>, DwarfRegNum<[6]>;
+ def R5R4 : AVRReg<2, "r5:r4", [R4, R5]>, DwarfRegNum<[4]>;
+ def R3R2 : AVRReg<1, "r3:r2", [R2, R3]>, DwarfRegNum<[2]>;
def R1R0 : AVRReg<0, "r1:r0", [R0, R1]>, DwarfRegNum<[0]>;
- // Pseudo registers for unaligned i16
+ // Pseudo registers for unaligned i16. These are only used in pseudo
+ // instructions, so encoding values are arbitrary.
def R26R25 : AVRReg<25, "r26:r25", [R25, R26]>, DwarfRegNum<[25]>;
def R24R23 : AVRReg<23, "r24:r23", [R23, R24]>, DwarfRegNum<[23]>;
def R22R21 : AVRReg<21, "r22:r21", [R21, R22]>, DwarfRegNum<[21]>;
diff --git a/llvm/lib/Target/AVR/Disassembler/AVRDisassembler.cpp b/llvm/lib/Target/AVR/Disassembler/AVRDisassembler.cpp
index 56b3cf7f88e2a..8152f832f89dc 100644
--- a/llvm/lib/Target/AVR/Disassembler/AVRDisassembler.cpp
+++ b/llvm/lib/Target/AVR/Disassembler/AVRDisassembler.cpp
@@ -61,7 +61,7 @@ LLVMInitializeAVRDisassembler() {
createAVRDisassembler);
}
-static const uint16_t GPRDecoderTable[] = {
+static constexpr MCRegister GPRDecoderTable[] = {
AVR::R0, AVR::R1, AVR::R2, AVR::R3, AVR::R4, AVR::R5, AVR::R6,
AVR::R7, AVR::R8, AVR::R9, AVR::R10, AVR::R11, AVR::R12, AVR::R13,
AVR::R14, AVR::R15, AVR::R16, AVR::R17, AVR::R18, AVR::R19, AVR::R20,
@@ -69,6 +69,13 @@ static const uint16_t GPRDecoderTable[] = {
AVR::R28, AVR::R29, AVR::R30, AVR::R31,
};
+static constexpr MCRegister GPRPairDecoderTable[] = {
+ AVR::R1R0, AVR::R3R2, AVR::R5R4, AVR::R7R6,
+ AVR::R9R8, AVR::R11R10, AVR::R13R12, AVR::R15R14,
+ AVR::R17R16, AVR::R19R18, AVR::R21R20, AVR::R23R22,
+ AVR::R25R24, AVR::R27R26, AVR::R29R28, AVR::R31R30,
+};
+
static DecodeStatus DecodeGPR8RegisterClass(MCInst &Inst, unsigned RegNo,
uint64_t Address,
const MCDisassembler *Decoder) {
@@ -91,6 +98,22 @@ static DecodeStatus DecodeLD8RegisterClass(MCInst &Inst, unsigned RegNo,
return MCDisassembler::Success;
}
+static DecodeStatus DecodeDREGSRegisterClass(MCInst &Inst, unsigned RegNo,
+ uint64_t Address,
+ const MCDisassembler *Decoder) {
+ assert(isUInt<4>(RegNo));
+ Inst.addOperand(MCOperand::createReg(GPRPairDecoderTable[RegNo]));
+ return MCDisassembler::Success;
+}
+
+static DecodeStatus DecodeIWREGSRegisterClass(MCInst &Inst, unsigned RegNo,
+ uint64_t Address,
+ const MCDisassembler *Decoder) {
+ assert(isUInt<2>(RegNo));
+ Inst.addOperand(MCOperand::createReg(GPRPairDecoderTable[12 + RegNo]));
+ return MCDisassembler::Success;
+}
+
static DecodeStatus decodeFIOARr(MCInst &Inst, unsigned Insn, uint64_t Address,
const MCDisassembler *Decoder) {
unsigned addr = 0;
@@ -166,36 +189,6 @@ static DecodeStatus decodeFFMULRdRr(MCInst &Inst, unsigned Insn,
return MCDisassembler::Success;
}
-static DecodeStatus decodeFMOVWRdRr(MCInst &Inst, unsigned Insn,
- uint64_t Address,
- const MCDisassembler *Decoder) {
- unsigned r = fieldFromInstruction(Insn, 4, 4) * 2;
- unsigned d = fieldFromInstruction(Insn, 0, 4) * 2;
- if (DecodeGPR8RegisterClass(Inst, r, Address, Decoder) ==
- MCDisassembler::Fail)
- return MCDisassembler::Fail;
- if (DecodeGPR8RegisterClass(Inst, d, Address, Decoder) ==
- MCDisassembler::Fail)
- return MCDisassembler::Fail;
- return MCDisassembler::Success;
-}
-
-static DecodeStatus decodeFWRdK(MCInst &Inst, unsigned Insn, uint64_t Address,
- const MCDisassembler *Decoder) {
- unsigned d = fieldFromInstruction(Insn, 4, 2) * 2 + 24; // starts at r24:r25
- unsigned k = 0;
- k |= fieldFromInstruction(Insn, 0, 4);
- k |= fieldFromInstruction(Insn, 6, 2) << 4;
- if (DecodeGPR8RegisterClass(Inst, d, Address, Decoder) ==
- MCDisassembler::Fail)
- return MCDisassembler::Fail;
- if (DecodeGPR8RegisterClass(Inst, d, Address, Decoder) ==
- MCDisassembler::Fail)
- return MCDisassembler::Fail;
- Inst.addOperand(MCOperand::createImm(k));
- return MCDisassembler::Success;
-}
-
static DecodeStatus decodeFMUL2RdRr(MCInst &Inst, unsigned Insn,
uint64_t Address,
const MCDisassembler *Decoder) {
diff --git a/llvm/test/CodeGen/AVR/pseudo/ASRWNRd.mir b/llvm/test/CodeGen/AVR/pseudo/ASRWNRd.mir
index 943421ad5f197..ca31f328d81e0 100644
--- a/llvm/test/CodeGen/AVR/pseudo/ASRWNRd.mir
+++ b/llvm/test/CodeGen/AVR/pseudo/ASRWNRd.mir
@@ -17,12 +17,12 @@ body: |
; CHECK-LABEL: test
; CHECK: $r14 = ADDRdRr killed $r14, killed $r14, implicit-def $sreg
- ; CHECK-NEXT: $r14 = MOVRdRr $r15
+ ; CHECK-NEXT: $r14 = MOV $r15
; CHECK-NEXT: $r14 = ADCRdRr $r14, $r14, implicit-def $sreg, implicit $sreg
; CHECK-NEXT: $r15 = SBCRdRr $r15, $r15, implicit-def $sreg, implicit killed $sreg
$r15r14 = ASRWNRd $r15r14, 7, implicit-def $sreg
- ; CHECK-NEXT: $r12 = MOVRdRr $r13
+ ; CHECK-NEXT: $r12 = MOV $r13
; CHECK-NEXT: $r13 = ADDRdRr killed $r13, killed $r13, implicit-def $sreg
; CHECK-NEXT: $r13 = SBCRdRr $r13, $r13, implicit-def $sreg, implicit killed $sreg
$r13r12 = ASRWNRd $r13r12, 8, implicit-def $sreg
@@ -30,12 +30,12 @@ body: |
; CHECK-NEXT: $r11 = ADDRdRr killed $r11, killed $r11, implicit-def $sreg
; CHECK-NEXT: $r10 = SBCRdRr killed $r10, killed $r10, implicit-def $sreg, implicit $sreg
; CHECK-NEXT: $r11 = ADDRdRr killed $r11, killed $r11, implicit-def $sreg
- ; CHECK-NEXT: $r11 = MOVRdRr $r10
+ ; CHECK-NEXT: $r11 = MOV $r10
; CHECK-NEXT: $r10 = ADCRdRr $r10, $r10, implicit-def $sreg, implicit killed $sreg
$r11r10 = ASRWNRd $r11r10, 14, implicit-def $sreg
; CHECK-NEXT: $r17 = ADDRdRr killed $r17, killed $r17, implicit-def $sreg
; CHECK-NEXT: $r17 = SBCRdRr killed $r17, killed $r17, implicit-def $sreg, implicit killed $sreg
- ; CHECK-NEXT: $r16 = MOVRdRr $r17
+ ; CHECK-NEXT: $r16 = MOV $r17
$r17r16 = ASRWNRd $r17r16, 15, implicit-def $sreg
...
diff --git a/llvm/test/CodeGen/AVR/pseudo/LSLWNRd.mir b/llvm/test/CodeGen/AVR/pseudo/LSLWNRd.mir
index bb8c68db97bd1..d6a3229ee1d7e 100644
--- a/llvm/test/CodeGen/AVR/pseudo/LSLWNRd.mir
+++ b/llvm/test/CodeGen/AVR/pseudo/LSLWNRd.mir
@@ -24,11 +24,11 @@ body: |
; CHECK-NEXT: $r17 = EORRdRr $r17, $r16, implicit-def $sreg
$r17r16 = LSLWNRd $r17r16, 4, implicit-def $sreg
- ; CHECK-NEXT: $r19 = MOVRdRr $r18
+ ; CHECK-NEXT: $r19 = MOV $r18
; CHECK-NEXT: $r18 = EORRdRr $r18, $r18, implicit-def $sreg
$r19r18 = LSLWNRd $r19r18, 8, implicit-def $sreg
- ; CHECK-NEXT: $r21 = MOVRdRr $r20
+ ; CHECK-NEXT: $r21 = MOV $r20
; CHECK-NEXT: $r21 = SWAPRd killed $r21
; CHECK-NEXT: $r21 = ANDIRdK $r21, 240, implicit-def dead $sreg
; CHECK-NEXT: $r20 = EORRdRr $r20, $r20, implicit-def $sreg
diff --git a/llvm/test/CodeGen/AVR/pseudo/LSRWNRd.mir b/llvm/test/CodeGen/AVR/pseudo/LSRWNRd.mir
index ada1f22c0a540..4d8e0fa179e33 100644
--- a/llvm/test/CodeGen/AVR/pseudo/LSRWNRd.mir
+++ b/llvm/test/CodeGen/AVR/pseudo/LSRWNRd.mir
@@ -24,11 +24,11 @@ body: |
; CHECK-NEXT: $r16 = EORRdRr $r16, $r17, implicit-def $sreg
$r17r16 = LSRWNRd $r17r16, 4, implicit-def $sreg
- ; CHECK-NEXT: $r18 = MOVRdRr $r19
+ ; CHECK-NEXT: $r18 = MOV $r19
; CHECK-NEXT: $r19 = EORRdRr $r19, $r19, implicit-def $sreg
$r19r18 = LSRWNRd $r19r18, 8, implicit-def $sreg
- ; CHECK-NEXT: $r20 = MOVRdRr $r21
+ ; CHECK-NEXT: $r20 = MOV $r21
; CHECK-NEXT: $r20 = SWAPRd killed $r20
; CHECK-NEXT: $r20 = ANDIRdK $r20, 15, implicit-def dead $sreg
; CHECK-NEXT: $r21 = EORRdRr $r21, $r21, implicit-def $sreg
diff --git a/llvm/test/CodeGen/AVR/pseudo/SEXT.mir b/llvm/test/CodeGen/AVR/pseudo/SEXT.mir
index 75360155b1e1c..9e97cb7b7cdbc 100644
--- a/llvm/test/CodeGen/AVR/pseudo/SEXT.mir
+++ b/llvm/test/CodeGen/AVR/pseudo/SEXT.mir
@@ -16,8 +16,8 @@ body: |
; CHECK-LABEL: test
- ; CHECK: $r14 = MOVRdRr $r31
- ; CHECK-NEXT: $r15 = MOVRdRr $r31
+ ; CHECK: $r14 = MOV $r31
+ ; CHECK-NEXT: $r15 = MOV $r31
; CHECK-NEXT: $r15 = ADDRdRr killed $r15, killed $r15, implicit-def $sreg
; CHECK-NEXT: $r15 = SBCRdRr killed $r15, killed $r15, implicit-def $sreg, implicit killed $sreg
diff --git a/llvm/test/CodeGen/AVR/pseudo/ZEXT.mir b/llvm/test/CodeGen/AVR/pseudo/ZEXT.mir
index 75360155b1e1c..9e97cb7b7cdbc 100644
--- a/llvm/test/CodeGen/AVR/pseudo/ZEXT.mir
+++ b/llvm/test/CodeGen/AVR/pseudo/ZEXT.mir
@@ -16,8 +16,8 @@ body: |
; CHECK-LABEL: test
- ; CHECK: $r14 = MOVRdRr $r31
- ; CHECK-NEXT: $r15 = MOVRdRr $r31
+ ; CHECK: $r14 = MOV $r31
+ ; CHECK-NEXT: $r15 = MOV $r31
; CHECK-NEXT: $r15 = ADDRdRr killed $r15, killed $r15, implicit-def $sreg
; CHECK-NEXT: $r15 = SBCRdRr killed $r15, killed $r15, implicit-def $sreg, implicit killed $sreg
More information about the llvm-commits
mailing list