[X86] Remove patterns for ADD/AND/OR/SUB/XOR/CMP with immediate 8 and optimize during MC lowering, NFCI

[skan]

Summary

This is follow-up of D150107.

In addition, the function X86::optimizeToFixedRegisterOrShortImmediateForm can be
shared with project bolt and eliminates the code in X86InstrRelaxTables.cpp.

[skan]

This change is straightforward to me. I tend to land it first to avoid more tests for ADD/AND/OR/SUB/XOR/CMP with i8 being added. The update in llvm/test/CodeGen/X86/avxvnni-combine.ll is due to the impact on machine schedule.
Opened a revision here for possible discussions.

llvm/lib/Target/X86/MCTargetDesc/X86EncodingOptimization.h

 class MCInstrDesc;
 namespace X86 {
 bool optimizeInstFromVEX3ToVEX2(MCInst &MI, const MCInstrDesc &Desc);
 bool optimizeShiftRotateWithImmediateOne(MCInst &MI);
 bool optimizeVPCMPWithImmediateOneOrSix(MCInst &MI);
 bool optimizeMOVSX(MCInst &MI);
 bool optimizeINCDEC(MCInst &MI, bool In64BitMode);
 bool optimizeMOV(MCInst &MI, bool In64BitMode);
-bool optimizeToFixedRegisterForm(MCInst &MI);
-bool optimizeToShortImmediateForm(MCInst &MI);
+bool optimizeToFixedRegisterOrShortImmediateForm(MCInst &MI);
 } // namespace X86
 } // namespace llvm
 #endif

llvm/lib/Target/X86/MCTargetDesc/X86EncodingOptimization.cpp

bool X86::optimizeMOV(MCInst &MI, bool In64BitMode) {
   MI.setOpcode(NewOpc);
   MI.addOperand(Saved);
   MI.addOperand(Seg);
   return true;
 }
 
 /// Simplify FOO $imm, %{al,ax,eax,rax} to FOO $imm, for instruction with
 /// a short fixed-register form.
-bool X86::optimizeToFixedRegisterForm(MCInst &MI) {
+static bool optimizeToFixedRegisterForm(MCInst &MI) {
   unsigned NewOpc;
   switch (MI.getOpcode()) {
   default:
     return false;
     FROM_TO(ADC8ri, ADC8i8)
     FROM_TO(ADC16ri, ADC16i16)
     FROM_TO(ADC32ri, ADC32i32)
     FROM_TO(ADC64ri32, ADC64i32)
static bool optimizeToFixedRegisterForm(MCInst &MI) {
   // If so, rewrite the instruction.
   MCOperand Saved = MI.getOperand(MI.getNumOperands() - 1);
   MI.clear();
   MI.setOpcode(NewOpc);
   MI.addOperand(Saved);
   return true;
 }
 
-bool X86::optimizeToShortImmediateForm(MCInst &MI) {
+static bool optimizeToShortImmediateForm(MCInst &MI) {
   unsigned NewOpc;
   switch (MI.getOpcode()) {
   default:
     return false;
     FROM_TO(ADC16mi, ADC16mi8)
     FROM_TO(ADC16ri, ADC16ri8)
     FROM_TO(ADC32mi, ADC32mi8)
     FROM_TO(ADC32ri, ADC32ri8)
     FROM_TO(ADC64mi32, ADC64mi8)
     FROM_TO(ADC64ri32, ADC64ri8)
     FROM_TO(SBB16mi, SBB16mi8)
     FROM_TO(SBB16ri, SBB16ri8)
     FROM_TO(SBB32mi, SBB32mi8)
     FROM_TO(SBB32ri, SBB32ri8)
     FROM_TO(SBB64mi32, SBB64mi8)
     FROM_TO(SBB64ri32, SBB64ri8)
+    FROM_TO(ADD16mi, ADD16mi8)
+    FROM_TO(ADD16ri, ADD16ri8)
+    FROM_TO(ADD32mi, ADD32mi8)
+    FROM_TO(ADD32ri, ADD32ri8)
+    FROM_TO(ADD64mi32, ADD64mi8)
+    FROM_TO(ADD64ri32, ADD64ri8)
+    FROM_TO(AND16mi, AND16mi8)
+    FROM_TO(AND16ri, AND16ri8)
+    FROM_TO(AND32mi, AND32mi8)
+    FROM_TO(AND32ri, AND32ri8)
+    FROM_TO(AND64mi32, AND64mi8)
+    FROM_TO(AND64ri32, AND64ri8)
+    FROM_TO(OR16mi, OR16mi8)
+    FROM_TO(OR16ri, OR16ri8)
+    FROM_TO(OR32mi, OR32mi8)
+    FROM_TO(OR32ri, OR32ri8)
+    FROM_TO(OR64mi32, OR64mi8)
+    FROM_TO(OR64ri32, OR64ri8)
+    FROM_TO(SUB16mi, SUB16mi8)
+    FROM_TO(SUB16ri, SUB16ri8)
+    FROM_TO(SUB32mi, SUB32mi8)
+    FROM_TO(SUB32ri, SUB32ri8)
+    FROM_TO(SUB64mi32, SUB64mi8)
+    FROM_TO(SUB64ri32, SUB64ri8)
+    FROM_TO(XOR16mi, XOR16mi8)
+    FROM_TO(XOR16ri, XOR16ri8)
+    FROM_TO(XOR32mi, XOR32mi8)
+    FROM_TO(XOR32ri, XOR32ri8)
+    FROM_TO(XOR64mi32, XOR64mi8)
+    FROM_TO(XOR64ri32, XOR64ri8)
+    FROM_TO(CMP16mi, CMP16mi8)
+    FROM_TO(CMP16ri, CMP16ri8)
+    FROM_TO(CMP32mi, CMP32mi8)
+    FROM_TO(CMP32ri, CMP32ri8)
+    FROM_TO(CMP64mi32, CMP64mi8)
+    FROM_TO(CMP64ri32, CMP64ri8)
   }
-  if (!isInt<8>(MI.getOperand(MI.getNumOperands() - 1).getImm()))
+  MCOperand &LastOp = MI.getOperand(MI.getNumOperands() - 1);
+  if (LastOp.isExpr()) {
+    const MCSymbolRefExpr *SRE = dyn_cast<MCSymbolRefExpr>(LastOp.getExpr());
+    if (!SRE || SRE->getKind() != MCSymbolRefExpr::VK_X86_ABS8)
+      return false;
+  } else if (LastOp.isImm()) {
+    if (!isInt<8>(LastOp.getImm()))
       return false;
+  }
   MI.setOpcode(NewOpc);
   return true;
 }
+
+bool X86::optimizeToFixedRegisterOrShortImmediateForm(MCInst &MI) {
+  // We may optimize twice here.
+  bool ShortImm = optimizeToShortImmediateForm(MI);
+  bool FixedReg = optimizeToFixedRegisterForm(MI);
+  return ShortImm || FixedReg;
+}

llvm/lib/Target/X86/X86CallFrameOptimization.cpp

X86CallFrameOptimization::classifyInstruction(
     MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
     const X86RegisterInfo &RegInfo, DenseSet<unsigned int> &UsedRegs) {
   if (MI == MBB.end())
     return Exit;
 
   // The instructions we actually care about are movs onto the stack or special
   // cases of constant-stores to stack
   switch (MI->getOpcode()) {
-    case X86::AND16mi8:
-    case X86::AND32mi8:
-    case X86::AND64mi8: {
+    case X86::AND16mi:
+    case X86::AND32mi:
+    case X86::AND64mi32: {
       const MachineOperand &ImmOp = MI->getOperand(X86::AddrNumOperands);
       return ImmOp.getImm() == 0 ? Convert : Exit;
     }
-    case X86::OR16mi8:
-    case X86::OR32mi8:
-    case X86::OR64mi8: {
+    case X86::OR16mi:
+    case X86::OR32mi:
+    case X86::OR64mi32: {
       const MachineOperand &ImmOp = MI->getOperand(X86::AddrNumOperands);
       return ImmOp.getImm() == -1 ? Convert : Exit;
     }
     case X86::MOV32mi:
     case X86::MOV32mr:
     case X86::MOV64mi32:
     case X86::MOV64mr:
       return Convert;
void X86CallFrameOptimization::adjustCallSequence(MachineFunction &MF,
   for (int Idx = (Context.ExpectedDist >> Log2SlotSize) - 1; Idx >= 0; --Idx) {
     MachineBasicBlock::iterator Store = *Context.ArgStoreVector[Idx];
     const MachineOperand &PushOp = Store->getOperand(X86::AddrNumOperands);
     MachineBasicBlock::iterator Push = nullptr;
     unsigned PushOpcode;
     switch (Store->getOpcode()) {
     default:
       llvm_unreachable("Unexpected Opcode!");
-    case X86::AND16mi8:
-    case X86::AND32mi8:
-    case X86::AND64mi8:
-    case X86::OR16mi8:
-    case X86::OR32mi8:
-    case X86::OR64mi8:
+    case X86::AND16mi:
+    case X86::AND32mi:
+    case X86::AND64mi32:
+    case X86::OR16mi:
+    case X86::OR32mi:
+    case X86::OR64mi32:
     case X86::MOV32mi:
     case X86::MOV64mi32:
       PushOpcode = Is64Bit ? X86::PUSH64i32 : X86::PUSHi32;
       // If the operand is a small (8-bit) immediate, we can use a
       // PUSH instruction with a shorter encoding.
       // Note that isImm() may fail even though this is a MOVmi, because
       // the operand can also be a symbol.
       if (PushOp.isImm()) {

llvm/lib/Target/X86/X86DynAllocaExpander.cpp

for (MachineInstr &MI : *MBB) {
         Offset = INT32_MAX;
       }
     }
 
     OutOffset[MBB] = Offset;
   }
 }
 
-static unsigned getSubOpcode(bool Is64Bit, int64_t Amount) {
+static unsigned getSubOpcode(bool Is64Bit) {
   if (Is64Bit)
-    return isInt<8>(Amount) ? X86::SUB64ri8 : X86::SUB64ri32;
-  return isInt<8>(Amount) ? X86::SUB32ri8 : X86::SUB32ri;
+    return X86::SUB64ri32;
+  return X86::SUB32ri;
 }
 
 void X86DynAllocaExpander::lower(MachineInstr *MI, Lowering L) {
   const DebugLoc &DL = MI->getDebugLoc();
   MachineBasicBlock *MBB = MI->getParent();
   MachineBasicBlock::iterator I = *MI;
 
   int64_t Amount = getDynAllocaAmount(MI, MRI);
case Sub:
     assert(Amount > 0);
     if (Amount == SlotSize) {
       // Use push to save size.
       unsigned RegA = Is64Bit ? X86::RAX : X86::EAX;
       BuildMI(*MBB, I, DL, TII->get(Is64Bit ? X86::PUSH64r : X86::PUSH32r))
           .addReg(RegA, RegState::Undef);
     } else {
       // Sub.
-      BuildMI(*MBB, I, DL,
-              TII->get(getSubOpcode(Is64BitAlloca, Amount)), StackPtr)
+      BuildMI(*MBB, I, DL, TII->get(getSubOpcode(Is64BitAlloca)), StackPtr)
           .addReg(StackPtr)
           .addImm(Amount);
     }
     break;
   case Probe:
     if (!NoStackArgProbe) {
       // The probe lowering expects the amount in RAX/EAX.
       unsigned RegA = Is64BitAlloca ? X86::RAX : X86::EAX;

llvm/lib/Target/X86/X86FastISel.cpp

return HasAVX512 ? X86::VUCOMISDZrr
            : HasSSE2 ? X86::UCOMISDrr
                      : 0;
   }
 }
 
 /// If we have a comparison with RHS as the RHS  of the comparison, return an
 /// opcode that works for the compare (e.g. CMP32ri) otherwise return 0.
 static unsigned X86ChooseCmpImmediateOpcode(EVT VT, const ConstantInt *RHSC) {
-  int64_t Val = RHSC->getSExtValue();
   switch (VT.getSimpleVT().SimpleTy) {
   // Otherwise, we can't fold the immediate into this comparison.
   default:
     return 0;
   case MVT::i8:
     return X86::CMP8ri;
   case MVT::i16:
-    if (isInt<8>(Val))
-      return X86::CMP16ri8;
     return X86::CMP16ri;
   case MVT::i32:
-    if (isInt<8>(Val))
-      return X86::CMP32ri8;
     return X86::CMP32ri;
   case MVT::i64:
-    if (isInt<8>(Val))
-      return X86::CMP64ri8;
     // 64-bit comparisons are only valid if the immediate fits in a 32-bit sext
     // field.
-    if (isInt<32>(Val))
-      return X86::CMP64ri32;
-    return 0;
+    return isInt<32>(RHSC->getSExtValue()) ? X86::CMP64ri32 : 0;
   }
 }
 
 bool X86FastISel::X86FastEmitCompare(const Value *Op0, const Value *Op1, EVT VT,
                                      const DebugLoc &CurMIMD) {
   Register Op0Reg = getRegForValue(Op0);
   if (Op0Reg == 0) return false;
 

llvm/lib/Target/X86/X86FixupLEAs.cpp

FixupLEAPass::postRAConvertToLEA(MachineBasicBlock &MBB,
   if (!MI.isConvertibleTo3Addr())
     return nullptr;
 
   switch (MI.getOpcode()) {
   default:
     // Only convert instructions that we've verified are safe.
     return nullptr;
   case X86::ADD64ri32:
-  case X86::ADD64ri8:
   case X86::ADD64ri32_DB:
-  case X86::ADD64ri8_DB:
   case X86::ADD32ri:
-  case X86::ADD32ri8:
   case X86::ADD32ri_DB:
-  case X86::ADD32ri8_DB:
     if (!MI.getOperand(2).isImm()) {
       // convertToThreeAddress will call getImm()
       // which requires isImm() to be true
       return nullptr;
     }
     break;
   case X86::SHL64ri:
   case X86::SHL32ri:
case X86::LEA64_32r:
     return X86::SUB32rr;
   case X86::LEA64r:
     return X86::SUB64rr;
   }
 }
 
 static inline unsigned getADDriFromLEA(unsigned LEAOpcode,
                                        const MachineOperand &Offset) {
-  bool IsInt8 = Offset.isImm() && isInt<8>(Offset.getImm());
   switch (LEAOpcode) {
   default:
     llvm_unreachable("Unexpected LEA instruction");
   case X86::LEA32r:
   case X86::LEA64_32r:
-    return IsInt8 ? X86::ADD32ri8 : X86::ADD32ri;
+    return X86::ADD32ri;
   case X86::LEA64r:
-    return IsInt8 ? X86::ADD64ri8 : X86::ADD64ri32;
+    return X86::ADD64ri32;
   }
 }
 
 static inline unsigned getINCDECFromLEA(unsigned LEAOpcode, bool IsINC) {
   switch (LEAOpcode) {
   default:
     llvm_unreachable("Unexpected LEA instruction");
   case X86::LEA32r:

llvm/lib/Target/X86/X86FrameLowering.cpp

return (MF.getTarget().Options.DisableFramePointerElim(MF) ||
           MFI.isFrameAddressTaken() || MFI.hasOpaqueSPAdjustment() ||
           MF.getInfo<X86MachineFunctionInfo>()->getForceFramePointer() ||
           MF.getInfo<X86MachineFunctionInfo>()->hasPreallocatedCall() ||
           MF.callsUnwindInit() || MF.hasEHFunclets() || MF.callsEHReturn() ||
           MFI.hasStackMap() || MFI.hasPatchPoint() ||
           (isWin64Prologue(MF) && MFI.hasCopyImplyingStackAdjustment()));
 }
 
-static unsigned getSUBriOpcode(bool IsLP64, int64_t Imm) {
-  if (IsLP64) {
-    if (isInt<8>(Imm))
-      return X86::SUB64ri8;
-    return X86::SUB64ri32;
-  } else {
-    if (isInt<8>(Imm))
-      return X86::SUB32ri8;
-    return X86::SUB32ri;
-  }
+static unsigned getSUBriOpcode(bool IsLP64) {
+  return IsLP64 ? X86::SUB64ri32 : X86::SUB32ri;
 }
 
-static unsigned getADDriOpcode(bool IsLP64, int64_t Imm) {
-  if (IsLP64) {
-    if (isInt<8>(Imm))
-      return X86::ADD64ri8;
-    return X86::ADD64ri32;
-  } else {
-    if (isInt<8>(Imm))
-      return X86::ADD32ri8;
-    return X86::ADD32ri;
-  }
+static unsigned getADDriOpcode(bool IsLP64) {
+  return IsLP64 ? X86::ADD64ri32 : X86::ADD32ri;
 }
 
 static unsigned getSUBrrOpcode(bool IsLP64) {
   return IsLP64 ? X86::SUB64rr : X86::SUB32rr;
 }
 
 static unsigned getADDrrOpcode(bool IsLP64) {
   return IsLP64 ? X86::ADD64rr : X86::ADD32rr;
 }
 
 static unsigned getANDriOpcode(bool IsLP64, int64_t Imm) {
-  if (IsLP64) {
-    if (isInt<8>(Imm))
-      return X86::AND64ri8;
-    return X86::AND64ri32;
-  }
-  if (isInt<8>(Imm))
-    return X86::AND32ri8;
-  return X86::AND32ri;
+  return IsLP64 ? X86::AND64ri32 : X86::AND32ri;
 }
 
 static unsigned getLEArOpcode(bool IsLP64) {
   return IsLP64 ? X86::LEA64r : X86::LEA32r;
 }
 
 static unsigned getMOVriOpcode(bool Use64BitReg, int64_t Imm) {
   if (Use64BitReg) {
MachineInstrBuilder X86FrameLowering::BuildStackAdjustment(
   if (UseLEA) {
     MI = addRegOffset(BuildMI(MBB, MBBI, DL,
                               TII.get(getLEArOpcode(Uses64BitFramePtr)),
                               StackPtr),
                       StackPtr, false, Offset);
   } else {
     bool IsSub = Offset < 0;
     uint64_t AbsOffset = IsSub ? -Offset : Offset;
-    const unsigned Opc = IsSub ? getSUBriOpcode(Uses64BitFramePtr, AbsOffset)
-                               : getADDriOpcode(Uses64BitFramePtr, AbsOffset);
+    const unsigned Opc = IsSub ? getSUBriOpcode(Uses64BitFramePtr)
+                               : getADDriOpcode(Uses64BitFramePtr);
     MI = BuildMI(MBB, MBBI, DL, TII.get(Opc), StackPtr)
              .addReg(StackPtr)
              .addImm(AbsOffset);
     MI->getOperand(3).setIsDead(); // The EFLAGS implicit def is dead.
   }
   return MI;
 }
 
/* TODO: Add support for the case where there are multiple CFI instructions
     ...
   */
   if (doMergeWithPrevious && PI != MBB.begin() && PI->isCFIInstruction())
     PI = std::prev(PI);
 
   unsigned Opc = PI->getOpcode();
   int Offset = 0;
 
-  if ((Opc == X86::ADD64ri32 || Opc == X86::ADD64ri8 ||
-       Opc == X86::ADD32ri || Opc == X86::ADD32ri8) &&
-      PI->getOperand(0).getReg() == StackPtr){
+  if ((Opc == X86::ADD64ri32 || Opc == X86::ADD32ri) &&
+      PI->getOperand(0).getReg() == StackPtr) {
     assert(PI->getOperand(1).getReg() == StackPtr);
     Offset = PI->getOperand(2).getImm();
   } else if ((Opc == X86::LEA32r || Opc == X86::LEA64_32r) &&
              PI->getOperand(0).getReg() == StackPtr &&
              PI->getOperand(1).getReg() == StackPtr &&
              PI->getOperand(2).getImm() == 1 &&
              PI->getOperand(3).getReg() == X86::NoRegister &&
              PI->getOperand(5).getReg() == X86::NoRegister) {
     // For LEAs we have: def = lea SP, FI, noreg, Offset, noreg.
     Offset = PI->getOperand(4).getImm();
-  } else if ((Opc == X86::SUB64ri32 || Opc == X86::SUB64ri8 ||
-              Opc == X86::SUB32ri || Opc == X86::SUB32ri8) &&
+  } else if ((Opc == X86::SUB64ri32 || Opc == X86::SUB32ri) &&
              PI->getOperand(0).getReg() == StackPtr) {
     assert(PI->getOperand(1).getReg() == StackPtr);
     Offset = -PI->getOperand(2).getImm();
   } else
     return 0;
 
   PI = MBB.erase(PI);
   if (PI != MBB.end() && PI->isCFIInstruction()) {
void X86FrameLowering::emitStackProbeInlineGenericLoop(
 
   BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::COPY), FinalStackProbed)
       .addReg(StackPtr)
       .setMIFlag(MachineInstr::FrameSetup);
 
   // save loop bound
   {
     const unsigned BoundOffset = alignDown(Offset, StackProbeSize);
-    const unsigned SUBOpc = getSUBriOpcode(Uses64BitFramePtr, BoundOffset);
+    const unsigned SUBOpc = getSUBriOpcode(Uses64BitFramePtr);
     BuildMI(MBB, MBBI, DL, TII.get(SUBOpc), FinalStackProbed)
         .addReg(FinalStackProbed)
         .addImm(BoundOffset)
         .setMIFlag(MachineInstr::FrameSetup);
 
     // while in the loop, use loop-invariant reg for CFI,
     // instead of the stack pointer, which changes during the loop
     if (!HasFP && NeedsDwarfCFI) {
if (Reg == StackPtr && EmitInlineStackProbe && MaxAlign >= StackProbeSize) {
         entryMBB->addSuccessor(headMBB);
         entryMBB->addSuccessor(&MBB);
       }
 
       // Loop entry block
 
       {
         const unsigned SUBOpc =
-            getSUBriOpcode(Uses64BitFramePtr, StackProbeSize);
+            getSUBriOpcode(Uses64BitFramePtr);
         BuildMI(headMBB, DL, TII.get(SUBOpc), StackPtr)
             .addReg(StackPtr)
             .addImm(StackProbeSize)
             .setMIFlag(MachineInstr::FrameSetup);
 
         BuildMI(headMBB, DL,
                 TII.get(Uses64BitFramePtr ? X86::CMP64rr : X86::CMP32rr))
             .addReg(StackPtr)
if (Reg == StackPtr && EmitInlineStackProbe && MaxAlign >= StackProbeSize) {
       {
         addRegOffset(BuildMI(bodyMBB, DL, TII.get(MovMIOpc))
                          .setMIFlag(MachineInstr::FrameSetup),
                      StackPtr, false, 0)
             .addImm(0)
             .setMIFlag(MachineInstr::FrameSetup);
 
         const unsigned SUBOpc =
-            getSUBriOpcode(Uses64BitFramePtr, StackProbeSize);
+            getSUBriOpcode(Uses64BitFramePtr);
         BuildMI(bodyMBB, DL, TII.get(SUBOpc), StackPtr)
             .addReg(StackPtr)
             .addImm(StackProbeSize)
             .setMIFlag(MachineInstr::FrameSetup);
 
         // cmp with stack pointer bound
         BuildMI(bodyMBB, DL,
                 TII.get(Uses64BitFramePtr ? X86::CMP64rr : X86::CMP32rr))
if (!IsFunclet) {
 
         BuildMI(MBB, MBBI, DL, TII.get(X86::LEA64r), FramePtr)
             .addUse(X86::RSP)
             .addImm(1)
             .addUse(X86::NoRegister)
             .addImm(8)
             .addUse(X86::NoRegister)
             .setMIFlag(MachineInstr::FrameSetup);
-        BuildMI(MBB, MBBI, DL, TII.get(X86::SUB64ri8), X86::RSP)
+        BuildMI(MBB, MBBI, DL, TII.get(X86::SUB64ri32), X86::RSP)
             .addUse(X86::RSP)
             .addImm(8)
             .setMIFlag(MachineInstr::FrameSetup);
       }
 
       if (!IsWin64Prologue && !IsFunclet) {
         // Update EBP with the new base value.
         if (!X86FI->hasSwiftAsyncContext())
void X86FrameLowering::emitEpilogue(MachineFunction &MF,
   while (MBBI != MBB.begin()) {
     MachineBasicBlock::iterator PI = std::prev(MBBI);
     unsigned Opc = PI->getOpcode();
 
     if (Opc != X86::DBG_VALUE && !PI->isTerminator()) {
       if ((Opc != X86::POP32r || !PI->getFlag(MachineInstr::FrameDestroy)) &&
           (Opc != X86::POP64r || !PI->getFlag(MachineInstr::FrameDestroy)) &&
           (Opc != X86::BTR64ri8 || !PI->getFlag(MachineInstr::FrameDestroy)) &&
-          (Opc != X86::ADD64ri8 || !PI->getFlag(MachineInstr::FrameDestroy)))
+          (Opc != X86::ADD64ri32 || !PI->getFlag(MachineInstr::FrameDestroy)))
         break;
       FirstCSPop = PI;
     }
 
     --MBBI;
   }
   if (ArgBaseReg.isValid()) {
     // Restore argument base pointer.
MachineBasicBlock::iterator X86FrameLowering::restoreWin32EHStackPointers(
 
   Register UsedReg;
   int EHRegOffset = getFrameIndexReference(MF, FI, UsedReg).getFixed();
   int EndOffset = -EHRegOffset - EHRegSize;
   FuncInfo.EHRegNodeEndOffset = EndOffset;
 
   if (UsedReg == FramePtr) {
     // ADD $offset, %ebp
-    unsigned ADDri = getADDriOpcode(false, EndOffset);
+    unsigned ADDri = getADDriOpcode(false);
     BuildMI(MBB, MBBI, DL, TII.get(ADDri), FramePtr)
         .addReg(FramePtr)
         .addImm(EndOffset)
         .setMIFlag(MachineInstr::FrameSetup)
         ->getOperand(3)
         .setIsDead();
     assert(EndOffset >= 0 &&
            "end of registration object above normal EBP position!");

llvm/lib/Target/X86/X86ISelDAGToDAG.cpp

auto SelectRegOpcode = [SelectOpcode](unsigned Opc) {
         return SelectOpcode(X86::OR64mr, X86::OR32mr, X86::OR16mr, X86::OR8mr);
       case X86ISD::XOR:
         return SelectOpcode(X86::XOR64mr, X86::XOR32mr, X86::XOR16mr,
                             X86::XOR8mr);
       default:
         llvm_unreachable("Invalid opcode!");
       }
     };
-    auto SelectImm8Opcode = [SelectOpcode](unsigned Opc) {
-      switch (Opc) {
-      case X86ISD::ADD:
-        return SelectOpcode(X86::ADD64mi8, X86::ADD32mi8, X86::ADD16mi8, 0);
-      case X86ISD::ADC:
-        return SelectOpcode(X86::ADC64mi8, X86::ADC32mi8, X86::ADC16mi8, 0);
-      case X86ISD::SUB:
-        return SelectOpcode(X86::SUB64mi8, X86::SUB32mi8, X86::SUB16mi8, 0);
-      case X86ISD::SBB:
-        return SelectOpcode(X86::SBB64mi8, X86::SBB32mi8, X86::SBB16mi8, 0);
-      case X86ISD::AND:
-        return SelectOpcode(X86::AND64mi8, X86::AND32mi8, X86::AND16mi8, 0);
-      case X86ISD::OR:
-        return SelectOpcode(X86::OR64mi8, X86::OR32mi8, X86::OR16mi8, 0);
-      case X86ISD::XOR:
-        return SelectOpcode(X86::XOR64mi8, X86::XOR32mi8, X86::XOR16mi8, 0);
-      default:
-        llvm_unreachable("Invalid opcode!");
-      }
-    };
     auto SelectImmOpcode = [SelectOpcode](unsigned Opc) {
       switch (Opc) {
       case X86ISD::ADD:
         return SelectOpcode(X86::ADD64mi32, X86::ADD32mi, X86::ADD16mi,
                             X86::ADD8mi);
       case X86ISD::ADC:
         return SelectOpcode(X86::ADC64mi32, X86::ADC32mi, X86::ADC16mi,
                             X86::ADC8mi);
if (auto *OperandC = dyn_cast<ConstantSDNode>(Operand)) {
           ((MemVT != MVT::i8 && !isInt<8>(OperandV) && isInt<8>(-OperandV)) ||
            (MemVT == MVT::i64 && !isInt<32>(OperandV) &&
             isInt<32>(-OperandV))) &&
           hasNoCarryFlagUses(StoredVal.getValue(1))) {
         OperandV = -OperandV;
         Opc = Opc == X86ISD::ADD ? X86ISD::SUB : X86ISD::ADD;
       }
 
-      // First try to fit this into an Imm8 operand. If it doesn't fit, then try
-      // the larger immediate operand.
-      if (MemVT != MVT::i8 && isInt<8>(OperandV)) {
-        Operand = CurDAG->getTargetConstant(OperandV, SDLoc(Node), MemVT);
-        NewOpc = SelectImm8Opcode(Opc);
-      } else if (MemVT != MVT::i64 || isInt<32>(OperandV)) {
+      if (MemVT != MVT::i64 || isInt<32>(OperandV)) {
         Operand = CurDAG->getTargetConstant(OperandV, SDLoc(Node), MemVT);
         NewOpc = SelectImmOpcode(Opc);
       }
     }
 
     if (Opc == X86ISD::ADC || Opc == X86ISD::SBB) {
       SDValue CopyTo =
           CurDAG->getCopyToReg(InputChain, SDLoc(Node), X86::EFLAGS,

llvm/lib/Target/X86/X86ISelLowering.cpp

case Intrinsic::swift_async_context_addr: {
       auto &MF = DAG.getMachineFunction();
       auto X86FI = MF.getInfo<X86MachineFunctionInfo>();
       if (Subtarget.is64Bit()) {
         MF.getFrameInfo().setFrameAddressIsTaken(true);
         X86FI->setHasSwiftAsyncContext(true);
         SDValue Chain = Op->getOperand(0);
         SDValue CopyRBP = DAG.getCopyFromReg(Chain, dl, X86::RBP, MVT::i64);
         SDValue Result =
-            SDValue(DAG.getMachineNode(X86::SUB64ri8, dl, MVT::i64, CopyRBP,
+            SDValue(DAG.getMachineNode(X86::SUB64ri32, dl, MVT::i64, CopyRBP,
                                        DAG.getTargetConstant(8, dl, MVT::i32)),
                     0);
         // Return { result, chain }.
         return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(), Result,
                            CopyRBP.getValue(1));
       } else {
         // 32-bit so no special extended frame, create or reuse an existing
         // stack slot.
X86TargetLowering::EmitLoweredSelect(MachineInstr &MI,
   createPHIsForCMOVsInSinkBB(MIItBegin, MIItEnd, ThisMBB, FalseMBB, SinkMBB);
 
   // Now remove the CMOV(s).
   ThisMBB->erase(MIItBegin, MIItEnd);
 
   return SinkMBB;
 }
 
-static unsigned getSUBriOpcode(bool IsLP64, int64_t Imm) {
-  if (IsLP64) {
-    if (isInt<8>(Imm))
-      return X86::SUB64ri8;
+static unsigned getSUBriOpcode(bool IsLP64) {
+  if (IsLP64)
     return X86::SUB64ri32;
-  } else {
-    if (isInt<8>(Imm))
-      return X86::SUB32ri8;
+  else
     return X86::SUB32ri;
-  }
-}
 
 MachineBasicBlock *
 X86TargetLowering::EmitLoweredProbedAlloca(MachineInstr &MI,
                                            MachineBasicBlock *MBB) const {
   MachineFunction *MF = MBB->getParent();
   const TargetInstrInfo *TII = Subtarget.getInstrInfo();
   const X86FrameLowering &TFI = *Subtarget.getFrameLowering();
   const DebugLoc &DL = MI.getDebugLoc();
X86TargetLowering::EmitLoweredProbedAlloca(MachineInstr &MI,
   //       |                                                       |
   // [free probe] -> [page alloc] -> [alloc probe] -> [tail alloc] + -> [dyn probe] -> [page alloc] -> [dyn probe] -> [tail alloc] +
   //                                                               |                                                               |
   //                                                               + <- ----------- <- ------------ <- ----------- <- ------------ +
   //
   // The property we want to enforce is to never have more than [page alloc] between two probes.
 
   const unsigned XORMIOpc =
-      TFI.Uses64BitFramePtr ? X86::XOR64mi8 : X86::XOR32mi8;
+      TFI.Uses64BitFramePtr ? X86::XOR64mi32 : X86::XOR32mi;
   addRegOffset(BuildMI(blockMBB, DL, TII->get(XORMIOpc)), physSPReg, false, 0)
       .addImm(0);
 
   BuildMI(blockMBB, DL,
-          TII->get(getSUBriOpcode(TFI.Uses64BitFramePtr, ProbeSize)), physSPReg)
+          TII->get(getSUBriOpcode(TFI.Uses64BitFramePtr)), physSPReg)
       .addReg(physSPReg)
       .addImm(ProbeSize);
 
 
   BuildMI(blockMBB, DL, TII->get(X86::JMP_1)).addMBB(testMBB);
   blockMBB->addSuccessor(testMBB);
 
   // Replace original instruction by the expected stack ptr

llvm/lib/Target/X86/X86InstrAVX512.td

let Predicates = [HasAVX512] in {
   defm : operation_gpr_mask_copy_lowering<VK4,  v4i1>;
   defm : operation_gpr_mask_copy_lowering<VK8,  v8i1>;
   defm : operation_gpr_mask_copy_lowering<VK16,  v16i1>;
   defm : operation_gpr_mask_copy_lowering<VK32,  v32i1>;
   defm : operation_gpr_mask_copy_lowering<VK64,  v64i1>;
 
   def : Pat<(insert_subvector (v16i1 immAllZerosV),
                               (v1i1 (scalar_to_vector GR8:$src)), (iPTR 0)),
-            (KMOVWkr (AND32ri8
+            (KMOVWkr (AND32ri
                       (INSERT_SUBREG (i32 (IMPLICIT_DEF)), GR8:$src, sub_8bit),
                       (i32 1)))>;
 }
 
 // Mask unary operation
 // - KNOT
 multiclass avx512_mask_unop<bits<8> opc, string OpcodeStr,
                             RegisterClass KRC, SDPatternOperator OpNode,

llvm/lib/Target/X86/X86InstrArithmetic.td

class BinOpRI8<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
                Format f, dag outlist, X86FoldableSchedWrite sched, list<dag> pattern>
   : ITy<opcode, f, typeinfo, outlist,
         (ins typeinfo.RegClass:$src1, typeinfo.Imm8Operand:$src2),
         mnemonic, "{$src2, $src1|$src1, $src2}", pattern>,
     Sched<[sched]> {
   let ImmT = Imm8; // Always 8-bit immediate.
 }
 
-// BinOpRI8_F - Binary instructions with inputs "reg, imm8", where the pattern
-// has EFLAGS as a result.
-class BinOpRI8_F<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
-                  SDPatternOperator opnode, Format f>
-  : BinOpRI8<opcode, mnemonic, typeinfo, f, (outs), WriteALU,
-             [(set EFLAGS,
-               (opnode typeinfo.RegClass:$src1, typeinfo.Imm8Operator:$src2))]>;
-
-// BinOpRI8_RF - Binary instructions with inputs "reg, imm8", where the pattern
-// has both a regclass and EFLAGS as a result.
-class BinOpRI8_RF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
-                  SDPatternOperator opnode, Format f>
-  : BinOpRI8<opcode, mnemonic, typeinfo, f, (outs typeinfo.RegClass:$dst), WriteALU,
-             [(set typeinfo.RegClass:$dst, EFLAGS,
-               (opnode typeinfo.RegClass:$src1, typeinfo.Imm8Operator:$src2))]>;
+// BinOpRI8_F - Binary instructions with inputs "reg, imm8".
+class BinOpRI8_F<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo, Format f>
+  : BinOpRI8<opcode, mnemonic, typeinfo, f, (outs), WriteALU, []>;
+
+// BinOpRI8_RF - Binary instructions with inputs "reg, imm8".
+class BinOpRI8_RF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo, Format f>
+  : BinOpRI8<opcode, mnemonic, typeinfo, f, (outs typeinfo.RegClass:$dst), WriteALU, []>;
 
 // BinOpRI8_RFF - Binary instructions with inputs "reg, imm8".
 class BinOpRI8_RFF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo, Format f>
   : BinOpRI8<opcode, mnemonic, typeinfo, f, (outs typeinfo.RegClass:$dst), WriteADC, []>;
 
 // BinOpMR - Binary instructions with inputs "[mem], reg".
 class BinOpMR<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
               list<dag> pattern>

 class BinOpMI8<string mnemonic, X86TypeInfo typeinfo,
                Format f, list<dag> pattern>
   : ITy<0x82, f, typeinfo,
         (outs), (ins typeinfo.MemOperand:$dst, typeinfo.Imm8Operand:$src),
         mnemonic, "{$src, $dst|$dst, $src}", pattern> {
   let ImmT = Imm8; // Always 8-bit immediate.
 }
 
-// BinOpMI8_RMW - Binary instructions with inputs "[mem], imm8", where the
-// pattern implicitly use EFLAGS.
-class BinOpMI8_RMW<string mnemonic, X86TypeInfo typeinfo,
-                   SDPatternOperator opnode, Format f>
-  : BinOpMI8<mnemonic, typeinfo, f,
-             [(store (opnode (load addr:$dst),
-                             typeinfo.Imm8Operator:$src), addr:$dst),
-              (implicit EFLAGS)]>,
-    Sched<[WriteALURMW]>;
+// BinOpMI8_RMW - Binary instructions with inputs "[mem], imm8".
+class BinOpMI8_RMW<string mnemonic, X86TypeInfo typeinfo, Format f>
+  : BinOpMI8<mnemonic, typeinfo, f, []>, Sched<[WriteALURMW]>;
 
 // BinOpMI8_RMW_FF - Binary instructions with inputs "[mem], imm8".
 class BinOpMI8_RMW_FF<string mnemonic, X86TypeInfo typeinfo, Format f>
   : BinOpMI8<mnemonic, typeinfo, f, []>, Sched<[WriteADCRMW]>;
 
-// BinOpMI8_F - Binary instructions with inputs "[mem], imm8", where the pattern
-// has EFLAGS as a result.
-class BinOpMI8_F<string mnemonic, X86TypeInfo typeinfo,
-                 SDPatternOperator opnode, Format f>
-  : BinOpMI8<mnemonic, typeinfo, f,
-             [(set EFLAGS, (opnode (typeinfo.LoadNode addr:$dst),
-                                    typeinfo.Imm8Operator:$src))]>,
-    Sched<[WriteALU.Folded]>;
+// BinOpMI8_F - Binary instructions with inputs "[mem], imm8"
+class BinOpMI8_F<string mnemonic, X86TypeInfo typeinfo, Format f>
+  : BinOpMI8<mnemonic, typeinfo, f, []>, Sched<[WriteALU.Folded]>;
 
 // BinOpAI - Binary instructions with input imm, that implicitly use A reg and
 // implicitly define Areg and EFLAGS.
 class BinOpAI<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
               Register areg, string operands, X86FoldableSchedWrite sched = WriteALU>
   : ITy<opcode, RawFrm, typeinfo,
         (outs), (ins typeinfo.ImmOperand:$src),
         mnemonic, operands, []>,
let Constraints = "$src1 = $dst" in {
       def NAME#32rr_REV : BinOpRR_Rev<BaseOpc2, mnemonic, Xi32>;
       def NAME#64rr_REV : BinOpRR_Rev<BaseOpc2, mnemonic, Xi64>;
 
       def NAME#8rm   : BinOpRM_RF<BaseOpc2, mnemonic, Xi8 , opnodeflag>;
       def NAME#16rm  : BinOpRM_RF<BaseOpc2, mnemonic, Xi16, opnodeflag>;
       def NAME#32rm  : BinOpRM_RF<BaseOpc2, mnemonic, Xi32, opnodeflag>;
       def NAME#64rm  : BinOpRM_RF<BaseOpc2, mnemonic, Xi64, opnodeflag>;
 
-      let isConvertibleToThreeAddress = ConvertibleToThreeAddress in {
+      let isConvertibleToThreeAddress = ConvertibleToThreeAddress, hasSideEffects= 0 in {
         def NAME#8ri   : BinOpRI_RF<0x80, mnemonic, Xi8 , opnodeflag, RegMRM>;
 
         // NOTE: These are order specific, we want the ri8 forms to be listed
         // first so that they are slightly preferred to the ri forms.
-        def NAME#16ri8 : BinOpRI8_RF<0x82, mnemonic, Xi16, opnodeflag, RegMRM>;
-        def NAME#32ri8 : BinOpRI8_RF<0x82, mnemonic, Xi32, opnodeflag, RegMRM>;
-        def NAME#64ri8 : BinOpRI8_RF<0x82, mnemonic, Xi64, opnodeflag, RegMRM>;
+        def NAME#16ri8 : BinOpRI8_RF<0x82, mnemonic, Xi16, RegMRM>;
+        def NAME#32ri8 : BinOpRI8_RF<0x82, mnemonic, Xi32, RegMRM>;
+        def NAME#64ri8 : BinOpRI8_RF<0x82, mnemonic, Xi64, RegMRM>;
 
         def NAME#16ri  : BinOpRI_RF<0x80, mnemonic, Xi16, opnodeflag, RegMRM>;
         def NAME#32ri  : BinOpRI_RF<0x80, mnemonic, Xi32, opnodeflag, RegMRM>;
         def NAME#64ri32: BinOpRI_RF<0x80, mnemonic, Xi64, opnodeflag, RegMRM>;
       }
     } // Constraints = "$src1 = $dst"
 
-    let mayLoad = 1, mayStore = 1 in {
+    let mayLoad = 1, mayStore = 1, hasSideEffects = 0 in {
       def NAME#8mr    : BinOpMR_RMW<BaseOpc, mnemonic, Xi8 , opnode>;
       def NAME#16mr   : BinOpMR_RMW<BaseOpc, mnemonic, Xi16, opnode>;
       def NAME#32mr   : BinOpMR_RMW<BaseOpc, mnemonic, Xi32, opnode>;
       def NAME#64mr   : BinOpMR_RMW<BaseOpc, mnemonic, Xi64, opnode>;
-    }
 
       // NOTE: These are order specific, we want the mi8 forms to be listed
       // first so that they are slightly preferred to the mi forms.
-    def NAME#16mi8  : BinOpMI8_RMW<mnemonic, Xi16, opnode, MemMRM>;
-    def NAME#32mi8  : BinOpMI8_RMW<mnemonic, Xi32, opnode, MemMRM>;
+      def NAME#16mi8  : BinOpMI8_RMW<mnemonic, Xi16, MemMRM>;
+      def NAME#32mi8  : BinOpMI8_RMW<mnemonic, Xi32, MemMRM>;
       let Predicates = [In64BitMode] in
-    def NAME#64mi8  : BinOpMI8_RMW<mnemonic, Xi64, opnode, MemMRM>;
+      def NAME#64mi8  : BinOpMI8_RMW<mnemonic, Xi64, MemMRM>;
 
       def NAME#8mi    : BinOpMI_RMW<0x80, mnemonic, Xi8 , opnode, MemMRM>;
       def NAME#16mi   : BinOpMI_RMW<0x80, mnemonic, Xi16, opnode, MemMRM>;
       def NAME#32mi   : BinOpMI_RMW<0x80, mnemonic, Xi32, opnode, MemMRM>;
       let Predicates = [In64BitMode] in
       def NAME#64mi32 : BinOpMI_RMW<0x80, mnemonic, Xi64, opnode, MemMRM>;
+    }
 
     // These are for the disassembler since 0x82 opcode behaves like 0x80, but
     // not in 64-bit mode.
     let Predicates = [Not64BitMode], isCodeGenOnly = 1, ForceDisassemble = 1,
         hasSideEffects = 0 in {
       let Constraints = "$src1 = $dst" in
-        def NAME#8ri8 : BinOpRI8_RF<0x82, mnemonic, Xi8, null_frag, RegMRM>;
+        def NAME#8ri8 : BinOpRI8_RF<0x82, mnemonic, Xi8, RegMRM>;
       let mayLoad = 1, mayStore = 1 in
-        def NAME#8mi8 : BinOpMI8_RMW<mnemonic, Xi8, null_frag, MemMRM>;
+        def NAME#8mi8 : BinOpMI8_RMW<mnemonic, Xi8, MemMRM>;
     }
   } // Defs = [EFLAGS]
 
   def NAME#8i8   : BinOpAI<BaseOpc4, mnemonic, Xi8 , AL,
                            "{$src, %al|al, $src}">;
   def NAME#16i16 : BinOpAI<BaseOpc4, mnemonic, Xi16, AX,
                            "{$src, %ax|ax, $src}">;
   def NAME#32i32 : BinOpAI<BaseOpc4, mnemonic, Xi32, EAX,
let Constraints = "$src1 = $dst" in {
 
       def NAME#8rm   : BinOpRM_RFF<BaseOpc2, mnemonic, Xi8 , opnode>;
       def NAME#16rm  : BinOpRM_RFF<BaseOpc2, mnemonic, Xi16, opnode>;
       def NAME#32rm  : BinOpRM_RFF<BaseOpc2, mnemonic, Xi32, opnode>;
       def NAME#64rm  : BinOpRM_RFF<BaseOpc2, mnemonic, Xi64, opnode>;
 
       def NAME#8ri   : BinOpRI_RFF<0x80, mnemonic, Xi8 , opnode, RegMRM>;
 
-      let isConvertibleToThreeAddress = ConvertibleToThreeAddress in {
+      let isConvertibleToThreeAddress = ConvertibleToThreeAddress, hasSideEffects = 0 in {
         // NOTE: These are order specific, we want the ri8 forms to be listed
         // first so that they are slightly preferred to the ri forms.
         def NAME#16ri8 : BinOpRI8_RFF<0x82, mnemonic, Xi16, RegMRM>;
         def NAME#32ri8 : BinOpRI8_RFF<0x82, mnemonic, Xi32, RegMRM>;
         def NAME#64ri8 : BinOpRI8_RFF<0x82, mnemonic, Xi64, RegMRM>;
 
         def NAME#16ri  : BinOpRI_RFF<0x80, mnemonic, Xi16, opnode, RegMRM>;
         def NAME#32ri  : BinOpRI_RFF<0x80, mnemonic, Xi32, opnode, RegMRM>;
         def NAME#64ri32: BinOpRI_RFF<0x80, mnemonic, Xi64, opnode, RegMRM>;
       }
     } // Constraints = "$src1 = $dst"
 
     def NAME#8mr    : BinOpMR_RMW_FF<BaseOpc, mnemonic, Xi8 , opnode>;
     def NAME#16mr   : BinOpMR_RMW_FF<BaseOpc, mnemonic, Xi16, opnode>;
     def NAME#32mr   : BinOpMR_RMW_FF<BaseOpc, mnemonic, Xi32, opnode>;
     def NAME#64mr   : BinOpMR_RMW_FF<BaseOpc, mnemonic, Xi64, opnode>;
 
     // NOTE: These are order specific, we want the mi8 forms to be listed
     // first so that they are slightly preferred to the mi forms.
+    let mayLoad = 1, mayStore = 1, hasSideEffects = 0 in {
     def NAME#16mi8  : BinOpMI8_RMW_FF<mnemonic, Xi16, MemMRM>;
     def NAME#32mi8  : BinOpMI8_RMW_FF<mnemonic, Xi32, MemMRM>;
     let Predicates = [In64BitMode] in
     def NAME#64mi8  : BinOpMI8_RMW_FF<mnemonic, Xi64, MemMRM>;
 
     def NAME#8mi    : BinOpMI_RMW_FF<0x80, mnemonic, Xi8 , opnode, MemMRM>;
     def NAME#16mi   : BinOpMI_RMW_FF<0x80, mnemonic, Xi16, opnode, MemMRM>;
     def NAME#32mi   : BinOpMI_RMW_FF<0x80, mnemonic, Xi32, opnode, MemMRM>;
     let Predicates = [In64BitMode] in
     def NAME#64mi32 : BinOpMI_RMW_FF<0x80, mnemonic, Xi64, opnode, MemMRM>;
+    }
 
     // These are for the disassembler since 0x82 opcode behaves like 0x80, but
     // not in 64-bit mode.
     let Predicates = [Not64BitMode], isCodeGenOnly = 1, ForceDisassemble = 1,
         hasSideEffects = 0 in {
       let Constraints = "$src1 = $dst" in
         def NAME#8ri8 : BinOpRI8_RFF<0x82, mnemonic, Xi8, RegMRM>;
       let mayLoad = 1, mayStore = 1 in
let Defs = [EFLAGS] in {
 
     def NAME#8rm   : BinOpRM_F<BaseOpc2, mnemonic, Xi8 , opnode>;
     def NAME#16rm  : BinOpRM_F<BaseOpc2, mnemonic, Xi16, opnode>;
     def NAME#32rm  : BinOpRM_F<BaseOpc2, mnemonic, Xi32, opnode>;
     def NAME#64rm  : BinOpRM_F<BaseOpc2, mnemonic, Xi64, opnode>;
 
     def NAME#8ri   : BinOpRI_F<0x80, mnemonic, Xi8 , opnode, RegMRM>;
 
-    let isConvertibleToThreeAddress = ConvertibleToThreeAddress in {
+    let isConvertibleToThreeAddress = ConvertibleToThreeAddress, hasSideEffects = 0 in {
       // NOTE: These are order specific, we want the ri8 forms to be listed
       // first so that they are slightly preferred to the ri forms.
-      def NAME#16ri8 : BinOpRI8_F<0x82, mnemonic, Xi16, opnode, RegMRM>;
-      def NAME#32ri8 : BinOpRI8_F<0x82, mnemonic, Xi32, opnode, RegMRM>;
-      def NAME#64ri8 : BinOpRI8_F<0x82, mnemonic, Xi64, opnode, RegMRM>;
+      def NAME#16ri8 : BinOpRI8_F<0x82, mnemonic, Xi16, RegMRM>;
+      def NAME#32ri8 : BinOpRI8_F<0x82, mnemonic, Xi32, RegMRM>;
+      def NAME#64ri8 : BinOpRI8_F<0x82, mnemonic, Xi64, RegMRM>;
 
       def NAME#16ri  : BinOpRI_F<0x80, mnemonic, Xi16, opnode, RegMRM>;
       def NAME#32ri  : BinOpRI_F<0x80, mnemonic, Xi32, opnode, RegMRM>;
       def NAME#64ri32: BinOpRI_F<0x80, mnemonic, Xi64, opnode, RegMRM>;
     }
 
     def NAME#8mr    : BinOpMR_F<BaseOpc, mnemonic, Xi8 , opnode>;
     def NAME#16mr   : BinOpMR_F<BaseOpc, mnemonic, Xi16, opnode>;
     def NAME#32mr   : BinOpMR_F<BaseOpc, mnemonic, Xi32, opnode>;
     def NAME#64mr   : BinOpMR_F<BaseOpc, mnemonic, Xi64, opnode>;
 
     // NOTE: These are order specific, we want the mi8 forms to be listed
     // first so that they are slightly preferred to the mi forms.
-    def NAME#16mi8  : BinOpMI8_F<mnemonic, Xi16, opnode, MemMRM>;
-    def NAME#32mi8  : BinOpMI8_F<mnemonic, Xi32, opnode, MemMRM>;
+    let mayLoad = 1, hasSideEffects = 0 in {
+      def NAME#16mi8  : BinOpMI8_F<mnemonic, Xi16, MemMRM>;
+      def NAME#32mi8  : BinOpMI8_F<mnemonic, Xi32, MemMRM>;
       let Predicates = [In64BitMode] in
-    def NAME#64mi8  : BinOpMI8_F<mnemonic, Xi64, opnode, MemMRM>;
+      def NAME#64mi8  : BinOpMI8_F<mnemonic, Xi64, MemMRM>;
 
       def NAME#8mi    : BinOpMI_F<0x80, mnemonic, Xi8 , opnode, MemMRM>;
       def NAME#16mi   : BinOpMI_F<0x80, mnemonic, Xi16, opnode, MemMRM>;
       def NAME#32mi   : BinOpMI_F<0x80, mnemonic, Xi32, opnode, MemMRM>;
       let Predicates = [In64BitMode] in
       def NAME#64mi32 : BinOpMI_F<0x80, mnemonic, Xi64, opnode, MemMRM>;
+    }
 
     // These are for the disassembler since 0x82 opcode behaves like 0x80, but
     // not in 64-bit mode.
     let Predicates = [Not64BitMode], isCodeGenOnly = 1, ForceDisassemble = 1,
         hasSideEffects = 0 in {
-      def NAME#8ri8 : BinOpRI8_F<0x82, mnemonic, Xi8, null_frag, RegMRM>;
+      def NAME#8ri8 : BinOpRI8_F<0x82, mnemonic, Xi8, RegMRM>;
       let mayLoad = 1 in
-        def NAME#8mi8 : BinOpMI8_F<mnemonic, Xi8, null_frag, MemMRM>;
+        def NAME#8mi8 : BinOpMI8_F<mnemonic, Xi8, MemMRM>;
     }
   } // Defs = [EFLAGS]
 
   def NAME#8i8   : BinOpAI_F<BaseOpc4, mnemonic, Xi8 , AL,
                              "{$src, %al|al, $src}">;
   def NAME#16i16 : BinOpAI_F<BaseOpc4, mnemonic, Xi16, AX,
                              "{$src, %ax|ax, $src}">;
   def NAME#32i32 : BinOpAI_F<BaseOpc4, mnemonic, Xi32, EAX,

 def : Pat<(store (X86adc_flag GR64:$src, (loadi64 addr:$dst), EFLAGS),
                  addr:$dst),
           (ADC64mr addr:$dst, GR64:$src)>;
 
 // Patterns for basic arithmetic ops with relocImm for the immediate field.
 multiclass ArithBinOp_RF_relocImm_Pats<SDNode OpNodeFlag, SDNode OpNode> {
   def : Pat<(OpNodeFlag GR8:$src1, relocImm8_su:$src2),
             (!cast<Instruction>(NAME#"8ri") GR8:$src1, relocImm8_su:$src2)>;
-  def : Pat<(OpNodeFlag GR16:$src1, i16relocImmSExt8_su:$src2),
-            (!cast<Instruction>(NAME#"16ri8") GR16:$src1, i16relocImmSExt8_su:$src2)>;
   def : Pat<(OpNodeFlag GR16:$src1, relocImm16_su:$src2),
             (!cast<Instruction>(NAME#"16ri") GR16:$src1, relocImm16_su:$src2)>;
-  def : Pat<(OpNodeFlag GR32:$src1, i32relocImmSExt8_su:$src2),
-            (!cast<Instruction>(NAME#"32ri8") GR32:$src1, i32relocImmSExt8_su:$src2)>;
   def : Pat<(OpNodeFlag GR32:$src1, relocImm32_su:$src2),
             (!cast<Instruction>(NAME#"32ri") GR32:$src1, relocImm32_su:$src2)>;
-  def : Pat<(OpNodeFlag GR64:$src1, i64relocImmSExt8_su:$src2),
-            (!cast<Instruction>(NAME#"64ri8") GR64:$src1, i64relocImmSExt8_su:$src2)>;
   def : Pat<(OpNodeFlag GR64:$src1, i64relocImmSExt32_su:$src2),
             (!cast<Instruction>(NAME#"64ri32") GR64:$src1, i64relocImmSExt32_su:$src2)>;
 
   def : Pat<(store (OpNode (load addr:$dst), relocImm8_su:$src), addr:$dst),
             (!cast<Instruction>(NAME#"8mi") addr:$dst, relocImm8_su:$src)>;
-  def : Pat<(store (OpNode (load addr:$dst), i16relocImmSExt8_su:$src), addr:$dst),
-            (!cast<Instruction>(NAME#"16mi8") addr:$dst, i16relocImmSExt8_su:$src)>;
   def : Pat<(store (OpNode (load addr:$dst), relocImm16_su:$src), addr:$dst),
             (!cast<Instruction>(NAME#"16mi") addr:$dst, relocImm16_su:$src)>;
-  def : Pat<(store (OpNode (load addr:$dst), i32relocImmSExt8_su:$src), addr:$dst),
-            (!cast<Instruction>(NAME#"32mi8") addr:$dst, i32relocImmSExt8_su:$src)>;
   def : Pat<(store (OpNode (load addr:$dst), relocImm32_su:$src), addr:$dst),
             (!cast<Instruction>(NAME#"32mi") addr:$dst, relocImm32_su:$src)>;
-  def : Pat<(store (OpNode (load addr:$dst), i64relocImmSExt8_su:$src), addr:$dst),
-            (!cast<Instruction>(NAME#"64mi8") addr:$dst, i64relocImmSExt8_su:$src)>;
   def : Pat<(store (OpNode (load addr:$dst), i64relocImmSExt32_su:$src), addr:$dst),
             (!cast<Instruction>(NAME#"64mi32") addr:$dst, i64relocImmSExt32_su:$src)>;
 }
 
 multiclass ArithBinOp_RFF_relocImm_Pats<SDNode OpNodeFlag> {
   def : Pat<(OpNodeFlag GR8:$src1, relocImm8_su:$src2, EFLAGS),
             (!cast<Instruction>(NAME#"8ri") GR8:$src1, relocImm8_su:$src2)>;
-  def : Pat<(OpNodeFlag GR16:$src1, i16relocImmSExt8_su:$src2, EFLAGS),
-            (!cast<Instruction>(NAME#"16ri8") GR16:$src1, i16relocImmSExt8_su:$src2)>;
   def : Pat<(OpNodeFlag GR16:$src1, relocImm16_su:$src2, EFLAGS),
             (!cast<Instruction>(NAME#"16ri") GR16:$src1, relocImm16_su:$src2)>;
-  def : Pat<(OpNodeFlag GR32:$src1, i32relocImmSExt8_su:$src2, EFLAGS),
-            (!cast<Instruction>(NAME#"32ri8") GR32:$src1, i32relocImmSExt8_su:$src2)>;
   def : Pat<(OpNodeFlag GR32:$src1, relocImm32_su:$src2, EFLAGS),
             (!cast<Instruction>(NAME#"32ri") GR32:$src1, relocImm32_su:$src2)>;
-  def : Pat<(OpNodeFlag GR64:$src1, i64relocImmSExt8_su:$src2, EFLAGS),
-            (!cast<Instruction>(NAME#"64ri8") GR64:$src1, i64relocImmSExt8_su:$src2)>;
   def : Pat<(OpNodeFlag GR64:$src1, i64relocImmSExt32_su:$src2, EFLAGS),
             (!cast<Instruction>(NAME#"64ri32") GR64:$src1, i64relocImmSExt32_su:$src2)>;
 
   def : Pat<(store (OpNodeFlag (load addr:$dst), relocImm8_su:$src, EFLAGS), addr:$dst),
             (!cast<Instruction>(NAME#"8mi") addr:$dst, relocImm8_su:$src)>;
-  def : Pat<(store (OpNodeFlag (load addr:$dst), i16relocImmSExt8_su:$src, EFLAGS), addr:$dst),
-            (!cast<Instruction>(NAME#"16mi8") addr:$dst, i16relocImmSExt8_su:$src)>;
   def : Pat<(store (OpNodeFlag (load addr:$dst), relocImm16_su:$src, EFLAGS), addr:$dst),
             (!cast<Instruction>(NAME#"16mi") addr:$dst, relocImm16_su:$src)>;
-  def : Pat<(store (OpNodeFlag (load addr:$dst), i32relocImmSExt8_su:$src, EFLAGS), addr:$dst),
-            (!cast<Instruction>(NAME#"32mi8") addr:$dst, i32relocImmSExt8_su:$src)>;
   def : Pat<(store (OpNodeFlag (load addr:$dst), relocImm32_su:$src, EFLAGS), addr:$dst),
             (!cast<Instruction>(NAME#"32mi") addr:$dst, relocImm32_su:$src)>;
-  def : Pat<(store (OpNodeFlag (load addr:$dst), i64relocImmSExt8_su:$src, EFLAGS), addr:$dst),
-            (!cast<Instruction>(NAME#"64mi8") addr:$dst, i64relocImmSExt8_su:$src)>;
   def : Pat<(store (OpNodeFlag (load addr:$dst), i64relocImmSExt32_su:$src, EFLAGS), addr:$dst),
             (!cast<Instruction>(NAME#"64mi32") addr:$dst, i64relocImmSExt32_su:$src)>;
 }
 
 multiclass ArithBinOp_F_relocImm_Pats<SDNode OpNodeFlag> {
   def : Pat<(OpNodeFlag GR8:$src1, relocImm8_su:$src2),
             (!cast<Instruction>(NAME#"8ri") GR8:$src1, relocImm8_su:$src2)>;
-  def : Pat<(OpNodeFlag GR16:$src1, i16relocImmSExt8_su:$src2),
-            (!cast<Instruction>(NAME#"16ri8") GR16:$src1, i16relocImmSExt8_su:$src2)>;
   def : Pat<(OpNodeFlag GR16:$src1, relocImm16_su:$src2),
             (!cast<Instruction>(NAME#"16ri") GR16:$src1, relocImm16_su:$src2)>;
-  def : Pat<(OpNodeFlag GR32:$src1, i32relocImmSExt8_su:$src2),
-            (!cast<Instruction>(NAME#"32ri8") GR32:$src1, i32relocImmSExt8_su:$src2)>;
   def : Pat<(OpNodeFlag GR32:$src1, relocImm32_su:$src2),
             (!cast<Instruction>(NAME#"32ri") GR32:$src1, relocImm32_su:$src2)>;
-  def : Pat<(OpNodeFlag GR64:$src1, i64relocImmSExt8_su:$src2),
-            (!cast<Instruction>(NAME#"64ri8") GR64:$src1, i64relocImmSExt8_su:$src2)>;
   def : Pat<(OpNodeFlag GR64:$src1, i64relocImmSExt32_su:$src2),
             (!cast<Instruction>(NAME#"64ri32") GR64:$src1, i64relocImmSExt32_su:$src2)>;
 
   def : Pat<(OpNodeFlag (loadi8 addr:$src1), relocImm8_su:$src2),
             (!cast<Instruction>(NAME#"8mi") addr:$src1, relocImm8_su:$src2)>;
-  def : Pat<(OpNodeFlag (loadi16 addr:$src1), i16relocImmSExt8_su:$src2),
-            (!cast<Instruction>(NAME#"16mi8") addr:$src1, i16relocImmSExt8_su:$src2)>;
   def : Pat<(OpNodeFlag (loadi16 addr:$src1), relocImm16_su:$src2),
             (!cast<Instruction>(NAME#"16mi") addr:$src1, relocImm16_su:$src2)>;
-  def : Pat<(OpNodeFlag (loadi32 addr:$src1), i32relocImmSExt8_su:$src2),
-            (!cast<Instruction>(NAME#"32mi8") addr:$src1, i32relocImmSExt8_su:$src2)>;
   def : Pat<(OpNodeFlag (loadi32 addr:$src1), relocImm32_su:$src2),
             (!cast<Instruction>(NAME#"32mi") addr:$src1, relocImm32_su:$src2)>;
-  def : Pat<(OpNodeFlag (loadi64 addr:$src1), i64relocImmSExt8_su:$src2),
-            (!cast<Instruction>(NAME#"64mi8") addr:$src1, i64relocImmSExt8_su:$src2)>;
   def : Pat<(OpNodeFlag (loadi64 addr:$src1), i64relocImmSExt32_su:$src2),
             (!cast<Instruction>(NAME#"64mi32") addr:$src1, i64relocImmSExt32_su:$src2)>;
 }
 
 defm AND : ArithBinOp_RF_relocImm_Pats<X86and_flag, and>;
 defm OR  : ArithBinOp_RF_relocImm_Pats<X86or_flag, or>;
 defm XOR : ArithBinOp_RF_relocImm_Pats<X86xor_flag, xor>;
 defm ADD : ArithBinOp_RF_relocImm_Pats<X86add_flag, add>;

llvm/lib/Target/X86/X86InstrCompiler.td

 //===----------------------------------------------------------------------===//
 // DAG Pattern Matching Rules
 //===----------------------------------------------------------------------===//
 
 // Use AND/OR to store 0/-1 in memory when optimizing for minsize. This saves
 // binary size compared to a regular MOV, but it introduces an unnecessary
 // load, so is not suitable for regular or optsize functions.
 let Predicates = [OptForMinSize] in {
-def : Pat<(simple_store (i16 0), addr:$dst), (AND16mi8 addr:$dst, 0)>;
-def : Pat<(simple_store (i32 0), addr:$dst), (AND32mi8 addr:$dst, 0)>;
-def : Pat<(simple_store (i64 0), addr:$dst), (AND64mi8 addr:$dst, 0)>;
-def : Pat<(simple_store (i16 -1), addr:$dst), (OR16mi8 addr:$dst, -1)>;
-def : Pat<(simple_store (i32 -1), addr:$dst), (OR32mi8 addr:$dst, -1)>;
-def : Pat<(simple_store (i64 -1), addr:$dst), (OR64mi8 addr:$dst, -1)>;
+def : Pat<(simple_store (i16 0), addr:$dst), (AND16mi addr:$dst, 0)>;
+def : Pat<(simple_store (i32 0), addr:$dst), (AND32mi addr:$dst, 0)>;
+def : Pat<(simple_store (i64 0), addr:$dst), (AND64mi32 addr:$dst, 0)>;
+def : Pat<(simple_store (i16 -1), addr:$dst), (OR16mi addr:$dst, -1)>;
+def : Pat<(simple_store (i32 -1), addr:$dst), (OR32mi addr:$dst, -1)>;
+def : Pat<(simple_store (i64 -1), addr:$dst), (OR64mi32 addr:$dst, -1)>;
 }
 
 // In kernel code model, we can get the address of a label
 // into a register with 'movq'.  FIXME: This is a hack, the 'imm' predicate of
 // the MOV64ri32 should accept these.
 def : Pat<(i64 (X86Wrapper tconstpool  :$dst)),
           (MOV64ri32 tconstpool  :$dst)>, Requires<[KernelCode]>;
 def : Pat<(i64 (X86Wrapper tjumptable  :$dst)),

 def ADD32rr_DB  : I<0, Pseudo, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
                     "", // orl/addl REG, REG
                     [(set GR32:$dst, (or_is_add GR32:$src1, GR32:$src2))]>;
 def ADD64rr_DB  : I<0, Pseudo, (outs GR64:$dst), (ins GR64:$src1, GR64:$src2),
                     "", // orq/addq REG, REG
                     [(set GR64:$dst, (or_is_add GR64:$src1, GR64:$src2))]>;
 } // isCommutable
 
-// NOTE: These are order specific, we want the ri8 forms to be listed
-// first so that they are slightly preferred to the ri forms.
-
 def ADD8ri_DB :   I<0, Pseudo,
                     (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
                     "", // orb/addb REG, imm8
                     [(set GR8:$dst, (or_is_add GR8:$src1, imm:$src2))]>;
-def ADD16ri8_DB : I<0, Pseudo,
-                    (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
-                    "", // orw/addw REG, imm8
-                    [(set GR16:$dst,(or_is_add GR16:$src1,i16immSExt8:$src2))]>;
 def ADD16ri_DB  : I<0, Pseudo, (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
                     "", // orw/addw REG, imm
                     [(set GR16:$dst, (or_is_add GR16:$src1, imm:$src2))]>;
-
-def ADD32ri8_DB : I<0, Pseudo,
-                    (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
-                    "", // orl/addl REG, imm8
-                    [(set GR32:$dst,(or_is_add GR32:$src1,i32immSExt8:$src2))]>;
 def ADD32ri_DB  : I<0, Pseudo, (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
                     "", // orl/addl REG, imm
                     [(set GR32:$dst, (or_is_add GR32:$src1, imm:$src2))]>;
-
-
-def ADD64ri8_DB : I<0, Pseudo,
-                    (outs GR64:$dst), (ins GR64:$src1, i64i8imm:$src2),
-                    "", // orq/addq REG, imm8
-                    [(set GR64:$dst, (or_is_add GR64:$src1,
-                                                i64immSExt8:$src2))]>;
 def ADD64ri32_DB : I<0, Pseudo,
                      (outs GR64:$dst), (ins GR64:$src1, i64i32imm:$src2),
                      "", // orq/addq REG, imm
                      [(set GR64:$dst, (or_is_add GR64:$src1,
                                                  i64immSExt32:$src2))]>;
 }
 } // AddedComplexity, SchedRW
 

 
 //===----------------------------------------------------------------------===//
 // Some peepholes
 //===----------------------------------------------------------------------===//
 
 // Odd encoding trick: -128 fits into an 8-bit immediate field while
 // +128 doesn't, so in this special case use a sub instead of an add.
 def : Pat<(add GR16:$src1, 128),
-          (SUB16ri8 GR16:$src1, -128)>;
+          (SUB16ri GR16:$src1, -128)>;
 def : Pat<(store (add (loadi16 addr:$dst), 128), addr:$dst),
-          (SUB16mi8 addr:$dst, -128)>;
+          (SUB16mi addr:$dst, -128)>;
 
 def : Pat<(add GR32:$src1, 128),
-          (SUB32ri8 GR32:$src1, -128)>;
+          (SUB32ri GR32:$src1, -128)>;
 def : Pat<(store (add (loadi32 addr:$dst), 128), addr:$dst),
-          (SUB32mi8 addr:$dst, -128)>;
+          (SUB32mi addr:$dst, -128)>;
 
 def : Pat<(add GR64:$src1, 128),
-          (SUB64ri8 GR64:$src1, -128)>;
+          (SUB64ri32 GR64:$src1, -128)>;
 def : Pat<(store (add (loadi64 addr:$dst), 128), addr:$dst),
-          (SUB64mi8 addr:$dst, -128)>;
+          (SUB64mi32 addr:$dst, -128)>;
 
 def : Pat<(X86add_flag_nocf GR16:$src1, 128),
-          (SUB16ri8 GR16:$src1, -128)>;
+          (SUB16ri GR16:$src1, -128)>;
 def : Pat<(X86add_flag_nocf GR32:$src1, 128),
-          (SUB32ri8 GR32:$src1, -128)>;
+          (SUB32ri GR32:$src1, -128)>;
 def : Pat<(X86add_flag_nocf GR64:$src1, 128),
-          (SUB64ri8 GR64:$src1, -128)>;
+          (SUB64ri32 GR64:$src1, -128)>;
 
 // The same trick applies for 32-bit immediate fields in 64-bit
 // instructions.
 def : Pat<(add GR64:$src1, 0x0000000080000000),
           (SUB64ri32 GR64:$src1, 0xffffffff80000000)>;
 def : Pat<(store (add (loadi64 addr:$dst), 0x0000000080000000), addr:$dst),
           (SUB64mi32 addr:$dst, 0xffffffff80000000)>;
-
 def : Pat<(X86add_flag_nocf GR64:$src1, 0x0000000080000000),
           (SUB64ri32 GR64:$src1, 0xffffffff80000000)>;
 
 // To avoid needing to materialize an immediate in a register, use a 32-bit and
 // with implicit zero-extension instead of a 64-bit and if the immediate has at
 // least 32 bits of leading zeros. If in addition the last 32 bits can be
 // represented with a sign extension of a 8 bit constant, use that.
 // This can also reduce instruction size by eliminating the need for the REX
 // prefix.
 
 // AddedComplexity is needed to give priority over i64immSExt8 and i64immSExt32.
 let AddedComplexity = 1 in {
-def : Pat<(and GR64:$src, i64immZExt32SExt8:$imm),
-          (SUBREG_TO_REG
-            (i64 0),
-            (AND32ri8
-              (EXTRACT_SUBREG GR64:$src, sub_32bit),
-              (i32 (GetLo32XForm imm:$imm))),
-            sub_32bit)>;
-
 def : Pat<(and GR64:$src, i64immZExt32:$imm),
           (SUBREG_TO_REG
             (i64 0),
             (AND32ri
               (EXTRACT_SUBREG GR64:$src, sub_32bit),
               (i32 (GetLo32XForm imm:$imm))),
             sub_32bit)>;
 } // AddedComplexity = 1
def : Pat<(add GR32:$src1, (loadi32 addr:$src2)),
           (ADD32rm GR32:$src1, addr:$src2)>;
 def : Pat<(add GR64:$src1, (loadi64 addr:$src2)),
           (ADD64rm GR64:$src1, addr:$src2)>;
 
 // add reg, imm
 def : Pat<(add GR8 :$src1, imm:$src2), (ADD8ri  GR8:$src1 , imm:$src2)>;
 def : Pat<(add GR16:$src1, imm:$src2), (ADD16ri GR16:$src1, imm:$src2)>;
 def : Pat<(add GR32:$src1, imm:$src2), (ADD32ri GR32:$src1, imm:$src2)>;
-def : Pat<(add GR16:$src1, i16immSExt8:$src2),
-          (ADD16ri8 GR16:$src1, i16immSExt8:$src2)>;
-def : Pat<(add GR32:$src1, i32immSExt8:$src2),
-          (ADD32ri8 GR32:$src1, i32immSExt8:$src2)>;
-def : Pat<(add GR64:$src1, i64immSExt8:$src2),
-          (ADD64ri8 GR64:$src1, i64immSExt8:$src2)>;
-def : Pat<(add GR64:$src1, i64immSExt32:$src2),
-          (ADD64ri32 GR64:$src1, i64immSExt32:$src2)>;
+def : Pat<(add GR64:$src1, i64immSExt32:$src2), (ADD64ri32 GR64:$src1, i64immSExt32:$src2)>;
 
 // sub reg, reg
 def : Pat<(sub GR8 :$src1, GR8 :$src2), (SUB8rr  GR8 :$src1, GR8 :$src2)>;
 def : Pat<(sub GR16:$src1, GR16:$src2), (SUB16rr GR16:$src1, GR16:$src2)>;
 def : Pat<(sub GR32:$src1, GR32:$src2), (SUB32rr GR32:$src1, GR32:$src2)>;
 def : Pat<(sub GR64:$src1, GR64:$src2), (SUB64rr GR64:$src1, GR64:$src2)>;
 
 // sub reg, mem
 def : Pat<(sub GR8:$src1, (loadi8 addr:$src2)),
           (SUB8rm GR8:$src1, addr:$src2)>;
 def : Pat<(sub GR16:$src1, (loadi16 addr:$src2)),
           (SUB16rm GR16:$src1, addr:$src2)>;
 def : Pat<(sub GR32:$src1, (loadi32 addr:$src2)),
           (SUB32rm GR32:$src1, addr:$src2)>;
 def : Pat<(sub GR64:$src1, (loadi64 addr:$src2)),
           (SUB64rm GR64:$src1, addr:$src2)>;
 
 // sub reg, imm
 def : Pat<(sub GR8:$src1, imm:$src2),
           (SUB8ri GR8:$src1, imm:$src2)>;
 def : Pat<(sub GR16:$src1, imm:$src2),
           (SUB16ri GR16:$src1, imm:$src2)>;
 def : Pat<(sub GR32:$src1, imm:$src2),
           (SUB32ri GR32:$src1, imm:$src2)>;
-def : Pat<(sub GR16:$src1, i16immSExt8:$src2),
-          (SUB16ri8 GR16:$src1, i16immSExt8:$src2)>;
-def : Pat<(sub GR32:$src1, i32immSExt8:$src2),
-          (SUB32ri8 GR32:$src1, i32immSExt8:$src2)>;
-def : Pat<(sub GR64:$src1, i64immSExt8:$src2),
-          (SUB64ri8 GR64:$src1, i64immSExt8:$src2)>;
 def : Pat<(sub GR64:$src1, i64immSExt32:$src2),
           (SUB64ri32 GR64:$src1, i64immSExt32:$src2)>;
 
 // sub 0, reg
 def : Pat<(X86sub_flag 0, GR8 :$src), (NEG8r  GR8 :$src)>;
 def : Pat<(X86sub_flag 0, GR16:$src), (NEG16r GR16:$src)>;
 def : Pat<(X86sub_flag 0, GR32:$src), (NEG32r GR32:$src)>;
 def : Pat<(X86sub_flag 0, GR64:$src), (NEG64r GR64:$src)>;
def : Pat<(or GR32:$src1, (loadi32 addr:$src2)),
           (OR32rm GR32:$src1, addr:$src2)>;
 def : Pat<(or GR64:$src1, (loadi64 addr:$src2)),
           (OR64rm GR64:$src1, addr:$src2)>;
 
 // or reg/imm
 def : Pat<(or GR8:$src1 , imm:$src2), (OR8ri  GR8 :$src1, imm:$src2)>;
 def : Pat<(or GR16:$src1, imm:$src2), (OR16ri GR16:$src1, imm:$src2)>;
 def : Pat<(or GR32:$src1, imm:$src2), (OR32ri GR32:$src1, imm:$src2)>;
-def : Pat<(or GR16:$src1, i16immSExt8:$src2),
-          (OR16ri8 GR16:$src1, i16immSExt8:$src2)>;
-def : Pat<(or GR32:$src1, i32immSExt8:$src2),
-          (OR32ri8 GR32:$src1, i32immSExt8:$src2)>;
-def : Pat<(or GR64:$src1, i64immSExt8:$src2),
-          (OR64ri8 GR64:$src1, i64immSExt8:$src2)>;
 def : Pat<(or GR64:$src1, i64immSExt32:$src2),
           (OR64ri32 GR64:$src1, i64immSExt32:$src2)>;
 
 // xor reg/reg
 def : Pat<(xor GR8 :$src1, GR8 :$src2), (XOR8rr  GR8 :$src1, GR8 :$src2)>;
 def : Pat<(xor GR16:$src1, GR16:$src2), (XOR16rr GR16:$src1, GR16:$src2)>;
 def : Pat<(xor GR32:$src1, GR32:$src2), (XOR32rr GR32:$src1, GR32:$src2)>;
 def : Pat<(xor GR64:$src1, GR64:$src2), (XOR64rr GR64:$src1, GR64:$src2)>;

 
 // xor reg/imm
 def : Pat<(xor GR8:$src1, imm:$src2),
           (XOR8ri GR8:$src1, imm:$src2)>;
 def : Pat<(xor GR16:$src1, imm:$src2),
           (XOR16ri GR16:$src1, imm:$src2)>;
 def : Pat<(xor GR32:$src1, imm:$src2),
           (XOR32ri GR32:$src1, imm:$src2)>;
-def : Pat<(xor GR16:$src1, i16immSExt8:$src2),
-          (XOR16ri8 GR16:$src1, i16immSExt8:$src2)>;
-def : Pat<(xor GR32:$src1, i32immSExt8:$src2),
-          (XOR32ri8 GR32:$src1, i32immSExt8:$src2)>;
-def : Pat<(xor GR64:$src1, i64immSExt8:$src2),
-          (XOR64ri8 GR64:$src1, i64immSExt8:$src2)>;
 def : Pat<(xor GR64:$src1, i64immSExt32:$src2),
           (XOR64ri32 GR64:$src1, i64immSExt32:$src2)>;
 
 // and reg/reg
 def : Pat<(and GR8 :$src1, GR8 :$src2), (AND8rr  GR8 :$src1, GR8 :$src2)>;
 def : Pat<(and GR16:$src1, GR16:$src2), (AND16rr GR16:$src1, GR16:$src2)>;
 def : Pat<(and GR32:$src1, GR32:$src2), (AND32rr GR32:$src1, GR32:$src2)>;
 def : Pat<(and GR64:$src1, GR64:$src2), (AND64rr GR64:$src1, GR64:$src2)>;

 
 // and reg/imm
 def : Pat<(and GR8:$src1, imm:$src2),
           (AND8ri GR8:$src1, imm:$src2)>;
 def : Pat<(and GR16:$src1, imm:$src2),
           (AND16ri GR16:$src1, imm:$src2)>;
 def : Pat<(and GR32:$src1, imm:$src2),
           (AND32ri GR32:$src1, imm:$src2)>;
-def : Pat<(and GR16:$src1, i16immSExt8:$src2),
-          (AND16ri8 GR16:$src1, i16immSExt8:$src2)>;
-def : Pat<(and GR32:$src1, i32immSExt8:$src2),
-          (AND32ri8 GR32:$src1, i32immSExt8:$src2)>;
-def : Pat<(and GR64:$src1, i64immSExt8:$src2),
-          (AND64ri8 GR64:$src1, i64immSExt8:$src2)>;
 def : Pat<(and GR64:$src1, i64immSExt32:$src2),
           (AND64ri32 GR64:$src1, i64immSExt32:$src2)>;
 
 // Bit scan instruction patterns to match explicit zero-undef behavior.
 def : Pat<(cttz_zero_undef GR16:$src), (BSF16rr GR16:$src)>;
 def : Pat<(cttz_zero_undef GR32:$src), (BSF32rr GR32:$src)>;
 def : Pat<(cttz_zero_undef GR64:$src), (BSF64rr GR64:$src)>;
 def : Pat<(cttz_zero_undef (loadi16 addr:$src)), (BSF16rm addr:$src)>;
 def : Pat<(cttz_zero_undef (loadi32 addr:$src)), (BSF32rm addr:$src)>;
 def : Pat<(cttz_zero_undef (loadi64 addr:$src)), (BSF64rm addr:$src)>;
 
 // When HasMOVBE is enabled it is possible to get a non-legalized
 // register-register 16 bit bswap. This maps it to a ROL instruction.
 let Predicates = [HasMOVBE] in {
  def : Pat<(bswap GR16:$src), (ROL16ri GR16:$src, (i8 8))>;
 }

llvm/lib/Target/X86/X86InstrInfo.cpp

case X86::INC16r:
     break;
   case X86::DEC8r:
   case X86::DEC16r:
     addRegOffset(MIB, InRegLEA, true, -1);
     break;
   case X86::ADD8ri:
   case X86::ADD8ri_DB:
   case X86::ADD16ri:
-  case X86::ADD16ri8:
   case X86::ADD16ri_DB:
-  case X86::ADD16ri8_DB:
     addRegOffset(MIB, InRegLEA, true, MI.getOperand(2).getImm());
     break;
   case X86::ADD8rr:
   case X86::ADD8rr_DB:
   case X86::ADD16rr:
   case X86::ADD16rr_DB: {
     Src2 = MI.getOperand(2).getReg();
     bool IsKill2 = MI.getOperand(2).isKill();
MachineInstr *X86InstrInfo::convertToThreeAddress(MachineInstr &MI,
   case X86::ADD8rr:
   case X86::ADD8rr_DB:
     Is8BitOp = true;
     [[fallthrough]];
   case X86::ADD16rr:
   case X86::ADD16rr_DB:
     return convertToThreeAddressWithLEA(MIOpc, MI, LV, LIS, Is8BitOp);
   case X86::ADD64ri32:
-  case X86::ADD64ri8:
   case X86::ADD64ri32_DB:
-  case X86::ADD64ri8_DB:
     assert(MI.getNumOperands() >= 3 && "Unknown add instruction!");
     NewMI = addOffset(
         BuildMI(MF, MI.getDebugLoc(), get(X86::LEA64r)).add(Dest).add(Src),
         MI.getOperand(2));
     break;
   case X86::ADD32ri:
-  case X86::ADD32ri8:
-  case X86::ADD32ri_DB:
-  case X86::ADD32ri8_DB: {
+  case X86::ADD32ri_DB: {
     assert(MI.getNumOperands() >= 3 && "Unknown add instruction!");
     unsigned Opc = Is64Bit ? X86::LEA64_32r : X86::LEA32r;
 
     bool isKill;
     MachineOperand ImplicitOp = MachineOperand::CreateReg(0, false);
     if (!classifyLEAReg(MI, Src, Opc, /*AllowSP=*/true, SrcReg, isKill,
                         ImplicitOp, LV, LIS))
       return nullptr;
if (LV && SrcReg != Src.getReg())
       LV->getVarInfo(SrcReg).Kills.push_back(NewMI);
     break;
   }
   case X86::ADD8ri:
   case X86::ADD8ri_DB:
     Is8BitOp = true;
     [[fallthrough]];
   case X86::ADD16ri:
-  case X86::ADD16ri8:
   case X86::ADD16ri_DB:
-  case X86::ADD16ri8_DB:
     return convertToThreeAddressWithLEA(MIOpc, MI, LV, LIS, Is8BitOp);
   case X86::SUB8ri:
-  case X86::SUB16ri8:
   case X86::SUB16ri:
     /// FIXME: Support these similar to ADD8ri/ADD16ri*.
     return nullptr;
-  case X86::SUB32ri8:
   case X86::SUB32ri: {
     if (!MI.getOperand(2).isImm())
       return nullptr;
     int64_t Imm = MI.getOperand(2).getImm();
     if (!isInt<32>(-Imm))
       return nullptr;
 
     assert(MI.getNumOperands() >= 3 && "Unknown add instruction!");
case X86::SUB32ri: {
     NewMI = addOffset(MIB, -Imm);
 
     // Add kills if classifyLEAReg created a new register.
     if (LV && SrcReg != Src.getReg())
       LV->getVarInfo(SrcReg).Kills.push_back(NewMI);
     break;
   }
 
-  case X86::SUB64ri8:
   case X86::SUB64ri32: {
     if (!MI.getOperand(2).isImm())
       return nullptr;
     int64_t Imm = MI.getOperand(2).getImm();
     if (!isInt<32>(-Imm))
       return nullptr;
 
     assert(MI.getNumOperands() >= 3 && "Unknown sub instruction!");

 }
 
 bool X86InstrInfo::analyzeCompare(const MachineInstr &MI, Register &SrcReg,
                                   Register &SrcReg2, int64_t &CmpMask,
                                   int64_t &CmpValue) const {
   switch (MI.getOpcode()) {
   default: break;
   case X86::CMP64ri32:
-  case X86::CMP64ri8:
   case X86::CMP32ri:
-  case X86::CMP32ri8:
   case X86::CMP16ri:
-  case X86::CMP16ri8:
   case X86::CMP8ri:
     SrcReg = MI.getOperand(0).getReg();
     SrcReg2 = 0;
     if (MI.getOperand(1).isImm()) {
       CmpMask = ~0;
       CmpValue = MI.getOperand(1).getImm();
     } else {
       CmpMask = CmpValue = 0;
bool X86InstrInfo::analyzeCompare(const MachineInstr &MI, Register &SrcReg,
   case X86::SUB16rr:
   case X86::SUB8rr:
     SrcReg = MI.getOperand(1).getReg();
     SrcReg2 = MI.getOperand(2).getReg();
     CmpMask = 0;
     CmpValue = 0;
     return true;
   case X86::SUB64ri32:
-  case X86::SUB64ri8:
   case X86::SUB32ri:
-  case X86::SUB32ri8:
   case X86::SUB16ri:
-  case X86::SUB16ri8:
   case X86::SUB8ri:
     SrcReg = MI.getOperand(1).getReg();
     SrcReg2 = 0;
     if (MI.getOperand(2).isImm()) {
       CmpMask = ~0;
       CmpValue = MI.getOperand(2).getImm();
     } else {
       CmpMask = CmpValue = 0;
case X86::SUB8rr: {
     }
     if (SrcReg == OISrcReg2 && SrcReg2 == OISrcReg) {
       *IsSwapped = true;
       return true;
     }
     return false;
   }
   case X86::CMP64ri32:
-  case X86::CMP64ri8:
   case X86::CMP32ri:
-  case X86::CMP32ri8:
   case X86::CMP16ri:
-  case X86::CMP16ri8:
   case X86::CMP8ri:
   case X86::SUB64ri32:
-  case X86::SUB64ri8:
   case X86::SUB32ri:
-  case X86::SUB32ri8:
   case X86::SUB16ri:
-  case X86::SUB16ri8:
   case X86::SUB8ri:
   case X86::TEST64rr:
   case X86::TEST32rr:
   case X86::TEST16rr:
   case X86::TEST8rr: {
     if (ImmMask != 0) {
       Register OISrcReg;
       Register OISrcReg2;
case X86::SHL8ri:    case X86::SHL16ri:  case X86::SHL32ri:case X86::SHL64ri:{
     if (isTruncatedShiftCountForLEA(ShAmt)) return false;
     return ShAmt != 0;
   }
 
   case X86::SHRD16rri8:case X86::SHRD32rri8:case X86::SHRD64rri8:
   case X86::SHLD16rri8:case X86::SHLD32rri8:case X86::SHLD64rri8:
      return getTruncatedShiftCount(MI, 3) != 0;
 
-  case X86::SUB64ri32: case X86::SUB64ri8: case X86::SUB32ri:
-  case X86::SUB32ri8:  case X86::SUB16ri:  case X86::SUB16ri8:
+  case X86::SUB64ri32: case X86::SUB32ri:  case X86::SUB16ri:
   case X86::SUB8ri:    case X86::SUB64rr:  case X86::SUB32rr:
   case X86::SUB16rr:   case X86::SUB8rr:   case X86::SUB64rm:
   case X86::SUB32rm:   case X86::SUB16rm:  case X86::SUB8rm:
   case X86::DEC64r:    case X86::DEC32r:   case X86::DEC16r: case X86::DEC8r:
-  case X86::ADD64ri32: case X86::ADD64ri8: case X86::ADD32ri:
-  case X86::ADD32ri8:  case X86::ADD16ri:  case X86::ADD16ri8:
+  case X86::ADD64ri32: case X86::ADD32ri:  case X86::ADD16ri:
   case X86::ADD8ri:    case X86::ADD64rr:  case X86::ADD32rr:
   case X86::ADD16rr:   case X86::ADD8rr:   case X86::ADD64rm:
   case X86::ADD32rm:   case X86::ADD16rm:  case X86::ADD8rm:
   case X86::INC64r:    case X86::INC32r:   case X86::INC16r: case X86::INC8r:
   case X86::ADC64ri32: case X86::ADC32ri:  case X86::ADC16ri:
   case X86::ADC8ri:    case X86::ADC64rr:  case X86::ADC32rr:
   case X86::ADC16rr:   case X86::ADC8rr:   case X86::ADC64rm:
   case X86::ADC32rm:   case X86::ADC16rm:  case X86::ADC8rm:
   case X86::SBB64ri32: case X86::SBB32ri:  case X86::SBB16ri:
   case X86::SBB8ri:    case X86::SBB64rr:  case X86::SBB32rr:
   case X86::SBB16rr:   case X86::SBB8rr:   case X86::SBB64rm:
   case X86::SBB32rm:   case X86::SBB16rm:  case X86::SBB8rm:
   case X86::NEG8r:     case X86::NEG16r:   case X86::NEG32r: case X86::NEG64r:
   case X86::LZCNT16rr: case X86::LZCNT16rm:
   case X86::LZCNT32rr: case X86::LZCNT32rm:
   case X86::LZCNT64rr: case X86::LZCNT64rm:
   case X86::POPCNT16rr:case X86::POPCNT16rm:
   case X86::POPCNT32rr:case X86::POPCNT32rm:
   case X86::POPCNT64rr:case X86::POPCNT64rm:
   case X86::TZCNT16rr: case X86::TZCNT16rm:
   case X86::TZCNT32rr: case X86::TZCNT32rm:
   case X86::TZCNT64rr: case X86::TZCNT64rm:
     return true;
-  case X86::AND64ri32:   case X86::AND64ri8:  case X86::AND32ri:
-  case X86::AND32ri8:    case X86::AND16ri:   case X86::AND16ri8:
+  case X86::AND64ri32:   case X86::AND32ri:   case X86::AND16ri:
   case X86::AND8ri:      case X86::AND64rr:   case X86::AND32rr:
   case X86::AND16rr:     case X86::AND8rr:    case X86::AND64rm:
   case X86::AND32rm:     case X86::AND16rm:   case X86::AND8rm:
-  case X86::XOR64ri32:   case X86::XOR64ri8:  case X86::XOR32ri:
-  case X86::XOR32ri8:    case X86::XOR16ri:   case X86::XOR16ri8:
+  case X86::XOR64ri32:   case X86::XOR32ri:   case X86::XOR16ri:
   case X86::XOR8ri:      case X86::XOR64rr:   case X86::XOR32rr:
   case X86::XOR16rr:     case X86::XOR8rr:    case X86::XOR64rm:
   case X86::XOR32rm:     case X86::XOR16rm:   case X86::XOR8rm:
-  case X86::OR64ri32:    case X86::OR64ri8:   case X86::OR32ri:
-  case X86::OR32ri8:     case X86::OR16ri:    case X86::OR16ri8:
+  case X86::OR64ri32:    case X86::OR32ri:    case X86::OR16ri:
   case X86::OR8ri:       case X86::OR64rr:    case X86::OR32rr:
   case X86::OR16rr:      case X86::OR8rr:     case X86::OR64rm:
   case X86::OR32rm:      case X86::OR16rm:    case X86::OR8rm:
   case X86::ANDN32rr:    case X86::ANDN32rm:
   case X86::ANDN64rr:    case X86::ANDN64rm:
   case X86::BLSI32rr:    case X86::BLSI32rm:
   case X86::BLSI64rr:    case X86::BLSI64rm:
   case X86::BLSMSK32rr:  case X86::BLSMSK32rm:

 bool X86InstrInfo::optimizeCompareInstr(MachineInstr &CmpInstr, Register SrcReg,
                                         Register SrcReg2, int64_t CmpMask,
                                         int64_t CmpValue,
                                         const MachineRegisterInfo *MRI) const {
   // Check whether we can replace SUB with CMP.
   switch (CmpInstr.getOpcode()) {
   default: break;
   case X86::SUB64ri32:
-  case X86::SUB64ri8:
   case X86::SUB32ri:
-  case X86::SUB32ri8:
   case X86::SUB16ri:
-  case X86::SUB16ri8:
   case X86::SUB8ri:
   case X86::SUB64rm:
   case X86::SUB32rm:
   case X86::SUB16rm:
   case X86::SUB8rm:
   case X86::SUB64rr:
   case X86::SUB32rr:
   case X86::SUB16rr:
   case X86::SUB8rr: {
     if (!MRI->use_nodbg_empty(CmpInstr.getOperand(0).getReg()))
       return false;
     // There is no use of the destination register, we can replace SUB with CMP.
     unsigned NewOpcode = 0;
     switch (CmpInstr.getOpcode()) {
     default: llvm_unreachable("Unreachable!");
     case X86::SUB64rm:   NewOpcode = X86::CMP64rm;   break;
     case X86::SUB32rm:   NewOpcode = X86::CMP32rm;   break;
     case X86::SUB16rm:   NewOpcode = X86::CMP16rm;   break;
     case X86::SUB8rm:    NewOpcode = X86::CMP8rm;    break;
     case X86::SUB64rr:   NewOpcode = X86::CMP64rr;   break;
     case X86::SUB32rr:   NewOpcode = X86::CMP32rr;   break;
     case X86::SUB16rr:   NewOpcode = X86::CMP16rr;   break;
     case X86::SUB8rr:    NewOpcode = X86::CMP8rr;    break;
     case X86::SUB64ri32: NewOpcode = X86::CMP64ri32; break;
-    case X86::SUB64ri8:  NewOpcode = X86::CMP64ri8;  break;
     case X86::SUB32ri:   NewOpcode = X86::CMP32ri;   break;
-    case X86::SUB32ri8:  NewOpcode = X86::CMP32ri8;  break;
     case X86::SUB16ri:   NewOpcode = X86::CMP16ri;   break;
-    case X86::SUB16ri8:  NewOpcode = X86::CMP16ri8;  break;
     case X86::SUB8ri:    NewOpcode = X86::CMP8ri;    break;
     }
     CmpInstr.setDesc(get(NewOpcode));
     CmpInstr.removeOperand(0);
     // Mutating this instruction invalidates any debug data associated with it.
     CmpInstr.dropDebugNumber();
     // Fall through to optimize Cmp if Cmp is CMPrr or CMPri.
     if (NewOpcode == X86::CMP64rm || NewOpcode == X86::CMP32rm ||
bool X86InstrInfo::expandPostRAPseudo(MachineInstr &MI) const {
   case X86::ADD8rr_DB:    MIB->setDesc(get(X86::OR8rr));    break;
   case X86::ADD16rr_DB:   MIB->setDesc(get(X86::OR16rr));   break;
   case X86::ADD32rr_DB:   MIB->setDesc(get(X86::OR32rr));   break;
   case X86::ADD64rr_DB:   MIB->setDesc(get(X86::OR64rr));   break;
   case X86::ADD8ri_DB:    MIB->setDesc(get(X86::OR8ri));    break;
   case X86::ADD16ri_DB:   MIB->setDesc(get(X86::OR16ri));   break;
   case X86::ADD32ri_DB:   MIB->setDesc(get(X86::OR32ri));   break;
   case X86::ADD64ri32_DB: MIB->setDesc(get(X86::OR64ri32)); break;
-  case X86::ADD16ri8_DB:  MIB->setDesc(get(X86::OR16ri8));  break;
-  case X86::ADD32ri8_DB:  MIB->setDesc(get(X86::OR32ri8));  break;
-  case X86::ADD64ri8_DB:  MIB->setDesc(get(X86::OR64ri8));  break;
   }
   return false;
 }
 
 /// Return true for all instructions that only update
 /// the first 32 or 64-bits of the destination register and leave the rest
 /// unmodified. This can be used to avoid folding loads if the instructions
 /// only update part of the destination register, and the non-updated part is
if (!RI.hasStackRealignment(MF))
     Alignment =
         std::min(Alignment, Subtarget.getFrameLowering()->getStackAlign());
   if (Ops.size() == 2 && Ops[0] == 0 && Ops[1] == 1) {
     unsigned NewOpc = 0;
     unsigned RCSize = 0;
     switch (MI.getOpcode()) {
     default: return nullptr;
     case X86::TEST8rr:  NewOpc = X86::CMP8ri; RCSize = 1; break;
-    case X86::TEST16rr: NewOpc = X86::CMP16ri8; RCSize = 2; break;
-    case X86::TEST32rr: NewOpc = X86::CMP32ri8; RCSize = 4; break;
-    case X86::TEST64rr: NewOpc = X86::CMP64ri8; RCSize = 8; break;
+    case X86::TEST16rr: NewOpc = X86::CMP16ri; RCSize = 2; break;
+    case X86::TEST32rr: NewOpc = X86::CMP32ri; RCSize = 4; break;
+    case X86::TEST64rr: NewOpc = X86::CMP64ri32; RCSize = 8; break;
     }
     // Check if it's safe to fold the load. If the size of the object is
     // narrower than the load width, then it's not.
     if (Size < RCSize)
       return nullptr;
     // Change to CMPXXri r, 0 first.
     MI.setDesc(get(NewOpc));
     MI.getOperand(1).ChangeToImmediate(0);
else
     default:
       return nullptr;
     }
   if (Ops.size() == 2 && Ops[0] == 0 && Ops[1] == 1) {
     unsigned NewOpc = 0;
     switch (MI.getOpcode()) {
     default: return nullptr;
     case X86::TEST8rr:  NewOpc = X86::CMP8ri; break;
-    case X86::TEST16rr: NewOpc = X86::CMP16ri8; break;
-    case X86::TEST32rr: NewOpc = X86::CMP32ri8; break;
-    case X86::TEST64rr: NewOpc = X86::CMP64ri8; break;
+    case X86::TEST16rr: NewOpc = X86::CMP16ri; break;
+    case X86::TEST32rr: NewOpc = X86::CMP32ri; break;
+    case X86::TEST64rr: NewOpc = X86::CMP64ri32; break;
     }
     // Change to CMPXXri r, 0 first.
     MI.setDesc(get(NewOpc));
     MI.getOperand(1).ChangeToImmediate(0);
   } else if (Ops.size() != 1)
     return nullptr;
 
   // Make sure the subregisters match.
MIB.addReg(ImpOp.getReg(),
                getKillRegState(ImpOp.isKill()) |
                getDeadRegState(ImpOp.isDead()) |
                getUndefRegState(ImpOp.isUndef()));
   }
   // Change CMP32ri r, 0 back to TEST32rr r, r, etc.
   switch (DataMI->getOpcode()) {
   default: break;
   case X86::CMP64ri32:
-  case X86::CMP64ri8:
   case X86::CMP32ri:
-  case X86::CMP32ri8:
   case X86::CMP16ri:
-  case X86::CMP16ri8:
   case X86::CMP8ri: {
     MachineOperand &MO0 = DataMI->getOperand(0);
     MachineOperand &MO1 = DataMI->getOperand(1);
     if (MO1.isImm() && MO1.getImm() == 0) {
       unsigned NewOpc;
       switch (DataMI->getOpcode()) {
       default: llvm_unreachable("Unreachable!");
-      case X86::CMP64ri8:
       case X86::CMP64ri32: NewOpc = X86::TEST64rr; break;
-      case X86::CMP32ri8:
       case X86::CMP32ri:   NewOpc = X86::TEST32rr; break;
-      case X86::CMP16ri8:
       case X86::CMP16ri:   NewOpc = X86::TEST16rr; break;
       case X86::CMP8ri:    NewOpc = X86::TEST8rr; break;
       }
       DataMI->setDesc(get(NewOpc));
       MO1.ChangeToRegister(MO0.getReg(), false);
     }
   }
   }
X86InstrInfo::unfoldMemoryOperand(SelectionDAG &DAG, SDNode *N,
   }
   if (Load)
     BeforeOps.push_back(SDValue(Load, 0));
   llvm::append_range(BeforeOps, AfterOps);
   // Change CMP32ri r, 0 back to TEST32rr r, r, etc.
   switch (Opc) {
     default: break;
     case X86::CMP64ri32:
-    case X86::CMP64ri8:
     case X86::CMP32ri:
-    case X86::CMP32ri8:
     case X86::CMP16ri:
-    case X86::CMP16ri8:
     case X86::CMP8ri:
       if (isNullConstant(BeforeOps[1])) {
         switch (Opc) {
           default: llvm_unreachable("Unreachable!");
-          case X86::CMP64ri8:
           case X86::CMP64ri32: Opc = X86::TEST64rr; break;
-          case X86::CMP32ri8:
           case X86::CMP32ri:   Opc = X86::TEST32rr; break;
-          case X86::CMP16ri8:
           case X86::CMP16ri:   Opc = X86::TEST16rr; break;
           case X86::CMP8ri:    Opc = X86::TEST8rr; break;
         }
         BeforeOps[1] = BeforeOps[0];
       }
   }
   SDNode *NewNode= DAG.getMachineNode(Opc, dl, VTs, BeforeOps);
   NewNodes.push_back(NewNode);

llvm/lib/Target/X86/X86InstructionSelector.cpp

bool X86InstructionSelector::selectZext(MachineInstr &I,
 
   if (SrcTy != LLT::scalar(1))
     return false;
 
   unsigned AndOpc;
   if (DstTy == LLT::scalar(8))
     AndOpc = X86::AND8ri;
   else if (DstTy == LLT::scalar(16))
-    AndOpc = X86::AND16ri8;
+    AndOpc = X86::AND16ri;
   else if (DstTy == LLT::scalar(32))
-    AndOpc = X86::AND32ri8;
+    AndOpc = X86::AND32ri;
   else if (DstTy == LLT::scalar(64))
-    AndOpc = X86::AND64ri8;
+    AndOpc = X86::AND64ri32;
   else
     return false;
 
   Register DefReg = SrcReg;
   if (DstTy != LLT::scalar(8)) {
     Register ImpDefReg =
         MRI.createVirtualRegister(getRegClass(DstTy, DstReg, MRI));
     BuildMI(*I.getParent(), I, I.getDebugLoc(),

llvm/lib/Target/X86/X86MCInstLower.cpp

if (auto MaybeMCOp = LowerMachineOperand(MI, MO))
       OutMI.addOperand(*MaybeMCOp);
 
   bool In64BitMode = AsmPrinter.getSubtarget().is64Bit();
   if (X86::optimizeInstFromVEX3ToVEX2(OutMI, MI->getDesc()) ||
       X86::optimizeShiftRotateWithImmediateOne(OutMI) ||
       X86::optimizeVPCMPWithImmediateOneOrSix(OutMI) ||
       X86::optimizeMOVSX(OutMI) || X86::optimizeINCDEC(OutMI, In64BitMode) ||
       X86::optimizeMOV(OutMI, In64BitMode) ||
-      X86::optimizeToFixedRegisterForm(OutMI) ||
-      X86::optimizeToShortImmediateForm(OutMI))
+      X86::optimizeToFixedRegisterOrShortImmediateForm(OutMI))
     return;
 
   // Handle a few special cases to eliminate operand modifiers.
   switch (OutMI.getOpcode()) {
   case X86::LEA64_32r:
   case X86::LEA64r:
   case X86::LEA16r:
   case X86::LEA32r:

llvm/test/CodeGen/MIR/X86/branch-folder-with-label.mir

body:             |
   bb.4:
     successors: %bb.5(0x80000000)
     liveins: $eax
   
   
   bb.5.if.then:
     liveins: $eax
   
-    $rsp = frame-destroy ADD64ri8 $rsp, 8, implicit-def dead $eflags
+    $rsp = frame-destroy ADD64ri32 $rsp, 8, implicit-def dead $eflags
     CFI_INSTRUCTION def_cfa_offset 24
     $rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp
     CFI_INSTRUCTION def_cfa_offset 16
     $r14 = frame-destroy POP64r implicit-def $rsp, implicit $rsp
     CFI_INSTRUCTION def_cfa_offset 8
     RET 0, $eax
   
   bb.6.do.cond:
     successors: %bb.8(0x30000000), %bb.7(0x50000000)
     liveins: $rbx, $r14
   
-    CMP32mi8 $rsp, 1, $noreg, 4, $noreg, 0, implicit-def $eflags :: (dereferenceable load (s32) from %ir.idx)
+    CMP32mi $rsp, 1, $noreg, 4, $noreg, 0, implicit-def $eflags :: (dereferenceable load (s32) from %ir.idx)
     JCC_1 %bb.8, 8, implicit killed $eflags
     JMP_1 %bb.7
   
   bb.7.lor.rhs:
     successors: %bb.8(0x30000000), %bb.3(0x50000000)
     liveins: $rbx, $r14
   
-    CMP32mi8 renamable $rbx, 1, $noreg, 0, $noreg, 0, implicit-def $eflags :: (load (s32) from %ir.1)
+    CMP32mi renamable $rbx, 1, $noreg, 0, $noreg, 0, implicit-def $eflags :: (load (s32) from %ir.1)
     JCC_1 %bb.3, 5, implicit killed $eflags
     JMP_1 %bb.8
   
   bb.8.do.body.backedge:
     successors: %bb.9(0x04000000), %bb.6(0x7c000000)
     liveins: $rbx, $r14
   
     $rdi = COPY renamable $r14, debug-location !22

llvm/test/CodeGen/X86/AMX/amx-greedy-ra-spill-shape.ll

define void @foo(i32 %M, i32 %N, i32 %K, ptr %A, ptr %B_rcr4, ptr %C, i32 %c_row_from, i32 %c_row_to, i32 %c_row_tile, i32 %c_col_from, i32 %c_col_to, i32 %c_col_tile) {
   ; CHECK-NEXT: bb.1.for.cond14.preheader.lr.ph:
   ; CHECK-NEXT:   successors: %bb.2(0x80000000)
   ; CHECK-NEXT: {{  $}}
   ; CHECK-NEXT:   undef [[MOV89:%[0-9]+]].sub_32bit:gr64_nosp = MOV32rm %fixed-stack.0, 1, $noreg, 0, $noreg :: (load (s32) from %fixed-stack.0, align 8)
   ; CHECK-NEXT:   MOV16mr %stack.0, 1, $noreg, 16, $noreg, [[MOV89]].sub_16bit :: (store (s512) into %stack.0 + 16, align 4)
   ; CHECK-NEXT:   [[MOV32rm2:%[0-9]+]]:gr32 = MOV32rm %fixed-stack.3, 1, $noreg, 0, $noreg :: (load (s32) from %fixed-stack.3, align 16)
   ; CHECK-NEXT:   MOV8mr %stack.0, 1, $noreg, 49, $noreg, [[MOV32rm2]].sub_8bit :: (store (s512) into %stack.0 + 49, align 1, basealign 4)
   ; CHECK-NEXT:   MOV8mr %stack.0, 1, $noreg, 48, $noreg, [[MOV32rm2]].sub_8bit :: (store (s512) into %stack.0 + 48, align 4)
-  ; CHECK-NEXT:   [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[AND32ri8_]], -64, implicit-def dead $eflags
+  ; CHECK-NEXT:   [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[AND32ri_]], -64, implicit-def dead $eflags
   ; CHECK-NEXT:   [[COPY2:%[0-9]+]]:gr32 = COPY [[COPY83]].sub_32bit
   ; CHECK-NEXT:   MOV16mr %stack.0, 1, $noreg, 18, $noreg, [[COPY2]].sub_16bit :: (store (s512) into %stack.0 + 18, align 2, basealign 4)
-  ; CHECK-NEXT:   [[SUB32rr:%[0-9]+]]:gr32 = SUB32rr [[SUB32rr]], [[AND32ri8_]], implicit-def dead $eflags
+  ; CHECK-NEXT:   [[SUB32rr:%[0-9]+]]:gr32 = SUB32rr [[SUB32rr]], [[AND32ri_]], implicit-def dead $eflags
   ; CHECK-NEXT:   MOV16mr %stack.0, 1, $noreg, 18, $noreg, [[SUB32rr]].sub_16bit :: (store (s512) into %stack.0 + 18, align 2, basealign 4)
   ; CHECK-NEXT:   [[MOVZX32rr16_:%[0-9]+]]:gr32 = MOVZX32rr16 [[SUB32rr]].sub_16bit
   ; CHECK-NEXT:   MOV8mr %stack.0, 1, $noreg, 50, $noreg, [[MOVZX32rr16_]].sub_8bit :: (store (s512) into %stack.0 + 50, align 2, basealign 4)
   ; CHECK-NEXT:   [[SHR32ri:%[0-9]+]]:gr32 = SHR32ri [[SHR32ri]], 2, implicit-def dead $eflags
   ; CHECK-NEXT:   MOV32mr %stack.2, 1, $noreg, 0, $noreg, [[SHR32ri]] :: (store (s32) into %stack.2)
   ; CHECK-NEXT:   MOV8mr %stack.0, 1, $noreg, 50, $noreg, [[SHR32ri]].sub_8bit :: (store (s512) into %stack.0 + 50, align 2, basealign 4)
   ; CHECK-NEXT:   [[LEA64_32r:%[0-9]+]]:gr32 = LEA64_32r $noreg, 4, [[MOV89]], 0, $noreg
   ; CHECK-NEXT:   MOV16mr %stack.0, 1, $noreg, 20, $noreg, [[LEA64_32r]].sub_16bit :: (store (s512) into %stack.0 + 20, align 4)

llvm/test/CodeGen/X86/GlobalISel/select-blsi.mir

body:             |
   bb.1:
     liveins: $edi
 
     ; CHECK-LABEL: name: test_blsi32rr_nomatch
     ; CHECK: liveins: $edi
     ; CHECK-NEXT: {{  $}}
     ; CHECK-NEXT: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; CHECK-NEXT: [[MOV32r0_:%[0-9]+]]:gr32 = MOV32r0 implicit-def $eflags
-    ; CHECK-NEXT: [[SUB32ri8_:%[0-9]+]]:gr32 = SUB32ri8 [[MOV32r0_]], 0, implicit-def $eflags
-    ; CHECK-NEXT: [[AND32rr:%[0-9]+]]:gr32 = AND32rr [[SUB32ri8_]], [[COPY]], implicit-def $eflags
+    ; CHECK-NEXT: [[SUB32ri:%[0-9]+]]:gr32 = SUB32ri [[MOV32r0_]], 0, implicit-def $eflags
+    ; CHECK-NEXT: [[AND32rr:%[0-9]+]]:gr32 = AND32rr [[SUB32ri]], [[COPY]], implicit-def $eflags
     ; CHECK-NEXT: $edi = COPY [[AND32rr]]
     %0(s32) = COPY $edi
     %1(s32) = G_CONSTANT i32 0
     %2(s32) = G_SUB %1, %1
     %3(s32) = G_AND %2, %0
     $edi = COPY %3
 ...

llvm/test/CodeGen/X86/GlobalISel/select-cmp.mir

bb.1 (%ir-block.0):
     liveins: $edi, $esi
 
     ; CHECK-LABEL: name: test_icmp_eq_i8
     ; CHECK: [[COPY:%[0-9]+]]:gr8 = COPY $dil
     ; CHECK: [[COPY1:%[0-9]+]]:gr8 = COPY $sil
     ; CHECK: CMP8rr [[COPY]], [[COPY1]], implicit-def $eflags
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 4, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 [[SETCCr]]
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[MOVZX32rr8_]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[MOVZX32rr8_]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %0(s8) = COPY $dil
     %1(s8) = COPY $sil
     %4(s8) = G_ICMP intpred(eq), %0(s8), %1
     %5(s32) = G_CONSTANT i32 1
     %6(s32) = G_ANYEXT %4(s8)
     %3(s32) = G_AND %6, %5
     $eax = COPY %3(s32)
bb.1 (%ir-block.0):
     liveins: $edi, $esi
 
     ; CHECK-LABEL: name: test_icmp_eq_i16
     ; CHECK: [[COPY:%[0-9]+]]:gr16 = COPY $di
     ; CHECK: [[COPY1:%[0-9]+]]:gr16 = COPY $si
     ; CHECK: CMP16rr [[COPY]], [[COPY1]], implicit-def $eflags
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 4, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 [[SETCCr]]
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[MOVZX32rr8_]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[MOVZX32rr8_]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %0(s16) = COPY $di
     %1(s16) = COPY $si
     %4(s8) = G_ICMP intpred(eq), %0(s16), %1
     %5(s32) = G_CONSTANT i32 1
     %6(s32) = G_ANYEXT %4(s8)
     %3(s32) = G_AND %6, %5
     $eax = COPY %3(s32)
bb.1 (%ir-block.0):
     liveins: $rdi, $rsi
 
     ; CHECK-LABEL: name: test_icmp_eq_i64
     ; CHECK: [[COPY:%[0-9]+]]:gr64 = COPY $rdi
     ; CHECK: [[COPY1:%[0-9]+]]:gr64 = COPY $rsi
     ; CHECK: CMP64rr [[COPY]], [[COPY1]], implicit-def $eflags
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 4, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 [[SETCCr]]
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[MOVZX32rr8_]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[MOVZX32rr8_]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %0(s64) = COPY $rdi
     %1(s64) = COPY $rsi
     %4(s8) = G_ICMP intpred(eq), %0(s64), %1
     %5(s32) = G_CONSTANT i32 1
     %6(s32) = G_ANYEXT %4(s8)
     %3(s32) = G_AND %6, %5
     $eax = COPY %3(s32)
bb.1 (%ir-block.0):
     liveins: $edi, $esi
 
     ; CHECK-LABEL: name: test_icmp_eq_i32
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; CHECK: [[COPY1:%[0-9]+]]:gr32 = COPY $esi
     ; CHECK: CMP32rr [[COPY]], [[COPY1]], implicit-def $eflags
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 4, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 [[SETCCr]]
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[MOVZX32rr8_]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[MOVZX32rr8_]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %0(s32) = COPY $edi
     %1(s32) = COPY $esi
     %4(s8) = G_ICMP intpred(eq), %0(s32), %1
     %5(s32) = G_CONSTANT i32 1
     %6(s32) = G_ANYEXT %4(s8)
     %3(s32) = G_AND %6, %5
     $eax = COPY %3(s32)
bb.1 (%ir-block.0):
     liveins: $edi, $esi
 
     ; CHECK-LABEL: name: test_icmp_ne_i32
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; CHECK: [[COPY1:%[0-9]+]]:gr32 = COPY $esi
     ; CHECK: CMP32rr [[COPY]], [[COPY1]], implicit-def $eflags
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 5, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 [[SETCCr]]
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[MOVZX32rr8_]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[MOVZX32rr8_]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %0(s32) = COPY $edi
     %1(s32) = COPY $esi
     %4(s8) = G_ICMP intpred(ne), %0(s32), %1
     %5(s32) = G_CONSTANT i32 1
     %6(s32) = G_ANYEXT %4(s8)
     %3(s32) = G_AND %6, %5
     $eax = COPY %3(s32)
bb.1 (%ir-block.0):
     liveins: $edi, $esi
 
     ; CHECK-LABEL: name: test_icmp_ugt_i32
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; CHECK: [[COPY1:%[0-9]+]]:gr32 = COPY $esi
     ; CHECK: CMP32rr [[COPY]], [[COPY1]], implicit-def $eflags
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 7, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 [[SETCCr]]
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[MOVZX32rr8_]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[MOVZX32rr8_]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %0(s32) = COPY $edi
     %1(s32) = COPY $esi
     %4(s8) = G_ICMP intpred(ugt), %0(s32), %1
     %5(s32) = G_CONSTANT i32 1
     %6(s32) = G_ANYEXT %4(s8)
     %3(s32) = G_AND %6, %5
     $eax = COPY %3(s32)
bb.1 (%ir-block.0):
     liveins: $edi, $esi
 
     ; CHECK-LABEL: name: test_icmp_uge_i32
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; CHECK: [[COPY1:%[0-9]+]]:gr32 = COPY $esi
     ; CHECK: CMP32rr [[COPY]], [[COPY1]], implicit-def $eflags
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 3, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 [[SETCCr]]
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[MOVZX32rr8_]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[MOVZX32rr8_]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %0(s32) = COPY $edi
     %1(s32) = COPY $esi
     %4(s8) = G_ICMP intpred(uge), %0(s32), %1
     %5(s32) = G_CONSTANT i32 1
     %6(s32) = G_ANYEXT %4(s8)
     %3(s32) = G_AND %6, %5
     $eax = COPY %3(s32)
bb.1 (%ir-block.0):
     liveins: $edi, $esi
 
     ; CHECK-LABEL: name: test_icmp_ult_i32
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; CHECK: [[COPY1:%[0-9]+]]:gr32 = COPY $esi
     ; CHECK: CMP32rr [[COPY]], [[COPY1]], implicit-def $eflags
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 2, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 [[SETCCr]]
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[MOVZX32rr8_]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[MOVZX32rr8_]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %0(s32) = COPY $edi
     %1(s32) = COPY $esi
     %4(s8) = G_ICMP intpred(ult), %0(s32), %1
     %5(s32) = G_CONSTANT i32 1
     %6(s32) = G_ANYEXT %4(s8)
     %3(s32) = G_AND %6, %5
     $eax = COPY %3(s32)
bb.1 (%ir-block.0):
     liveins: $edi, $esi
 
     ; CHECK-LABEL: name: test_icmp_ule_i32
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; CHECK: [[COPY1:%[0-9]+]]:gr32 = COPY $esi
     ; CHECK: CMP32rr [[COPY]], [[COPY1]], implicit-def $eflags
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 6, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 [[SETCCr]]
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[MOVZX32rr8_]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[MOVZX32rr8_]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %0(s32) = COPY $edi
     %1(s32) = COPY $esi
     %4(s8) = G_ICMP intpred(ule), %0(s32), %1
     %5(s32) = G_CONSTANT i32 1
     %6(s32) = G_ANYEXT %4(s8)
     %3(s32) = G_AND %6, %5
     $eax = COPY %3(s32)
bb.1 (%ir-block.0):
     liveins: $edi, $esi
 
     ; CHECK-LABEL: name: test_icmp_sgt_i32
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; CHECK: [[COPY1:%[0-9]+]]:gr32 = COPY $esi
     ; CHECK: CMP32rr [[COPY]], [[COPY1]], implicit-def $eflags
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 15, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 [[SETCCr]]
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[MOVZX32rr8_]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[MOVZX32rr8_]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %0(s32) = COPY $edi
     %1(s32) = COPY $esi
     %4(s8) = G_ICMP intpred(sgt), %0(s32), %1
     %5(s32) = G_CONSTANT i32 1
     %6(s32) = G_ANYEXT %4(s8)
     %3(s32) = G_AND %6, %5
     $eax = COPY %3(s32)
bb.1 (%ir-block.0):
     liveins: $edi, $esi
 
     ; CHECK-LABEL: name: test_icmp_sge_i32
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; CHECK: [[COPY1:%[0-9]+]]:gr32 = COPY $esi
     ; CHECK: CMP32rr [[COPY]], [[COPY1]], implicit-def $eflags
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 13, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 [[SETCCr]]
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[MOVZX32rr8_]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[MOVZX32rr8_]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %0(s32) = COPY $edi
     %1(s32) = COPY $esi
     %4(s8) = G_ICMP intpred(sge), %0(s32), %1
     %5(s32) = G_CONSTANT i32 1
     %6(s32) = G_ANYEXT %4(s8)
     %3(s32) = G_AND %6, %5
     $eax = COPY %3(s32)
bb.1 (%ir-block.0):
     liveins: $edi, $esi
 
     ; CHECK-LABEL: name: test_icmp_slt_i32
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; CHECK: [[COPY1:%[0-9]+]]:gr32 = COPY $esi
     ; CHECK: CMP32rr [[COPY]], [[COPY1]], implicit-def $eflags
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 12, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 [[SETCCr]]
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[MOVZX32rr8_]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[MOVZX32rr8_]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %0(s32) = COPY $edi
     %1(s32) = COPY $esi
     %4(s8) = G_ICMP intpred(slt), %0(s32), %1
     %5(s32) = G_CONSTANT i32 1
     %6(s32) = G_ANYEXT %4(s8)
     %3(s32) = G_AND %6, %5
     $eax = COPY %3(s32)
bb.1 (%ir-block.0):
     liveins: $edi, $esi
 
     ; CHECK-LABEL: name: test_icmp_sle_i32
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; CHECK: [[COPY1:%[0-9]+]]:gr32 = COPY $esi
     ; CHECK: CMP32rr [[COPY]], [[COPY1]], implicit-def $eflags
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 14, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 [[SETCCr]]
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[MOVZX32rr8_]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[MOVZX32rr8_]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %0(s32) = COPY $edi
     %1(s32) = COPY $esi
     %4(s8) = G_ICMP intpred(sle), %0(s32), %1
     %5(s32) = G_CONSTANT i32 1
     %6(s32) = G_ANYEXT %4(s8)
     %3(s32) = G_AND %6, %5
     $eax = COPY %3(s32)
     RET 0, implicit $eax
 
 ...

llvm/test/CodeGen/X86/GlobalISel/select-ext-x86-64.mir

 body:             |
   bb.1 (%ir-block.0):
     liveins: $edi
 
     ; ALL-LABEL: name: test_zext_i1
     ; ALL: [[COPY:%[0-9]+]]:gr8 = COPY $dil
     ; ALL: [[DEF:%[0-9]+]]:gr64 = IMPLICIT_DEF
     ; ALL: [[INSERT_SUBREG:%[0-9]+]]:gr64 = INSERT_SUBREG [[DEF]], [[COPY]], %subreg.sub_8bit
-    ; ALL: [[AND64ri8_:%[0-9]+]]:gr64 = AND64ri8 [[INSERT_SUBREG]], 1, implicit-def $eflags
-    ; ALL: $rax = COPY [[AND64ri8_]]
+    ; ALL: [[AND64ri32_:%[0-9]+]]:gr64 = AND64ri32 [[INSERT_SUBREG]], 1, implicit-def $eflags
+    ; ALL: $rax = COPY [[AND64ri32_]]
     ; ALL: RET 0, implicit $rax
     %0(s8) = COPY $dil
     %1(s1) = G_TRUNC %0(s8)
     %2(s64) = G_ZEXT %1(s1)
     $rax = COPY %2(s64)
     RET 0, implicit $rax
 
 ...

llvm/test/CodeGen/X86/GlobalISel/select-ext.mir

body:             |
   bb.1 (%ir-block.0):
     liveins: $edi
 
     ; X86-LABEL: name: test_zext_i1toi16
     ; X86: [[COPY:%[0-9]+]]:gr32_abcd = COPY $edi
     ; X86-NEXT: [[COPY1:%[0-9]+]]:gr8 = COPY [[COPY]].sub_8bit
     ; X86-NEXT: [[DEF:%[0-9]+]]:gr16 = IMPLICIT_DEF
     ; X86-NEXT: [[INSERT_SUBREG:%[0-9]+]]:gr16 = INSERT_SUBREG [[DEF]], [[COPY1]], %subreg.sub_8bit
-    ; X86-NEXT: [[AND16ri8_:%[0-9]+]]:gr16 = AND16ri8 [[INSERT_SUBREG]], 1, implicit-def $eflags
-    ; X86-NEXT: $ax = COPY [[AND16ri8_]]
+    ; X86-NEXT: [[AND16ri_:%[0-9]+]]:gr16 = AND16ri [[INSERT_SUBREG]], 1, implicit-def $eflags
+    ; X86-NEXT: $ax = COPY [[AND16ri_]]
     ; X86-NEXT: RET 0, implicit $ax
     ; X64-LABEL: name: test_zext_i1toi16
     ; X64: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; X64-NEXT: [[COPY1:%[0-9]+]]:gr8 = COPY [[COPY]].sub_8bit
     ; X64-NEXT: [[DEF:%[0-9]+]]:gr16 = IMPLICIT_DEF
     ; X64-NEXT: [[INSERT_SUBREG:%[0-9]+]]:gr16 = INSERT_SUBREG [[DEF]], [[COPY1]], %subreg.sub_8bit
-    ; X64-NEXT: [[AND16ri8_:%[0-9]+]]:gr16 = AND16ri8 [[INSERT_SUBREG]], 1, implicit-def $eflags
-    ; X64-NEXT: $ax = COPY [[AND16ri8_]]
+    ; X64-NEXT: [[AND16ri_:%[0-9]+]]:gr16 = AND16ri [[INSERT_SUBREG]], 1, implicit-def $eflags
+    ; X64-NEXT: $ax = COPY [[AND16ri_]]
     ; X64-NEXT: RET 0, implicit $ax
     %0(s32) = COPY $edi
     %1(s1) = G_TRUNC %0(s32)
     %2(s16) = G_ZEXT %1(s1)
     $ax = COPY %2(s16)
     RET 0, implicit $ax
 
 ...
body:             |
   bb.1 (%ir-block.0):
     liveins: $edi
 
     ; X86-LABEL: name: test_zext_i1
     ; X86: [[COPY:%[0-9]+]]:gr32_abcd = COPY $edi
     ; X86-NEXT: [[COPY1:%[0-9]+]]:gr8 = COPY [[COPY]].sub_8bit
     ; X86-NEXT: [[DEF:%[0-9]+]]:gr32 = IMPLICIT_DEF
     ; X86-NEXT: [[INSERT_SUBREG:%[0-9]+]]:gr32 = INSERT_SUBREG [[DEF]], [[COPY1]], %subreg.sub_8bit
-    ; X86-NEXT: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[INSERT_SUBREG]], 1, implicit-def $eflags
-    ; X86-NEXT: $eax = COPY [[AND32ri8_]]
+    ; X86-NEXT: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[INSERT_SUBREG]], 1, implicit-def $eflags
+    ; X86-NEXT: $eax = COPY [[AND32ri_]]
     ; X86-NEXT: RET 0, implicit $eax
     ; X64-LABEL: name: test_zext_i1
     ; X64: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; X64-NEXT: [[COPY1:%[0-9]+]]:gr8 = COPY [[COPY]].sub_8bit
     ; X64-NEXT: [[DEF:%[0-9]+]]:gr32 = IMPLICIT_DEF
     ; X64-NEXT: [[INSERT_SUBREG:%[0-9]+]]:gr32 = INSERT_SUBREG [[DEF]], [[COPY1]], %subreg.sub_8bit
-    ; X64-NEXT: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[INSERT_SUBREG]], 1, implicit-def $eflags
-    ; X64-NEXT: $eax = COPY [[AND32ri8_]]
+    ; X64-NEXT: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[INSERT_SUBREG]], 1, implicit-def $eflags
+    ; X64-NEXT: $eax = COPY [[AND32ri_]]
     ; X64-NEXT: RET 0, implicit $eax
     %0(s32) = COPY $edi
     %1(s1) = G_TRUNC %0(s32)
     %2(s32) = G_ZEXT %1(s1)
     $eax = COPY %2(s32)
     RET 0, implicit $eax
 
 ...

llvm/test/CodeGen/X86/GlobalISel/x86_64-select-zext.mir

 body:             |
   bb.1 (%ir-block.0):
     liveins: $edi
 
     ; CHECK-LABEL: name: zext_i1_to_i16
     ; CHECK: liveins: $edi
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; CHECK: [[COPY1:%[0-9]+]]:gr16 = COPY [[COPY]].sub_16bit
-    ; CHECK: [[AND16ri8_:%[0-9]+]]:gr16 = AND16ri8 [[COPY1]], 1, implicit-def $eflags
-    ; CHECK: $ax = COPY [[AND16ri8_]]
+    ; CHECK: [[AND16ri_:%[0-9]+]]:gr16 = AND16ri [[COPY1]], 1, implicit-def $eflags
+    ; CHECK: $ax = COPY [[AND16ri_]]
     ; CHECK: RET 0, implicit $ax
     %1:gpr(s32) = COPY $edi
     %3:gpr(s16) = G_CONSTANT i16 1
     %4:gpr(s16) = G_TRUNC %1(s32)
     %2:gpr(s16) = G_AND %4, %3
     $ax = COPY %2(s16)
     RET 0, implicit $ax
 
registers:
   - { id: 4, class: gpr }
 body:             |
   bb.1 (%ir-block.0):
     liveins: $edi
 
     ; CHECK-LABEL: name: zext_i1_to_i32
     ; CHECK: liveins: $edi
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $edi
-    ; CHECK: [[AND32ri8_:%[0-9]+]]:gr32 = AND32ri8 [[COPY]], 1, implicit-def $eflags
-    ; CHECK: $eax = COPY [[AND32ri8_]]
+    ; CHECK: [[AND32ri_:%[0-9]+]]:gr32 = AND32ri [[COPY]], 1, implicit-def $eflags
+    ; CHECK: $eax = COPY [[AND32ri_]]
     ; CHECK: RET 0, implicit $eax
     %1:gpr(s32) = COPY $edi
     %3:gpr(s32) = G_CONSTANT i32 1
     %4:gpr(s32) = COPY %1(s32)
     %2:gpr(s32) = G_AND %4, %3
     $eax = COPY %2(s32)
     RET 0, implicit $eax
 
body:             |
   bb.1 (%ir-block.0):
     liveins: $edi
 
     ; CHECK-LABEL: name: zext_i1_to_i64
     ; CHECK: liveins: $edi
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $edi
     ; CHECK: [[DEF:%[0-9]+]]:gr64 = IMPLICIT_DEF
     ; CHECK: [[INSERT_SUBREG:%[0-9]+]]:gr64 = INSERT_SUBREG [[DEF]], [[COPY]], %subreg.sub_32bit
-    ; CHECK: [[AND64ri8_:%[0-9]+]]:gr64 = AND64ri8 [[INSERT_SUBREG]], 1, implicit-def $eflags
-    ; CHECK: $rax = COPY [[AND64ri8_]]
+    ; CHECK: [[AND64ri32_:%[0-9]+]]:gr64 = AND64ri32 [[INSERT_SUBREG]], 1, implicit-def $eflags
+    ; CHECK: $rax = COPY [[AND64ri32_]]
     ; CHECK: RET 0, implicit $rax
     %1:gpr(s32) = COPY $edi
     %3:gpr(s64) = G_CONSTANT i64 1
     %4:gpr(s64) = G_ANYEXT %1(s32)
     %2:gpr(s64) = G_AND %4, %3
     $rax = COPY %2(s64)
     RET 0, implicit $rax
 

llvm/test/CodeGen/X86/avxvnni-combine.ll

; AVX512-NEXT:    retq
   %16 = tail call <4 x i32> @llvm.x86.avx512.vpdpwssd.128(<4 x i32> %14, <4 x i32> %8, <4 x i32> %15)
   %17 = bitcast <4 x i32> %16 to <2 x i64>
   ret <2 x i64> %17
 }
 
 declare <4 x i32> @llvm.x86.avx512.vpdpwssd.128(<4 x i32>, <4 x i32>, <4 x i32>) #1
 
 define <2 x i64> @foo_128(i32 %0, <2 x i64> %1, <2 x i64> %2, ptr %3) {
-; ADL-LABEL: foo_128:
-; ADL:       # %bb.0:
-; ADL-NEXT:    testl %edi, %edi
-; ADL-NEXT:    jle .LBB1_6
-; ADL-NEXT:  # %bb.1:
-; ADL-NEXT:    movl %edi, %edx
-; ADL-NEXT:    movl %edx, %eax
-; ADL-NEXT:    andl $3, %eax
-; ADL-NEXT:    cmpl $4, %edi
-; ADL-NEXT:    jae .LBB1_7
-; ADL-NEXT:  # %bb.2:
-; ADL-NEXT:    xorl %ecx, %ecx
-; ADL-NEXT:    jmp .LBB1_3
-; ADL-NEXT:  .LBB1_7:
-; ADL-NEXT:    andl $-4, %edx
-; ADL-NEXT:    leaq 48(%rsi), %rdi
-; ADL-NEXT:    xorl %ecx, %ecx
-; ADL-NEXT:    .p2align 4, 0x90
-; ADL-NEXT:  .LBB1_8: # =>This Inner Loop Header: Depth=1
-; ADL-NEXT:    {vex} vpdpwssd -48(%rdi), %xmm1, %xmm0
-; ADL-NEXT:    vpmaddwd -32(%rdi), %xmm1, %xmm2
-; ADL-NEXT:    vpmaddwd -16(%rdi), %xmm1, %xmm3
-; ADL-NEXT:    vpaddd %xmm2, %xmm0, %xmm0
-; ADL-NEXT:    vpaddd %xmm3, %xmm0, %xmm0
-; ADL-NEXT:    vpmaddwd (%rdi), %xmm1, %xmm2
-; ADL-NEXT:    vpaddd %xmm2, %xmm0, %xmm0
-; ADL-NEXT:    addq $4, %rcx
-; ADL-NEXT:    addq $64, %rdi
-; ADL-NEXT:    cmpq %rcx, %rdx
-; ADL-NEXT:    jne .LBB1_8
-; ADL-NEXT:  .LBB1_3:
-; ADL-NEXT:    testq %rax, %rax
-; ADL-NEXT:    je .LBB1_6
-; ADL-NEXT:  # %bb.4: # %.preheader
-; ADL-NEXT:    shlq $4, %rcx
-; ADL-NEXT:    addq %rcx, %rsi
-; ADL-NEXT:    shlq $4, %rax
-; ADL-NEXT:    xorl %ecx, %ecx
-; ADL-NEXT:    .p2align 4, 0x90
-; ADL-NEXT:  .LBB1_5: # =>This Inner Loop Header: Depth=1
-; ADL-NEXT:    {vex} vpdpwssd (%rsi,%rcx), %xmm1, %xmm0
-; ADL-NEXT:    addq $16, %rcx
-; ADL-NEXT:    cmpq %rcx, %rax
-; ADL-NEXT:    jne .LBB1_5
-; ADL-NEXT:  .LBB1_6:
-; ADL-NEXT:    retq
-;
-; SPR-LABEL: foo_128:
-; SPR:       # %bb.0:
-; SPR-NEXT:    testl %edi, %edi
-; SPR-NEXT:    jle .LBB1_6
-; SPR-NEXT:  # %bb.1:
-; SPR-NEXT:    movl %edi, %edx
-; SPR-NEXT:    movl %edx, %eax
-; SPR-NEXT:    andl $3, %eax
-; SPR-NEXT:    cmpl $4, %edi
-; SPR-NEXT:    jae .LBB1_7
-; SPR-NEXT:  # %bb.2:
-; SPR-NEXT:    xorl %ecx, %ecx
-; SPR-NEXT:    jmp .LBB1_3
-; SPR-NEXT:  .LBB1_7:
-; SPR-NEXT:    andl $-4, %edx
-; SPR-NEXT:    leaq 48(%rsi), %rdi
-; SPR-NEXT:    xorl %ecx, %ecx
-; SPR-NEXT:    .p2align 4, 0x90
-; SPR-NEXT:  .LBB1_8: # =>This Inner Loop Header: Depth=1
-; SPR-NEXT:    {vex} vpdpwssd -48(%rdi), %xmm1, %xmm0
-; SPR-NEXT:    vpmaddwd -32(%rdi), %xmm1, %xmm2
-; SPR-NEXT:    vpaddd %xmm2, %xmm0, %xmm0
-; SPR-NEXT:    vpmaddwd -16(%rdi), %xmm1, %xmm2
-; SPR-NEXT:    vpaddd %xmm2, %xmm0, %xmm0
-; SPR-NEXT:    vpmaddwd (%rdi), %xmm1, %xmm2
-; SPR-NEXT:    vpaddd %xmm2, %xmm0, %xmm0
-; SPR-NEXT:    addq $4, %rcx
-; SPR-NEXT:    addq $64, %rdi
-; SPR-NEXT:    cmpq %rcx, %rdx
-; SPR-NEXT:    jne .LBB1_8
-; SPR-NEXT:  .LBB1_3:
-; SPR-NEXT:    testq %rax, %rax
-; SPR-NEXT:    je .LBB1_6
-; SPR-NEXT:  # %bb.4: # %.preheader
-; SPR-NEXT:    shlq $4, %rcx
-; SPR-NEXT:    addq %rcx, %rsi
-; SPR-NEXT:    shlq $4, %rax
-; SPR-NEXT:    xorl %ecx, %ecx
-; SPR-NEXT:    .p2align 4, 0x90
-; SPR-NEXT:  .LBB1_5: # =>This Inner Loop Header: Depth=1
-; SPR-NEXT:    {vex} vpdpwssd (%rsi,%rcx), %xmm1, %xmm0
-; SPR-NEXT:    addq $16, %rcx
-; SPR-NEXT:    cmpq %rcx, %rax
-; SPR-NEXT:    jne .LBB1_5
-; SPR-NEXT:  .LBB1_6:
-; SPR-NEXT:    retq
+; AVX-LABEL: foo_128:
+; AVX:       # %bb.0:
+; AVX-NEXT:    testl %edi, %edi
+; AVX-NEXT:    jle .LBB1_6
+; AVX-NEXT:  # %bb.1:
+; AVX-NEXT:    movl %edi, %edx
+; AVX-NEXT:    movl %edx, %eax
+; AVX-NEXT:    andl $3, %eax
+; AVX-NEXT:    cmpl $4, %edi
+; AVX-NEXT:    jae .LBB1_7
+; AVX-NEXT:  # %bb.2:
+; AVX-NEXT:    xorl %ecx, %ecx
+; AVX-NEXT:    jmp .LBB1_3
+; AVX-NEXT:  .LBB1_7:
+; AVX-NEXT:    andl $-4, %edx
+; AVX-NEXT:    leaq 48(%rsi), %rdi
+; AVX-NEXT:    xorl %ecx, %ecx
+; AVX-NEXT:    .p2align 4, 0x90
+; AVX-NEXT:  .LBB1_8: # =>This Inner Loop Header: Depth=1
+; AVX-NEXT:    {vex} vpdpwssd -48(%rdi), %xmm1, %xmm0
+; AVX-NEXT:    vpmaddwd -32(%rdi), %xmm1, %xmm2
+; AVX-NEXT:    vpaddd %xmm2, %xmm0, %xmm0
+; AVX-NEXT:    vpmaddwd -16(%rdi), %xmm1, %xmm2
+; AVX-NEXT:    vpaddd %xmm2, %xmm0, %xmm0
+; AVX-NEXT:    vpmaddwd (%rdi), %xmm1, %xmm2
+; AVX-NEXT:    vpaddd %xmm2, %xmm0, %xmm0
+; AVX-NEXT:    addq $4, %rcx
+; AVX-NEXT:    addq $64, %rdi
+; AVX-NEXT:    cmpq %rcx, %rdx
+; AVX-NEXT:    jne .LBB1_8
+; AVX-NEXT:  .LBB1_3:
+; AVX-NEXT:    testq %rax, %rax
+; AVX-NEXT:    je .LBB1_6
+; AVX-NEXT:  # %bb.4: # %.preheader
+; AVX-NEXT:    shlq $4, %rcx
+; AVX-NEXT:    addq %rcx, %rsi
+; AVX-NEXT:    shlq $4, %rax
+; AVX-NEXT:    xorl %ecx, %ecx
+; AVX-NEXT:    .p2align 4, 0x90
+; AVX-NEXT:  .LBB1_5: # =>This Inner Loop Header: Depth=1
+; AVX-NEXT:    {vex} vpdpwssd (%rsi,%rcx), %xmm1, %xmm0
+; AVX-NEXT:    addq $16, %rcx
+; AVX-NEXT:    cmpq %rcx, %rax
+; AVX-NEXT:    jne .LBB1_5
+; AVX-NEXT:  .LBB1_6:
+; AVX-NEXT:    retq
 ;
 ; AVX512-LABEL: foo_128:
 ; AVX512:       # %bb.0:
 ; AVX512-NEXT:    testl %edi, %edi
 ; AVX512-NEXT:    jle .LBB1_6
 ; AVX512-NEXT:  # %bb.1:
 ; AVX512-NEXT:    movl %edi, %edx
 ; AVX512-NEXT:    movl %edx, %eax

 ;         __m256i a = p[i];
 ;         __m256i m = _mm256_madd_epi16 (b, a);
 ;         c = _mm256_add_epi32(m, c);
 ;     }
 ;     return c;
 ; }
 
 define <4 x i64> @foo_256(i32 %0, <4 x i64> %1, <4 x i64> %2, ptr %3) {
-; ADL-LABEL: foo_256:
-; ADL:       # %bb.0:
-; ADL-NEXT:    testl %edi, %edi
-; ADL-NEXT:    jle .LBB4_6
-; ADL-NEXT:  # %bb.1:
-; ADL-NEXT:    movl %edi, %edx
-; ADL-NEXT:    movl %edx, %eax
-; ADL-NEXT:    andl $3, %eax
-; ADL-NEXT:    cmpl $4, %edi
-; ADL-NEXT:    jae .LBB4_7
-; ADL-NEXT:  # %bb.2:
-; ADL-NEXT:    xorl %ecx, %ecx
-; ADL-NEXT:    jmp .LBB4_3
-; ADL-NEXT:  .LBB4_7:
-; ADL-NEXT:    andl $-4, %edx
-; ADL-NEXT:    leaq 96(%rsi), %rdi
-; ADL-NEXT:    xorl %ecx, %ecx
-; ADL-NEXT:    .p2align 4, 0x90
-; ADL-NEXT:  .LBB4_8: # =>This Inner Loop Header: Depth=1
-; ADL-NEXT:    {vex} vpdpwssd -96(%rdi), %ymm1, %ymm0
-; ADL-NEXT:    vpmaddwd -64(%rdi), %ymm1, %ymm2
-; ADL-NEXT:    vpmaddwd -32(%rdi), %ymm1, %ymm3
-; ADL-NEXT:    vpaddd %ymm2, %ymm0, %ymm0
-; ADL-NEXT:    vpaddd %ymm3, %ymm0, %ymm0
-; ADL-NEXT:    vpmaddwd (%rdi), %ymm1, %ymm2
-; ADL-NEXT:    vpaddd %ymm2, %ymm0, %ymm0
-; ADL-NEXT:    addq $4, %rcx
-; ADL-NEXT:    subq $-128, %rdi
-; ADL-NEXT:    cmpq %rcx, %rdx
-; ADL-NEXT:    jne .LBB4_8
-; ADL-NEXT:  .LBB4_3:
-; ADL-NEXT:    testq %rax, %rax
-; ADL-NEXT:    je .LBB4_6
-; ADL-NEXT:  # %bb.4: # %.preheader
-; ADL-NEXT:    shlq $5, %rcx
-; ADL-NEXT:    addq %rcx, %rsi
-; ADL-NEXT:    shlq $5, %rax
-; ADL-NEXT:    xorl %ecx, %ecx
-; ADL-NEXT:    .p2align 4, 0x90
-; ADL-NEXT:  .LBB4_5: # =>This Inner Loop Header: Depth=1
-; ADL-NEXT:    {vex} vpdpwssd (%rsi,%rcx), %ymm1, %ymm0
-; ADL-NEXT:    addq $32, %rcx
-; ADL-NEXT:    cmpq %rcx, %rax
-; ADL-NEXT:    jne .LBB4_5
-; ADL-NEXT:  .LBB4_6:
-; ADL-NEXT:    retq
-;
-; SPR-LABEL: foo_256:
-; SPR:       # %bb.0:
-; SPR-NEXT:    testl %edi, %edi
-; SPR-NEXT:    jle .LBB4_6
-; SPR-NEXT:  # %bb.1:
-; SPR-NEXT:    movl %edi, %edx
-; SPR-NEXT:    movl %edx, %eax
-; SPR-NEXT:    andl $3, %eax
-; SPR-NEXT:    cmpl $4, %edi
-; SPR-NEXT:    jae .LBB4_7
-; SPR-NEXT:  # %bb.2:
-; SPR-NEXT:    xorl %ecx, %ecx
-; SPR-NEXT:    jmp .LBB4_3
-; SPR-NEXT:  .LBB4_7:
-; SPR-NEXT:    andl $-4, %edx
-; SPR-NEXT:    leaq 96(%rsi), %rdi
-; SPR-NEXT:    xorl %ecx, %ecx
-; SPR-NEXT:    .p2align 4, 0x90
-; SPR-NEXT:  .LBB4_8: # =>This Inner Loop Header: Depth=1
-; SPR-NEXT:    {vex} vpdpwssd -96(%rdi), %ymm1, %ymm0
-; SPR-NEXT:    vpmaddwd -64(%rdi), %ymm1, %ymm2
-; SPR-NEXT:    vpaddd %ymm2, %ymm0, %ymm0
-; SPR-NEXT:    vpmaddwd -32(%rdi), %ymm1, %ymm2
-; SPR-NEXT:    vpaddd %ymm2, %ymm0, %ymm0
-; SPR-NEXT:    vpmaddwd (%rdi), %ymm1, %ymm2
-; SPR-NEXT:    vpaddd %ymm2, %ymm0, %ymm0
-; SPR-NEXT:    addq $4, %rcx
-; SPR-NEXT:    subq $-128, %rdi
-; SPR-NEXT:    cmpq %rcx, %rdx
-; SPR-NEXT:    jne .LBB4_8
-; SPR-NEXT:  .LBB4_3:
-; SPR-NEXT:    testq %rax, %rax
-; SPR-NEXT:    je .LBB4_6
-; SPR-NEXT:  # %bb.4: # %.preheader
-; SPR-NEXT:    shlq $5, %rcx
-; SPR-NEXT:    addq %rcx, %rsi
-; SPR-NEXT:    shlq $5, %rax
-; SPR-NEXT:    xorl %ecx, %ecx
-; SPR-NEXT:    .p2align 4, 0x90
-; SPR-NEXT:  .LBB4_5: # =>This Inner Loop Header: Depth=1
-; SPR-NEXT:    {vex} vpdpwssd (%rsi,%rcx), %ymm1, %ymm0
-; SPR-NEXT:    addq $32, %rcx
-; SPR-NEXT:    cmpq %rcx, %rax
-; SPR-NEXT:    jne .LBB4_5
-; SPR-NEXT:  .LBB4_6:
-; SPR-NEXT:    retq
+; AVX-LABEL: foo_256:
+; AVX:       # %bb.0:
+; AVX-NEXT:    testl %edi, %edi
+; AVX-NEXT:    jle .LBB4_6
+; AVX-NEXT:  # %bb.1:
+; AVX-NEXT:    movl %edi, %edx
+; AVX-NEXT:    movl %edx, %eax
+; AVX-NEXT:    andl $3, %eax
+; AVX-NEXT:    cmpl $4, %edi
+; AVX-NEXT:    jae .LBB4_7
+; AVX-NEXT:  # %bb.2:
+; AVX-NEXT:    xorl %ecx, %ecx
+; AVX-NEXT:    jmp .LBB4_3
+; AVX-NEXT:  .LBB4_7:
+; AVX-NEXT:    andl $-4, %edx
+; AVX-NEXT:    leaq 96(%rsi), %rdi
+; AVX-NEXT:    xorl %ecx, %ecx
+; AVX-NEXT:    .p2align 4, 0x90
+; AVX-NEXT:  .LBB4_8: # =>This Inner Loop Header: Depth=1
+; AVX-NEXT:    {vex} vpdpwssd -96(%rdi), %ymm1, %ymm0
+; AVX-NEXT:    vpmaddwd -64(%rdi), %ymm1, %ymm2
+; AVX-NEXT:    vpaddd %ymm2, %ymm0, %ymm0
+; AVX-NEXT:    vpmaddwd -32(%rdi), %ymm1, %ymm2
+; AVX-NEXT:    vpaddd %ymm2, %ymm0, %ymm0
+; AVX-NEXT:    vpmaddwd (%rdi), %ymm1, %ymm2
+; AVX-NEXT:    vpaddd %ymm2, %ymm0, %ymm0
+; AVX-NEXT:    addq $4, %rcx
+; AVX-NEXT:    subq $-128, %rdi
+; AVX-NEXT:    cmpq %rcx, %rdx
+; AVX-NEXT:    jne .LBB4_8
+; AVX-NEXT:  .LBB4_3:
+; AVX-NEXT:    testq %rax, %rax
+; AVX-NEXT:    je .LBB4_6
+; AVX-NEXT:  # %bb.4: # %.preheader
+; AVX-NEXT:    shlq $5, %rcx
+; AVX-NEXT:    addq %rcx, %rsi
+; AVX-NEXT:    shlq $5, %rax
+; AVX-NEXT:    xorl %ecx, %ecx
+; AVX-NEXT:    .p2align 4, 0x90
+; AVX-NEXT:  .LBB4_5: # =>This Inner Loop Header: Depth=1
+; AVX-NEXT:    {vex} vpdpwssd (%rsi,%rcx), %ymm1, %ymm0
+; AVX-NEXT:    addq $32, %rcx
+; AVX-NEXT:    cmpq %rcx, %rax
+; AVX-NEXT:    jne .LBB4_5
+; AVX-NEXT:  .LBB4_6:
+; AVX-NEXT:    retq
 ;
 ; AVX512-LABEL: foo_256:
 ; AVX512:       # %bb.0:
 ; AVX512-NEXT:    testl %edi, %edi
 ; AVX512-NEXT:    jle .LBB4_6
 ; AVX512-NEXT:  # %bb.1:
 ; AVX512-NEXT:    movl %edi, %edx
 ; AVX512-NEXT:    movl %edx, %eax

llvm/test/CodeGen/X86/cfi-xmm.ll

 ; CHECK:   .cfi_offset %xmm15, -32
 ; CHECK:   movaps  (%rsp), %xmm10
 ; CHECK:   movaps  16(%rsp), %xmm15
 ; CHECK:   addq    $40, %rsp
 ; CHECK:   retq
 ; CHECK:   .cfi_endproc
 
 ; PEI-LABEL: name: _Z1fv
-; PEI:         $rsp = frame-setup SUB64ri8 $rsp, 40, implicit-def dead $eflags
+; PEI:         $rsp = frame-setup SUB64ri32 $rsp, 40, implicit-def dead $eflags
 ; PEI-NEXT:    frame-setup MOVAPSmr $rsp, 1, $noreg, 16, $noreg, killed $xmm15 :: (store (s128) into %fixed-stack.1)
 ; PEI-NEXT:    frame-setup MOVAPSmr $rsp, 1, $noreg, 0, $noreg, killed $xmm10 :: (store (s128) into %fixed-stack.0)
 ; PEI-NEXT:    frame-setup CFI_INSTRUCTION def_cfa_offset 48
 ; PEI-NEXT:    {{^ +}}CFI_INSTRUCTION offset $xmm10, -48
 ; PEI-NEXT:    {{^ +}}CFI_INSTRUCTION offset $xmm15, -32
 ; PEI-NEXT:    INLINEASM {{.*}}
 ; PEI-NEXT:    $xmm10 = MOVAPSrm $rsp, 1, $noreg, 0, $noreg :: (load (s128) from %fixed-stack.0)
 ; PEI-NEXT:    $xmm15 = MOVAPSrm $rsp, 1, $noreg, 16, $noreg :: (load (s128) from %fixed-stack.1)
-; PEI-NEXT:    $rsp = frame-destroy ADD64ri8 $rsp, 40, implicit-def dead $eflags
+; PEI-NEXT:    $rsp = frame-destroy ADD64ri32 $rsp, 40, implicit-def dead $eflags
 ; PEI-NEXT:    RET 0

llvm/test/CodeGen/X86/extend-set-cc-uses-dbg.ll

 ; RUN: llc < %s -O0 -stop-after=livedebugvalues -o - | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.13.0"
 
 define void @foo(ptr %p) !dbg !4 {
 bb:
   %tmp = load i32, ptr %p, align 4, !dbg !7
   ; CHECK: $eax = MOV32rm killed {{.*}} $rdi, {{.*}} debug-location !7 :: (load (s32) from %ir.p)
   ; CHECK-NEXT: $rax = KILL killed renamable $eax, debug-location !7
   ; CHECK-NEXT: MOV64mr $rsp, 1, $noreg, -8, $noreg, $rax :: (store (s64) into %stack.0)
-  ; CHECK-NEXT: SUB64ri8 renamable $rax, 3, implicit-def $eflags, debug-location !7
+  ; CHECK-NEXT: SUB64ri32 renamable $rax, 3, implicit-def $eflags, debug-location !7
 
   switch i32 %tmp, label %bb7 [
     i32 0, label %bb1
     i32 1, label %bb2
     i32 2, label %bb3
     i32 3, label %bb4
   ], !dbg !8
 

llvm/test/CodeGen/X86/fast-regalloc-live-out-debug-values.mir

body:             |
   ; CHECK:   successors: %bb.1(0x80000000)
   ; CHECK:   liveins: $edi, $rbx
   ; CHECK:   frame-setup PUSH64r killed $rbp, implicit-def $rsp, implicit $rsp
   ; CHECK:   CFI_INSTRUCTION def_cfa_offset 16
   ; CHECK:   CFI_INSTRUCTION offset $rbp, -16
   ; CHECK:   $rbp = frame-setup MOV64rr $rsp
   ; CHECK:   CFI_INSTRUCTION def_cfa_register $rbp
   ; CHECK:   frame-setup PUSH64r killed $rbx, implicit-def $rsp, implicit $rsp, debug-location !13
-  ; CHECK:   $rsp = frame-setup SUB64ri8 $rsp, 40, implicit-def dead $eflags
+  ; CHECK:   $rsp = frame-setup SUB64ri32 $rsp, 40, implicit-def dead $eflags
   ; CHECK:   CFI_INSTRUCTION offset $rbx, -24
   ; CHECK:   renamable $eax = MOV32rm $rbp, 1, $noreg, -12, $noreg, debug-location !13 :: (dereferenceable load (s32) from %ir.a.addr)
   ; CHECK:   renamable $rax = KILL killed renamable $eax, debug-location !13
   ; CHECK:   $rcx = MOV64rr $rsp, debug-location !14
   ; CHECK:   MOV64mr $rbp, 1, $noreg, -40, $noreg, $rcx :: (store (s64) into %stack.4)
   ; CHECK:   DBG_VALUE $rbp, 0, !18, !DIExpression(DW_OP_constu, 40, DW_OP_minus, DW_OP_deref), debug-location !22
   ; CHECK:   $rsp = MOV64rr $rcx, debug-location !14
   ; CHECK:   MOV64mr $rbp, 1, $noreg, -24, $noreg, killed renamable $rax, debug-location !14 :: (store (s64) into %ir.__vla_expr0)

llvm/test/CodeGen/X86/leaFixup32.mir

 # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
 # RUN: llc -run-pass x86-fixup-LEAs -mtriple=i386 -verify-machineinstrs -mcpu=corei7-avx -o - %s | FileCheck %s
 --- |
   ; ModuleID = 'test/CodeGen/X86/fixup-lea.ll'
   source_filename = "test/CodeGen/X86/fixup-lea.ll"
   target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
   target triple = "i386"
   ;generated using: llc -stop-after x86-pad-short-functions fixup-lea.ll > leaFinxup32.mir
 
   ;test2add_32: 3 operands LEA32r that can be replaced with 2 add instructions
-  ; where ADD32ri8 is chosen
+  ; where ADD32ri is chosen
   define i32 @test2add_32() {
     ret i32 0
   }
 
   ;test2add_ebp_32: 3 operands LEA32r that can be replaced with 2 add instructions
   ; where the base is rbp/r13/ebp register
   define i32 @test2add_ebp_32() {
     ret i32 0
frameInfo:
   hasMustTailInVarArgFunc: false
 body:             |
   bb.0 (%ir-block.0):
     liveins: $eax, $ebp
 
     ; CHECK-LABEL: name: test2add_32
     ; CHECK: liveins: $eax, $ebp
     ; CHECK: $eax = ADD32rr $eax, $ebp, implicit-def $eflags
-    ; CHECK: $eax = ADD32ri8 $eax, -5, implicit-def $eflags
+    ; CHECK: $eax = ADD32ri $eax, -5, implicit-def $eflags
     ; CHECK: RET64 $eax
     $eax = LEA32r killed $eax, 1, killed $ebp, -5, $noreg
     RET64 $eax
 
 ...
 ---
 name:            test2add_ebp_32
 alignment:       16
frameInfo:
   hasMustTailInVarArgFunc: false
 body:             |
   bb.0 (%ir-block.0):
     liveins: $eax, $ebp
 
     ; CHECK-LABEL: name: test2add_ebp_32
     ; CHECK: liveins: $eax, $ebp
     ; CHECK: $ebp = ADD32rr $ebp, $eax, implicit-def $eflags
-    ; CHECK: $ebp = ADD32ri8 $ebp, -5, implicit-def $eflags
+    ; CHECK: $ebp = ADD32ri $ebp, -5, implicit-def $eflags
     ; CHECK: RET64 $ebp
     $ebp = LEA32r killed $ebp, 1, killed $eax, -5, $noreg
     RET64 $ebp
 
 ...
 ---
 name:            test1add_ebp_32
 alignment:       16
frameInfo:
   hasMustTailInVarArgFunc: false
 body:             |
   bb.0 (%ir-block.0):
     liveins: $eax, $ebp, $esi
 
     ; CHECK-LABEL: name: testleaadd_32
     ; CHECK: liveins: $eax, $ebp, $esi
     ; CHECK: $ebx = LEA32r killed $eax, 1, killed $ebp, 0, $noreg
-    ; CHECK: $ebx = ADD32ri8 $ebx, -5, implicit-def $eflags
+    ; CHECK: $ebx = ADD32ri $ebx, -5, implicit-def $eflags
     ; CHECK: RET64 $ebx
     $ebx = LEA32r killed $eax, 1, killed $ebp, -5, $noreg
     RET64 $ebx
 
 ...
 ---
 name:            testleaadd_ebp_32
 alignment:       16
frameInfo:
   hasMustTailInVarArgFunc: false
 body:             |
   bb.0 (%ir-block.0):
     liveins: $eax, $ebp
 
     ; CHECK-LABEL: name: testleaadd_ebp_32
     ; CHECK: liveins: $eax, $ebp
     ; CHECK: $ebx = LEA32r killed $eax, 1, killed $ebp, 0, $noreg
-    ; CHECK: $ebx = ADD32ri8 $ebx, -5, implicit-def $eflags
+    ; CHECK: $ebx = ADD32ri $ebx, -5, implicit-def $eflags
     ; CHECK: RET64 $ebx
     $ebx = LEA32r killed $ebp, 1, killed $eax, -5, $noreg
     RET64 $ebx
 
 ...
 ---
 name:            test1lea_ebp_32
 alignment:       16
body:             |
   ; CHECK:   liveins: $eax, $ebp, $ebx
   ; CHECK:   CMP32rr $eax, killed $ebx, implicit-def $eflags
   ; CHECK:   $ebx = LEA32r killed $eax, 4, killed $eax, 5, $noreg
   ; CHECK:   JCC_1 %bb.1, 4, implicit $eflags
   ; CHECK:   RET64 $ebx
   ; CHECK: bb.1:
   ; CHECK:   liveins: $eax, $ebp, $ebx
   ; CHECK:   $ebp = LEA32r killed $ebx, 4, killed $ebx, 0, $noreg
-  ; CHECK:   $ebp = ADD32ri8 $ebp, 5, implicit-def $eflags
+  ; CHECK:   $ebp = ADD32ri $ebp, 5, implicit-def $eflags
   ; CHECK:   RET64 $ebp
   bb.0 (%ir-block.0):
     liveins: $eax, $ebp, $ebx
 
     CMP32rr   $eax, killed $ebx, implicit-def $eflags
     $ebx = LEA32r killed $eax, 4, killed $eax, 5, $noreg
     JCC_1 %bb.1, 4, implicit $eflags
     RET64 $ebx

llvm/test/CodeGen/X86/leaFixup64.mir

frameInfo:
   hasMustTailInVarArgFunc: false
 body:             |
   bb.0 (%ir-block.0):
     liveins: $rax, $rbp
 
     ; CHECK-LABEL: name: testleaadd_64_32_1
     ; CHECK: liveins: $rax, $rbp
     ; CHECK: $eax = ADD32rr $eax, $ebp, implicit-def $eflags, implicit $rax, implicit $rbp
-    ; CHECK: $eax = ADD32ri8 $eax, -5, implicit-def $eflags
+    ; CHECK: $eax = ADD32ri $eax, -5, implicit-def $eflags
     ; CHECK: RET64 $eax
     $eax = LEA64_32r killed $rax, 1, killed $rbp, -5, $noreg
     RET64 $eax
 
 ...
 ---
 name:            testleaadd_rbp_64_32_1
 alignment:       16
frameInfo:
   hasMustTailInVarArgFunc: false
 body:             |
   bb.0 (%ir-block.0):
     liveins: $rax, $rbp
 
     ; CHECK-LABEL: name: testleaadd_rbp_64_32_1
     ; CHECK: liveins: $rax, $rbp
     ; CHECK: $ebp = ADD32rr $ebp, $eax, implicit-def $eflags, implicit $rbp, implicit $rax
-    ; CHECK: $ebp = ADD32ri8 $ebp, -5, implicit-def $eflags
+    ; CHECK: $ebp = ADD32ri $ebp, -5, implicit-def $eflags
     ; CHECK: RET64 $ebp
     $ebp = LEA64_32r killed $rbp, 1, killed $rax, -5, $noreg
     RET64 $ebp
 
 ...
 ---
 name:            test1lea_rbp_64_32_1
 alignment:       16
frameInfo:
   hasMustTailInVarArgFunc: false
 body:             |
   bb.0 (%ir-block.0):
     liveins: $rax, $rbp
 
     ; CHECK-LABEL: name: test2add_64
     ; CHECK: liveins: $rax, $rbp
     ; CHECK: $rax = ADD64rr $rax, $rbp, implicit-def $eflags
-    ; CHECK: $rax = ADD64ri8 $rax, -5, implicit-def $eflags
+    ; CHECK: $rax = ADD64ri32 $rax, -5, implicit-def $eflags
     ; CHECK: RET64 $eax
     $rax = LEA64r killed $rax, 1, killed $rbp, -5, $noreg
     RET64 $eax
 
 ...
 ---
 name:            test2add_rbp_64
 alignment:       16
frameInfo:
   hasMustTailInVarArgFunc: false
 body:             |
   bb.0 (%ir-block.0):
     liveins: $rax, $rbp
 
     ; CHECK-LABEL: name: test2add_rbp_64
     ; CHECK: liveins: $rax, $rbp
     ; CHECK: $rbp = ADD64rr $rbp, $rax, implicit-def $eflags
-    ; CHECK: $rbp = ADD64ri8 $rbp, -5, implicit-def $eflags
+    ; CHECK: $rbp = ADD64ri32 $rbp, -5, implicit-def $eflags
     ; CHECK: RET64 $ebp
     $rbp = LEA64r killed $rbp, 1, killed $rax, -5, $noreg
     RET64 $ebp
 
 ...
 ---
 name:            test1add_rbp_64
 alignment:       16
frameInfo:
   hasMustTailInVarArgFunc: false
 body:             |
   bb.0 (%ir-block.0):
     liveins: $rax, $rbp
 
     ; CHECK-LABEL: name: testleaadd_64_32
     ; CHECK: liveins: $rax, $rbp
     ; CHECK: $ebx = LEA64_32r killed $rax, 1, killed $rbp, 0, $noreg
-    ; CHECK: $ebx = ADD32ri8 $ebx, -5, implicit-def $eflags
+    ; CHECK: $ebx = ADD32ri $ebx, -5, implicit-def $eflags
     ; CHECK: RET64 $ebx
     $ebx = LEA64_32r killed $rax, 1, killed $rbp, -5, $noreg
     RET64 $ebx
 
 ...
 ---
 name:            testleaadd_rbp_64_32
 alignment:       16
frameInfo:
   hasMustTailInVarArgFunc: false
 body:             |
   bb.0 (%ir-block.0):
     liveins: $rax, $rbp
 
     ; CHECK-LABEL: name: testleaadd_rbp_64_32
     ; CHECK: liveins: $rax, $rbp
     ; CHECK: $ebx = LEA64_32r killed $rax, 1, killed $rbp, 0, $noreg
-    ; CHECK: $ebx = ADD32ri8 $ebx, -5, implicit-def $eflags
+    ; CHECK: $ebx = ADD32ri $ebx, -5, implicit-def $eflags
     ; CHECK: RET64 $ebx
     $ebx = LEA64_32r killed $rbp, 1, killed $rax, -5, $noreg
     RET64 $ebx
 
 ...
 ---
 name:            test1lea_rbp_64_32
 alignment:       16
frameInfo:
   hasMustTailInVarArgFunc: false
 body:             |
   bb.0 (%ir-block.0):
     liveins: $rax, $rbp
 
     ; CHECK-LABEL: name: testleaadd_64
     ; CHECK: liveins: $rax, $rbp
     ; CHECK: $rbx = LEA64r killed $rax, 1, killed $rbp, 0, $noreg
-    ; CHECK: $rbx = ADD64ri8 $rbx, -5, implicit-def $eflags
+    ; CHECK: $rbx = ADD64ri32 $rbx, -5, implicit-def $eflags
     ; CHECK: RET64 $ebx
     $rbx = LEA64r killed $rax, 1, killed $rbp, -5, $noreg
     RET64 $ebx
 
 ...
 ---
 name:            testleaadd_rbp_64
 alignment:       16
frameInfo:
   hasMustTailInVarArgFunc: false
 body:             |
   bb.0 (%ir-block.0):
     liveins: $rax, $rbp
 
     ; CHECK-LABEL: name: testleaadd_rbp_64
     ; CHECK: liveins: $rax, $rbp
     ; CHECK: $rbx = LEA64r killed $rax, 1, killed $rbp, 0, $noreg
-    ; CHECK: $rbx = ADD64ri8 $rbx, -5, implicit-def $eflags
+    ; CHECK: $rbx = ADD64ri32 $rbx, -5, implicit-def $eflags
     ; CHECK: RET64 $ebx
     $rbx = LEA64r killed $rbp, 1, killed $rax, -5, $noreg
     RET64 $ebx
 
 ...
 ---
 name:            test1lea_rbp_64
 alignment:       16
body:             |
   ; CHECK:   liveins: $rax, $rbp, $rbx
   ; CHECK:   CMP64rr $rax, killed $rbx, implicit-def $eflags
   ; CHECK:   $rbx = LEA64r killed $rax, 4, killed $rax, 5, $noreg
   ; CHECK:   JCC_1 %bb.1, 4, implicit $eflags
   ; CHECK:   RET64 $ebx
   ; CHECK: bb.1:
   ; CHECK:   liveins: $rax, $rbp, $rbx
   ; CHECK:   $rbp = LEA64r killed $rbx, 4, killed $rbx, 0, $noreg
-  ; CHECK:   $rbp = ADD64ri8 $rbp, 5, implicit-def $eflags
+  ; CHECK:   $rbp = ADD64ri32 $rbp, 5, implicit-def $eflags
   ; CHECK:   RET64 $ebp
   bb.0 (%ir-block.0):
     liveins: $rax, $rbp, $rbx
 
     CMP64rr   $rax, killed $rbx, implicit-def $eflags
     $rbx = LEA64r killed $rax, 4, killed $rax, 5, $noreg
     JCC_1 %bb.1, 4, implicit $eflags
     RET64 $ebx
body:             |
   ; CHECK:   liveins: $rax, $rbp, $rbx
   ; CHECK:   CMP64rr $rax, killed $rbx, implicit-def $eflags
   ; CHECK:   $ebx = LEA64_32r killed $rax, 4, killed $rax, 5, $noreg
   ; CHECK:   JCC_1 %bb.1, 4, implicit $eflags
   ; CHECK:   RET64 $ebx
   ; CHECK: bb.1:
   ; CHECK:   liveins: $rax, $rbp, $rbx
   ; CHECK:   $ebp = LEA64_32r killed $rbx, 4, killed $rbx, 0, $noreg
-  ; CHECK:   $ebp = ADD32ri8 $ebp, 5, implicit-def $eflags
+  ; CHECK:   $ebp = ADD32ri $ebp, 5, implicit-def $eflags
   ; CHECK:   RET64 $ebp
   bb.0 (%ir-block.0):
     liveins: $rax, $rbp, $rbx
 
     CMP64rr   $rax, killed $rbx, implicit-def $eflags
     $ebx = LEA64_32r killed $rax, 4, killed $rax, 5, $noreg
     JCC_1 %bb.1, 4, implicit $eflags
     RET64 $ebx

llvm/test/CodeGen/X86/limit-split-cost.mir

bb.0.entry:
     %6:gr64 = MOV64rm $rip, 1, $noreg, target-flags(x86-gotpcrel) @m, $noreg :: (load (s64) from got)
     %4:gr64 = LEA64r $rip, 1, $noreg, @.str.1, $noreg
     %3:gr64 = LEA64r $rip, 1, $noreg, @.str, $noreg
   
   bb.1.do.body:
     successors: %bb.6(0x20000000), %bb.2(0x60000000)
   
     INLINEASM &"", 1, 12, implicit-def dead early-clobber $r10, 12, implicit-def dead early-clobber $r11, 12, implicit-def dead early-clobber $r12, 12, implicit-def dead early-clobber $r13, 12, implicit-def dead early-clobber $r14, 12, implicit-def dead early-clobber $r15, 12, implicit-def dead early-clobber $eflags, !3
-    CMP32ri8 %0, 2, implicit-def $eflags
+    CMP32ri %0, 2, implicit-def $eflags
     JCC_1 %bb.6, 4, implicit killed $eflags
     JMP_1 %bb.2
   
   bb.2.do.body:
     successors: %bb.5(0x2aaaaaab), %bb.3(0x55555555)
   
-    CMP32ri8 %0, 1, implicit-def $eflags
+    CMP32ri %0, 1, implicit-def $eflags
     JCC_1 %bb.5, 4, implicit killed $eflags
     JMP_1 %bb.3
   
   bb.3.do.body:
     successors: %bb.4, %bb.7
   
     TEST32rr %0, %0, implicit-def $eflags
     JCC_1 %bb.7, 5, implicit killed $eflags
bb.6.sw.bb2:
     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
     $rdi = COPY %5
     CALL64pcrel32 target-flags(x86-plt) @_Z3gooPKc, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp
     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
   
   bb.7.do.cond:
     successors: %bb.8(0x04000000), %bb.1(0x7c000000)
   
-    CMP32mi8 %6, 1, $noreg, 0, $noreg, 5, implicit-def $eflags :: (dereferenceable load (s32) from @m, !tbaa !4)
+    CMP32mi %6, 1, $noreg, 0, $noreg, 5, implicit-def $eflags :: (dereferenceable load (s32) from @m, !tbaa !4)
     JCC_1 %bb.1, 5, implicit killed $eflags
     JMP_1 %bb.8
   
   bb.8.do.end:
     RET 0
 
 ...

llvm/test/CodeGen/X86/machinesink-debug-inv-0.mir

body:             |
   ; CHECK-NEXT:   [[MOV64rm1:%[0-9]+]]:gr64 = MOV64rm $rip, 1, $noreg, target-flags(x86-gotpcrel) @e, $noreg :: (load (s64) from got)
   ; CHECK-NEXT:   [[MOV64rm2:%[0-9]+]]:gr64 = MOV64rm $rip, 1, $noreg, target-flags(x86-gotpcrel) @f, $noreg :: (load (s64) from got)
   ; CHECK-NEXT:   [[MOV64rm3:%[0-9]+]]:gr64 = MOV64rm $rip, 1, $noreg, target-flags(x86-gotpcrel) @g, $noreg :: (load (s64) from got)
   ; CHECK-NEXT: {{  $}}
   ; CHECK-NEXT: bb.1.for.body:
   ; CHECK-NEXT:   successors: %bb.3(0x30000000), %bb.2(0x50000000)
   ; CHECK-NEXT: {{  $}}
   ; CHECK-NEXT:   [[PHI:%[0-9]+]]:gr8 = PHI [[MOV8ri]], %bb.0, %8, %bb.3
-  ; CHECK-NEXT:   CMP32mi8 [[MOV64rm]], 1, $noreg, 0, $noreg, 0, implicit-def $eflags :: (dereferenceable load (s32) from @d, align 1)
+  ; CHECK-NEXT:   CMP32mi [[MOV64rm]], 1, $noreg, 0, $noreg, 0, implicit-def $eflags :: (dereferenceable load (s32) from @d, align 1)
   ; CHECK-NEXT:   JCC_1 %bb.3, 4, implicit $eflags
   ; CHECK-NEXT:   JMP_1 %bb.2
   ; CHECK-NEXT: {{  $}}
   ; CHECK-NEXT: bb.2.for.cond13.preheader.preheader.i:
   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
   ; CHECK-NEXT: {{  $}}
   ; CHECK-NEXT:   [[MOV32rm:%[0-9]+]]:gr32 = MOV32rm [[MOV64rm2]], 1, $noreg, 0, $noreg :: (dereferenceable load (s32) from @f, align 1)
   ; CHECK-NEXT:   MOV32mr [[MOV64rm3]], 1, $noreg, 0, $noreg, killed [[MOV32rm]] :: (store (s32) into @g, align 1)
bb.0.entry:
     %4:gr64 = MOV64rm $rip, 1, $noreg, target-flags(x86-gotpcrel) @e, $noreg :: (load (s64) from got)
     %5:gr64 = MOV64rm $rip, 1, $noreg, target-flags(x86-gotpcrel) @f, $noreg :: (load (s64) from got)
     %7:gr64 = MOV64rm $rip, 1, $noreg, target-flags(x86-gotpcrel) @g, $noreg :: (load (s64) from got)
 
   bb.1.for.body:
     successors: %bb.3(0x30000000), %bb.2(0x50000000)
 
     %0:gr8 = PHI %2, %bb.0, %8, %bb.3
-    CMP32mi8 %3, 1, $noreg, 0, $noreg, 0, implicit-def $eflags :: (dereferenceable load (s32) from @d, align 1)
+    CMP32mi %3, 1, $noreg, 0, $noreg, 0, implicit-def $eflags :: (dereferenceable load (s32) from @d, align 1)
     %1:gr32 = MOV32rm %4, 1, $noreg, 0, $noreg :: (dereferenceable load (s32) from @e, align 1)
     JCC_1 %bb.3, 4, implicit $eflags
     JMP_1 %bb.2
 
   bb.2.for.cond13.preheader.preheader.i:
     %6:gr32 = MOV32rm %5, 1, $noreg, 0, $noreg :: (dereferenceable load (s32) from @f, align 1)
     MOV32mr %7, 1, $noreg, 0, $noreg, killed %6 :: (store (s32) into @g, align 1)
 

llvm/test/CodeGen/X86/optimize-compare.mir

bb.0:
     ; CHECK-LABEL: name: opt_zerocmp_1
     ; CHECK: [[COPY:%[0-9]+]]:gr64 = COPY $rsi
     ; CHECK-NEXT: [[DEC64r:%[0-9]+]]:gr64 = DEC64r [[COPY]], implicit-def $eflags
     ; CHECK-NEXT: [[LEA64r:%[0-9]+]]:gr64 = LEA64r [[DEC64r]], 5, $noreg, 12, $noreg
     ; CHECK-NEXT: $al = SETCCr 4, implicit $eflags
     %0:gr64 = COPY $rsi
     %1:gr64 = DEC64r %0, implicit-def $eflags
     ; CMP should be removed.
-    CMP64ri8 %1, 0, implicit-def $eflags
+    CMP64ri32 %1, 0, implicit-def $eflags
     %2:gr64 = LEA64r %1, 5, $noreg, 12, $noreg
     $al = SETCCr 4, implicit $eflags
 ...
 ---
 name: opt_multiple_blocks
 tracksRegLiveness: true
 body: |
   ; CHECK-LABEL: name: opt_multiple_blocks

 ...
 ---
 name: opt_redundant_flags_cmp_cmp_2
 body: |
   bb.0:
     ; CHECK-LABEL: name: opt_redundant_flags_cmp_cmp_2
     ; CHECK: [[COPY:%[0-9]+]]:gr64 = COPY $rsi
     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:gr64 = COPY $rdi
-    ; CHECK-NEXT: CMP64ri8 [[COPY]], 15, implicit-def $eflags
+    ; CHECK-NEXT: CMP64ri32 [[COPY]], 15, implicit-def $eflags
     ; CHECK-NEXT: $cl = SETCCr 2, implicit $eflags
     ; CHECK-NEXT: $bl = SETCCr 2, implicit $eflags
     %0:gr64 = COPY $rsi
     %1:gr64 = COPY $rdi
-    CMP64ri8 %0, 15, implicit-def $eflags
+    CMP64ri32 %0, 15, implicit-def $eflags
     $cl = SETCCr 2, implicit $eflags
     ; 2nd CMP should be removed.
-    CMP64ri8 %0, 15, implicit-def $eflags
+    CMP64ri32 %0, 15, implicit-def $eflags
     $bl = SETCCr 2, implicit $eflags
 ...
 ---
 name: opt_redundant_flags_test_test
 body: |
   bb.0:
     ; CHECK-LABEL: name: opt_redundant_flags_test_test
     ; CHECK: [[COPY:%[0-9]+]]:gr16 = COPY $ax
bb.0:
     $bl = SETCCr 2, implicit $eflags
 ...
 ---
 name: opt_redundant_flags_cmp_test
 body: |
   bb.0:
     ; CHECK-LABEL: name: opt_redundant_flags_cmp_test
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $esi
-    ; CHECK-NEXT: CMP32ri8 [[COPY]], 0, implicit-def $eflags
+    ; CHECK-NEXT: CMP32ri [[COPY]], 0, implicit-def $eflags
     ; CHECK-NEXT: $cl = SETCCr 2, implicit $eflags
     ; CHECK-NEXT: $bl = SETCCr 2, implicit $eflags
     %0:gr32 = COPY $esi
-    CMP32ri8 %0, 0, implicit-def $eflags
+    CMP32ri %0, 0, implicit-def $eflags
     $cl = SETCCr 2, implicit $eflags
     ; TEST should be removed
     TEST32rr %0, %0, implicit-def $eflags
     $bl = SETCCr 2, implicit $eflags
 ...
 ---
 name: opt_redundant_flags_test_cmp
 body: |
   bb.0:
     ; CHECK-LABEL: name: opt_redundant_flags_test_cmp
     ; CHECK: [[COPY:%[0-9]+]]:gr32 = COPY $esi
     ; CHECK-NEXT: TEST32rr [[COPY]], [[COPY]], implicit-def $eflags
     ; CHECK-NEXT: $cl = SETCCr 2, implicit $eflags
     ; CHECK-NEXT: $bl = SETCCr 2, implicit $eflags
     %0:gr32 = COPY $esi
     TEST32rr %0, %0, implicit-def $eflags
     $cl = SETCCr 2, implicit $eflags
     ; TEST should be removed
-    CMP32ri8 %0, 0, implicit-def $eflags
+    CMP32ri %0, 0, implicit-def $eflags
     $bl = SETCCr 2, implicit $eflags
 ...
 ---
 name: opt_redundant_flags_cmp_addr
 stack:
   - { id: 0, size: 4, alignment: 4 }
 body: |
   bb.0:
bb.0:
     $cl = SETCCr 3, implicit $eflags
 ...
 ---
 name: opt_redundant_flags_adjusted_imm_0
 body: |
   bb.0:
     ; CHECK-LABEL: name: opt_redundant_flags_adjusted_imm_0
     ; CHECK: [[COPY:%[0-9]+]]:gr64 = COPY $rsi
-    ; CHECK-NEXT: CMP64ri8 [[COPY]], 1, implicit-def $eflags
+    ; CHECK-NEXT: CMP64ri32 [[COPY]], 1, implicit-def $eflags
     ; CHECK-NEXT: $cl = SETCCr 4, implicit $eflags
     ; CHECK-NEXT: $bl = SETCCr 15, implicit $eflags
     ; CHECK-NEXT: $bl = SETCCr 7, implicit $eflags
     ; CHECK-NEXT: $bl = SETCCr 14, implicit $eflags
     ; CHECK-NEXT: $bl = SETCCr 6, implicit $eflags
     %0:gr64 = COPY $rsi
     ; CMP+SETCC   %0 == 1
-    CMP64ri8 %0, 1, implicit-def $eflags
+    CMP64ri32 %0, 1, implicit-def $eflags
     $cl = SETCCr 4, implicit $eflags
     ; CMP+SETCC   %0 >= 2; CMP can be removed.
-    CMP64ri8 %0, 2, implicit-def $eflags
+    CMP64ri32 %0, 2, implicit-def $eflags
     ; %0 >=s 2  -->  %0 >s 1
     $bl = SETCCr 13, implicit $eflags
     ; %0 >=u 2  -->  %0 >u 1
     $bl = SETCCr 3, implicit $eflags
     ; %0 <s 2  -->  %0 <=s 1
     $bl = SETCCr 12, implicit $eflags
     ; %0 <u 2  -->  %0 <=u 1
     $bl = SETCCr 2, implicit $eflags
 ...
 ---
 name: opt_redundant_flags_adjusted_imm_1
 body: |
   bb.0:
     ; CHECK-LABEL: name: opt_redundant_flags_adjusted_imm_1
     ; CHECK: [[COPY:%[0-9]+]]:gr64 = COPY $rsi
-    ; CHECK-NEXT: CMP64ri8 [[COPY]], 42, implicit-def $eflags
+    ; CHECK-NEXT: CMP64ri32 [[COPY]], 42, implicit-def $eflags
     ; CHECK-NEXT: $cl = SETCCr 5, implicit $eflags
     ; CHECK-NEXT: $bl = SETCCr 13, implicit $eflags
     ; CHECK-NEXT: $bl = SETCCr 3, implicit $eflags
     ; CHECK-NEXT: $bl = SETCCr 12, implicit $eflags
     ; CHECK-NEXT: $bl = SETCCr 2, implicit $eflags
     %0:gr64 = COPY $rsi
     ; CMP+SETCC   %0 != 42
-    CMP64ri8 %0, 42, implicit-def $eflags
+    CMP64ri32 %0, 42, implicit-def $eflags
     $cl = SETCCr 5, implicit $eflags
     ; CMP+SETCC   %0 >= 2; CMP can be removed.
-    CMP64ri8 %0, 41, implicit-def $eflags
+    CMP64ri32 %0, 41, implicit-def $eflags
     ; %0 >s 41  -->  %0 >=s 42
     $bl = SETCCr 15, implicit $eflags
     ; %0 >u 41  -->  %0 >=u 42
     $bl = SETCCr 7, implicit $eflags
     ; %0 <=s 41  -->  %0 <s 42
     $bl = SETCCr 14, implicit $eflags
     ; %0 <=u 41  -->  %0 <u 42
     $bl = SETCCr 6, implicit $eflags
bb.0:
     $cl = SETCCr 12, implicit $eflags
 ...
 ---
 name: opt_redundant_flags_adjusted_imm_noopt_0
 body: |
   bb.0:
     ; CHECK-LABEL: name: opt_redundant_flags_adjusted_imm_noopt_0
     ; CHECK: [[COPY:%[0-9]+]]:gr64 = COPY $rsi
-    ; CHECK-NEXT: CMP64ri8 [[COPY]], 42, implicit-def $eflags
+    ; CHECK-NEXT: CMP64ri32 [[COPY]], 42, implicit-def $eflags
     ; CHECK-NEXT: $cl = SETCCr 4, implicit $eflags
-    ; CHECK-NEXT: CMP64ri8 [[COPY]], 41, implicit-def $eflags
+    ; CHECK-NEXT: CMP64ri32 [[COPY]], 41, implicit-def $eflags
     ; CHECK-NEXT: $bl = SETCCr 4, implicit $eflags
     %0:gr64 = COPY $rsi
     ; CMP+SETCC   %0 <s 1
-    CMP64ri8 %0, 42, implicit-def $eflags
+    CMP64ri32 %0, 42, implicit-def $eflags
     $cl = SETCCr 4, implicit $eflags
     ; CMP should not be removed.
-    CMP64ri8 %0, 41, implicit-def $eflags
+    CMP64ri32 %0, 41, implicit-def $eflags
     ; %0 == 41
     $bl = SETCCr 4, implicit $eflags
 ...
 ---
 name: opt_redundant_flags_adjusted_imm_noopt_1
 body: |
   bb.0:
     ; CHECK-LABEL: name: opt_redundant_flags_adjusted_imm_noopt_1

llvm/test/CodeGen/X86/peephole-fold-testrr.mir

 machineFunctionInfo: {}
 body:             |
   bb.0 (%ir-block.0):
     liveins: $rdi
 
     ; CHECK-LABEL: name: atomic
     ; CHECK: liveins: $rdi
     ; CHECK: [[COPY:%[0-9]+]]:gr64 = COPY $rdi
-    ; CHECK: CMP64mi8 [[COPY]], 1, $noreg, 0, $noreg, 0, implicit-def $eflags :: (load unordered (s64) from %ir.arg)
+    ; CHECK: CMP64mi32 [[COPY]], 1, $noreg, 0, $noreg, 0, implicit-def $eflags :: (load unordered (s64) from %ir.arg)
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 4, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 killed [[SETCCr]]
     ; CHECK: $eax = COPY [[MOVZX32rr8_]]
     ; CHECK: RET 0, $eax
     %0:gr64 = COPY $rdi
     %1:gr64 = MOV64rm %0, 1, $noreg, 0, $noreg :: (load unordered (s64) from %ir.arg)
     TEST64rr %1, %1, implicit-def $eflags
     %2:gr8 = SETCCr 4, implicit $eflags

 machineFunctionInfo: {}
 body:             |
   bb.0 (%ir-block.0):
     liveins: $rdi
 
     ; CHECK-LABEL: name: nonatomic_unoptimized
     ; CHECK: liveins: $rdi
     ; CHECK: [[COPY:%[0-9]+]]:gr64 = COPY $rdi
-    ; CHECK: CMP64mi8 [[COPY]], 1, $noreg, 0, $noreg, 0, implicit-def $eflags :: (load (s64) from %ir.arg)
+    ; CHECK: CMP64mi32 [[COPY]], 1, $noreg, 0, $noreg, 0, implicit-def $eflags :: (load (s64) from %ir.arg)
     ; CHECK: [[SETCCr:%[0-9]+]]:gr8 = SETCCr 4, implicit $eflags
     ; CHECK: [[MOVZX32rr8_:%[0-9]+]]:gr32 = MOVZX32rr8 killed [[SETCCr]]
     ; CHECK: $eax = COPY [[MOVZX32rr8_]]
     ; CHECK: RET 0, $eax
     %0:gr64 = COPY $rdi
     %1:gr64 = MOV64rm %0, 1, $noreg, 0, $noreg :: (load (s64) from %ir.arg)
     TEST64rr %1, %1, implicit-def $eflags
     %2:gr8 = SETCCr 4, implicit $eflags
     %3:gr32 = MOVZX32rr8 killed %2
     $eax = COPY %3
     RET 0, $eax
 
 ...

llvm/test/CodeGen/X86/pr46827.ll

 ; RUN: llc < %s -mtriple=i686-pc-linux -mattr=+rtm -verify-machineinstrs -stop-after=finalize-isel | FileCheck %s
 
 ; CHECK: body:             |
 ; CHECK:   bb.0.bb107:
 ; CHECK:     successors: %bb.3(0x40000000), %bb.4(0x40000000)
 ; CHECK:     %0:gr32 = MOV32rm %fixed-stack.0, 1, $noreg, 0, $noreg :: (load (s32) from %fixed-stack.0, align 16)
-; CHECK:     %1:gr32 = SUB32ri8 %0, 1, implicit-def $eflags
+; CHECK:     %1:gr32 = SUB32ri %0, 1, implicit-def $eflags
 ; CHECK:     XBEGIN_4 %bb.4, implicit-def $eax
 ; CHECK:   bb.3.bb107:
 ; CHECK:     successors: %bb.5(0x80000000)
 ; CHECK:     liveins: $eflags
 ; CHECK:     %3:gr32 = MOV32ri -1
 ; CHECK:     JMP_1 %bb.5
 ; CHECK:   bb.4.bb107:
 ; CHECK:     successors: %bb.5(0x80000000)

llvm/test/CodeGen/X86/push-cfi.ll

 ; LINUX-NEXT: .cfi_adjust_cfa_offset 4
 ; LINUX-NEXT: call
 ; LINUX-NEXT: addl $16, %esp
 ; LINUX: .cfi_adjust_cfa_offset -16
 ; DARWIN-NOT: .cfi_escape
 ; DARWIN-NOT: pushl
 
 ; PEI-LABEL: name: test1_nofp
-; PEI:         $esp = frame-setup SUB32ri8 $esp, 12, implicit-def dead $eflags
+; PEI:         $esp = frame-setup SUB32ri $esp, 12, implicit-def dead $eflags
 ; PEI-NEXT:    frame-setup CFI_INSTRUCTION def_cfa_offset 16
 ; PEI-NOT:     frame-setup CFI_INSTRUCTION
 ; PEI:         ...
 define void @test1_nofp() #0 personality ptr @__gxx_personality_v0 {
 entry:
   invoke void @good(i32 1, i32 2, i32 3, i32 4)
           to label %continue unwind label %cleanup
 continue:

llvm/test/CodeGen/X86/statepoint-cmp-sunk-past-statepoint.ll

 ; CHECK-LV:     TEST8rr killed %18, %18, implicit-def $eflags
 ; CHECK-LIS:    TEST8rr %18, %18, implicit-def $eflags
 ; CHECK:        JCC_1 %bb.5, 5, implicit killed $eflags
 ; CHECK:        JMP_1 %bb.4
 ; CHECK:      bb.4
 ; CHECK:      bb.5
 ; CHECK:        %3:gr64 = COPY %10
 ; CHECK-LV:     %4:gr64 = COPY killed %10
-; CHECK-LV:     %4:gr64 = nuw ADD64ri8 %4, 8, implicit-def dead $eflags
+; CHECK-LV:     %4:gr64 = nuw ADD64ri32 %4, 8, implicit-def dead $eflags
 ; CHECK-LIS:    %4:gr64 = LEA64r %10, 1, $noreg, 8, $noreg
 ; CHECK:        TEST64rr killed %1, %1, implicit-def $eflags
 ; CHECK:        JCC_1 %bb.1, 5, implicit killed $eflags
 ; CHECK:        JMP_1 %bb.6
 define void @test2(i8 addrspace(1)* %this, i32 %0, i32 addrspace(1)* %p0, i8 addrspace(1)* %p1) gc "statepoint-example" personality i32* ()* @fake_personality_function {
 preheader:
   br label %loop.head
 

llvm/test/CodeGen/X86/switch-bit-test-unreachable-default.ll

 
 
 ; CHECK-GISEL: bb.1 (%ir-block.1):
 ; CHECK-GISEL:   successors: %bb.5(0x80000000); %bb.5(100.00%)
 ; CHECK-GISEL:   liveins: $edi
 ; CHECK-GISEL:   %0:gr32 = COPY $edi
 ; CHECK-GISEL:   %10:gr32 = MOV32ri 1
 ; CHECK-GISEL:   %11:gr32 = MOV32r0 implicit-def $eflags
-; CHECK-GISEL:   %2:gr32 = SUB32ri8 %0:gr32(tied-def 0), 0, implicit-def $eflags
+; CHECK-GISEL:   %2:gr32 = SUB32ri %0:gr32(tied-def 0), 0, implicit-def $eflags
 ; CHECK-GISEL: bb.5 (%ir-block.1):
 ; CHECK-GISEL: ; predecessors: %bb.1
 ; CHECK-GISEL:   successors: %bb.4(0x55555555), %bb.2(0x2aaaaaab); %bb.4(66.67%), %bb.2(33.33%)
 ; CHECK-GISEL:   %3:gr32 = MOV32ri 1
 ; CHECK-GISEL:   %13:gr8 = COPY %2.sub_8bit:gr32
 ; CHECK-GISEL:   $cl = COPY %13:gr8
 ; CHECK-GISEL:   %4:gr32 = SHL32rCL %3:gr32(tied-def 0), implicit-def $eflags, implicit $cl
 ; CHECK-GISEL:   %6:gr32 = AND32ri %4:gr32(tied-def 0), 13056, implicit-def $eflags

llvm/test/CodeGen/X86/switch-lower-peel-top-case.ll

 ; CHECK:    JMP_1 %[[BB3_LABEL]]
 ; CHECK:  [[BB3_LABEL]]
 ; CHECK:    successors: %[[CASE5_LABEL:.*]](0x45d173c8), %[[BB4_LABEL:.*]](0x3a2e8c38)
 ; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri %[[VAL]], 129, implicit-def $eflags
 ; CHECK:    JCC_1 %[[CASE5_LABEL]], 4, implicit $eflags
 ; CHECK:    JMP_1 %[[BB4_LABEL]]
 ; CHECK:  [[BB4_LABEL:.*]].{{[a-zA-Z0-9.]+}}:
 ; CHECK:    successors: %[[CASE1_LABEL:.*]](0x66666666), %[[DEFAULT_BB_LABEL:.*]](0x1999999a)
-; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri8 %[[VAL]], 8, implicit-def $eflags
+; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri %[[VAL]], 8, implicit-def $eflags
 ; CHECK:    JCC_1 %[[CASE1_LABEL]], 4, implicit $eflags
 ; CHECK:    JMP_1 %[[DEFAULT_BB_LABEL]]
 ; CHECK:  [[BB2_LABEL]].{{[a-zA-Z0-9.]+}}:
 ; CHECK:    successors: %[[CASE3_LABEL:.*]](0x7fe44107), %[[DEFAULT_BB_LABEL]](0x001bbef9)
 ; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri %[[VAL]], 18312, implicit-def $eflags
 ; CHECK:    JCC_1 %[[CASE3_LABEL]], 4, implicit $eflags
 ; CHECK:    JMP_1 %[[DEFAULT_BB_LABEL]]
 
switch i32 %n, label %bb_default [
     i32 1, label %bb3
     i32 5, label %bb4
     i32 7, label %bb5
     i32 49, label %bb6
   ], !prof !3
 
 ; CHECK:   successors: %[[PEELED_CASE_LABEL:.*]](0x59999999), %[[PEELED_SWITCH_LABEL:.*]](0x26666667)
 ; CHECK:   %[[VAL:[0-9]+]]:gr32 = COPY $edi
-; CHECK:   %{{[0-9]+}}:gr32 = ADD32ri8 %{{[0-9]+}}, -85, implicit-def dead $eflags
-; CHECK:   %{{[0-9]+}}:gr32 = SUB32ri8 %{{[0-9]+}}, 2, implicit-def $eflags
+; CHECK:   %{{[0-9]+}}:gr32 = ADD32ri %{{[0-9]+}}, -85, implicit-def dead $eflags
+; CHECK:   %{{[0-9]+}}:gr32 = SUB32ri %{{[0-9]+}}, 2, implicit-def $eflags
 ; CHECK:   JCC_1 %[[PEELED_CASE_LABEL]], 2, implicit $eflags
 ; CHECK:   JMP_1 %[[PEELED_SWITCH_LABEL]]
 ; CHECK: [[PEELED_SWITCH_LABEL]].{{[a-zA-Z0-9.]+}}:
 ; CHECK:    successors: %[[BB1_LABEL:.*]](0x0088888a), %[[BB2_LABEL:.*]](0x7f777776)
-; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri8 %[[VAL]], 4, implicit-def $eflags
+; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri %[[VAL]], 4, implicit-def $eflags
 ; CHECK:    JCC_1 %[[BB2_LABEL]], 15, implicit $eflags
 ; CHECK:    JMP_1 %[[BB1_LABEL]]
 ; CHECK:  [[BB1_LABEL]].{{[a-zA-Z0-9.]+}}:
 ; CHECK:    successors: %[[CASE4_LABEL:.*]](0x7f775a4f), %[[BB3_LABEL:.*]](0x0088a5b1)
-; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri8 %[[VAL]], 1, implicit-def $eflags
+; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri %[[VAL]], 1, implicit-def $eflags
 ; CHECK:    JCC_1 %[[CASE4_LABEL]], 4, implicit $eflags
 ; CHECK:    JMP_1 %[[BB3_LABEL]]
 ; CHECK:  [[BB3_LABEL]].{{[a-zA-Z0-9.]+}}:
 ; CHECK:    successors: %[[CASE1_LABEL:.*]](0x66666666), %[[DEFAULT_BB_LABEL:.*]](0x1999999a)
-; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri8 %[[VAL]], -40, implicit-def $eflags
+; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri %[[VAL]], -40, implicit-def $eflags
 ; CHECK:    JCC_1 %[[CASE1_LABEL]], 4, implicit $eflags
 ; CHECK:    JMP_1 %[[DEFAULT_BB_LABEL]]
 ; CHECK:  [[BB2_LABEL]].{{[a-zA-Z0-9.]+}}:
 ; CHECK:    successors: %[[CASE5_LABEL:.*]](0x00000000), %[[BB4_LABEL:.*]](0x80000000)
-; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri8 %[[VAL]], 5, implicit-def $eflags
+; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri %[[VAL]], 5, implicit-def $eflags
 ; CHECK:    JCC_1 %[[CASE5_LABEL]], 4, implicit $eflags
 ; CHECK:    JMP_1 %[[BB4_LABEL]]
 ; CHECK:  [[BB4_LABEL]].{{[a-zA-Z0-9.]+}}:
 ; CHECK:    successors: %[[CASE6_LABEL:.*]](0x00000000), %[[BB5_LABEL:.*]](0x80000000)
-; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri8 %[[VAL]], 7, implicit-def $eflags
+; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri %[[VAL]], 7, implicit-def $eflags
 ; CHECK:    JCC_1 %[[CASE6_LABEL]], 4, implicit $eflags
 ; CHECK:    JMP_1 %[[BB5_LABEL]]
 ; CHECK:  [[BB5_LABEL]].{{[a-zA-Z0-9.]+}}:
 ; CHECK:    successors: %[[CASE7_LABEL:.*]](0x00000000), %[[DEFAULT_BB_LABEL]](0x80000000)
-; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri8 %[[VAL]], 49, implicit-def $eflags
+; CHECK:    %{{[0-9]+}}:gr32 = SUB32ri %[[VAL]], 49, implicit-def $eflags
 ; CHECK:    JCC_1 %[[CASE7_LABEL]], 4, implicit $eflags
 ; CHECK:    JMP_1 %[[DEFAULT_BB_LABEL]]
 
 
 bb1:
   br label %return
 bb2:
   br label %return

llvm/test/CodeGen/X86/tail-call-conditional.mir

liveins:
   - { reg: '$rdi' }
   - { reg: '$rsi' }
 body:             |
   bb.0:
     successors: %bb.1, %bb.4
     liveins: $rdi, $rsi
 
     $rax = COPY $rdi
-    CMP64ri8 $rax, 99, implicit-def $eflags
+    CMP64ri32 $rax, 99, implicit-def $eflags
     JCC_1 %bb.4, 7, implicit $eflags
     JMP_1 %bb.1
 
   ; CHECK: bb.1:
   ; CHECK-NEXT: successors: %bb.2({{[^)]+}}){{$}}
   ; CHECK-NEXT: liveins: $rax, $rsi
   ; CHECK-NEXT: {{^  $}}
   ; CHECK-NEXT: $rdi = COPY $rsi
   ; CHECK-NEXT: $rsi = COPY $rax
-  ; CHECK-NEXT: CMP64ri8 $rax, 9, implicit-def $eflags
+  ; CHECK-NEXT: CMP64ri32 $rax, 9, implicit-def $eflags
   ; CHECK-NEXT: TCRETURNdi64cc @f1, 0, 6, csr_64, implicit $rsp, implicit $eflags, implicit $ssp, implicit $rsp, implicit $rdi, implicit $rsi, implicit $rdi, implicit-def $rdi, implicit $hsi, implicit-def $hsi, implicit $sih, implicit-def $sih, implicit $sil, implicit-def $sil, implicit $si, implicit-def $si, implicit $esi, implicit-def $esi, implicit $rsi, implicit-def $rsi, implicit $hdi, implicit-def $hdi, implicit $dih, implicit-def $dih, implicit $dil, implicit-def $dil, implicit $di, implicit-def $di, implicit $edi, implicit-def $edi
 
   bb.1:
     successors: %bb.2, %bb.3
     liveins: $rax, $rsi
 
-    CMP64ri8 $rax, 9, implicit-def $eflags
+    CMP64ri32 $rax, 9, implicit-def $eflags
     JCC_1 %bb.3, 7, implicit $eflags
     JMP_1 %bb.2
 
   bb.2:
     liveins: $rax, $rsi
 
     $rdi = COPY $rsi
     $rsi = COPY $rax

llvm/test/CodeGen/X86/tail-merge-after-mbp.mir

body:             |
   ; CHECK:   JCC_1 %bb.1, 5, implicit $eflags
   ; CHECK: bb.2:
   ; CHECK:   successors: %bb.1(0x30000000), %bb.3(0x50000000)
   ; CHECK:   $rax = MOV64rm $r14, 1, $noreg, 0, $noreg :: (load (s64))
   ; CHECK:   TEST64rr $rax, $rax, implicit-def $eflags
   ; CHECK:   JCC_1 %bb.1, 4, implicit $eflags
   ; CHECK: bb.3:
   ; CHECK:   successors: %bb.6(0x30000000), %bb.4(0x50000000)
-  ; CHECK:   CMP64mi8 killed $rax, 1, $noreg, 8, $noreg, 0, implicit-def $eflags :: (load (s64))
+  ; CHECK:   CMP64mi32 killed $rax, 1, $noreg, 8, $noreg, 0, implicit-def $eflags :: (load (s64))
   ; CHECK:   JCC_1 %bb.6, 4, implicit $eflags
   ; CHECK: bb.4:
   ; CHECK:   $ebp = XOR32rr undef $ebp, undef $ebp, implicit-def dead $eflags
   ; CHECK:   dead $eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, implicit-def $al
   ; CHECK:   RET64 $eax
   ; CHECK: bb.6:
   ; CHECK:   successors: %bb.1(0x30000000), %bb.7(0x50000000)
   ; CHECK:   $rax = MOV64rm $r14, 1, $noreg, 0, $noreg :: (load (s64))
   ; CHECK:   TEST64rr $rax, $rax, implicit-def $eflags
   ; CHECK:   JCC_1 %bb.1, 4, implicit $eflags
   ; CHECK: bb.7 (align 16):
   ; CHECK:   successors: %bb.8(0x71555555), %bb.4(0x0eaaaaab)
-  ; CHECK:   CMP64mi8 killed $rax, 1, $noreg, 8, $noreg, 0, implicit-def $eflags :: (load (s64)), (load (s64))
+  ; CHECK:   CMP64mi32 killed $rax, 1, $noreg, 8, $noreg, 0, implicit-def $eflags :: (load (s64)), (load (s64))
   ; CHECK:   JCC_1 %bb.4, 5, implicit $eflags
   ; CHECK: bb.8:
   ; CHECK:   successors: %bb.1(0x04000000), %bb.7(0x7c000000)
   ; CHECK:   $rax = MOV64rm $r14, 1, $noreg, 0, $noreg :: (load (s64))
   ; CHECK:   TEST64rr $rax, $rax, implicit-def $eflags
   ; CHECK:   JCC_1 %bb.7, 5, implicit $eflags
   ; CHECK: bb.1:
   ; CHECK:   $ebp = XOR32rr undef $ebp, undef $ebp, implicit-def dead $eflags
bb.8:
     successors: %bb.16(0x80000000)
 
     $ebp = XOR32rr undef $ebp, undef $ebp, implicit-def dead $eflags
     JMP_1 %bb.16
 
   bb.9:
     successors: %bb.10(0x30000000), %bb.15(0x50000000)
 
-    CMP64mi8 killed $rax, 1, $noreg, 8, $noreg, 0, implicit-def $eflags :: (load (s64))
+    CMP64mi32 killed $rax, 1, $noreg, 8, $noreg, 0, implicit-def $eflags :: (load (s64))
     JCC_1 %bb.15, 5, implicit $eflags
 
   bb.10:
     successors: %bb.11(0x30000000), %bb.12(0x50000000)
 
     $rax = MOV64rm $r14, 1, $noreg, 0, $noreg :: (load (s64))
     TEST64rr $rax, $rax, implicit-def $eflags
     JCC_1 %bb.12, 5, implicit $eflags
 
   bb.11:
     successors: %bb.16(0x80000000)
 
     $ebp = XOR32rr undef $ebp, undef $ebp, implicit-def dead $eflags
     JMP_1 %bb.16
 
   bb.12:
     successors: %bb.13(0x71555555), %bb.15(0x0eaaaaab)
 
-    CMP64mi8 killed $rax, 1, $noreg, 8, $noreg, 0, implicit-def $eflags :: (load (s64)), (load (s64))
+    CMP64mi32 killed $rax, 1, $noreg, 8, $noreg, 0, implicit-def $eflags :: (load (s64)), (load (s64))
     JCC_1 %bb.15, 5, implicit $eflags
 
   bb.13:
     successors: %bb.14(0x04000000), %bb.12(0x7c000000)
 
     $rax = MOV64rm $r14, 1, $noreg, 0, $noreg :: (load (s64))
     TEST64rr $rax, $rax, implicit-def $eflags
     JCC_1 %bb.12, 5, implicit $eflags

llvm/test/CodeGen/X86/throws-cfi-fp.ll

 ; PEI-NEXT:    frame-setup CFI_INSTRUCTION def_cfa_offset 16
 ; PEI-NEXT:    frame-setup CFI_INSTRUCTION offset $rbp, -16
 ; PEI-NEXT:    $rbp = frame-setup MOV64rr $rsp
 ; PEI-NEXT:    frame-setup CFI_INSTRUCTION def_cfa_register $rbp
 ; PEI-NEXT:    frame-setup PUSH64r killed $rbx, implicit-def $rsp, implicit $rsp
 ; PEI-NEXT:    frame-setup PUSH64r undef $rax, implicit-def $rsp, implicit $rsp
 ; PEI-NEXT:    {{^ +}}CFI_INSTRUCTION offset $rbx, -24
 ; PEI:         bb.4.try.cont:
-; PEI-NEXT:      $rsp = frame-destroy ADD64ri8 $rsp, 8, implicit-def dead $eflags
+; PEI-NEXT:      $rsp = frame-destroy ADD64ri32 $rsp, 8, implicit-def dead $eflags
 ; PEI-NEXT:      $rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp
 ; PEI-NEXT:      $rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp
 ; PEI-NEXT:      frame-destroy CFI_INSTRUCTION def_cfa $rsp, 8
 ; PEI-NEXT:      RET 0
 
 entry:
   %.b5 = load i1, ptr @_ZL11ShouldThrow, align 1
   br i1 %.b5, label %if.then, label %try.cont

llvm/test/CodeGen/X86/twoaddr-dbg-value.mir

 # RUN: llc -run-pass=livevars,twoaddressinstruction -mtriple=x86_64-- -o - %s | FileCheck %s
 ---
 name:            foo
 tracksRegLiveness: true
 body:             |
   bb.0:
     liveins: $edi
 
     %0:gr32 = COPY killed $edi
     %1:gr32 = COPY killed %0
-    %4:gr32 = XOR32ri8 %1, 1, implicit-def dead $eflags
+    %4:gr32 = XOR32ri %1, 1, implicit-def dead $eflags
     DBG_VALUE %4
     %5:gr32 = COPY %4
     PUSH32r killed %1, implicit-def $esp, implicit $esp
     $eax = COPY killed %5
     RET64 implicit killed $eax
 
 ...
 
 # Verify that the DBG_VALUE instruction does not inhibit
 # TwoAddressInstructionPass::rescheduleMIBelowKill optimization
 
 # CHECK: PUSH32r %1, implicit-def $esp, implicit $esp
 # CHECK-NEXT: %2:gr32 = COPY killed %1
-# CHECK-NEXT: %2:gr32 = XOR32ri8 %2, 1, implicit-def dead $eflags
+# CHECK-NEXT: %2:gr32 = XOR32ri %2, 1, implicit-def dead $eflags
 # CHECK-NEXT: DBG_VALUE %2
 # CHECK-NEXT: %3:gr32 = COPY killed %2

llvm/test/CodeGen/X86/update-terminator-debugloc.ll

 ; these debug locations are propaged correctly to lowered instructions.
 ;
 ; CHECK: [[DLOC:![0-9]+]] = !DILocation(line: 6
 ; CHECK-DAG: [[VREG1:%[^ ]+]]:gr64 = COPY $rsi
 ; CHECK-DAG: [[VREG2:%[^ ]+]]:gr64 = COPY $rdi
 ; CHECK: SUB64rr [[VREG2]], [[VREG1]]
 ; CHECK-NEXT: JCC_1 {{.*}}, debug-location [[DLOC]]{{$}}
 ; CHECK: [[VREG3:%[^ ]+]]:gr64 = PHI [[VREG2]]
-; CHECK: [[VREG4:%[^ ]+]]:gr64 = nuw ADD64ri8 [[VREG3]], 4
+; CHECK: [[VREG4:%[^ ]+]]:gr64 = nuw ADD64ri32 [[VREG3]], 4
 ; CHECK: SUB64rr [[VREG4]], [[VREG1]]
 ; CHECK-NEXT: JCC_1 {{.*}}, debug-location [[DLOC]]{{$}}
 ; CHECK-NEXT: JMP_1 {{.*}}, debug-location [[DLOC]]{{$}}
 
 target triple = "x86_64-unknown-linux-gnu"
 
 define i32 @foo(ptr readonly %begin, ptr readnone %end) !dbg !4 {
 entry:

llvm/test/CodeGen/X86/vecloadextract.ll

define i32 @const_index(ptr %v) {
   %a = load <8 x i32>, ptr %v
   %b = extractelement <8 x i32> %a, i32 1
   ret i32 %b
 }
 
 ; CHECK: name: variable_index
 ; CHECK:  bb.0 (%ir-block.0):
 ; CHECK:    [[INDEX:%[0-9]+]]:gr32 = MOV32rm %fixed-stack.0, 1, $noreg, 0, $noreg :: (load (s32) from %fixed-stack.0)
-; CHECK:    [[MASKED_INDEX:%[0-9]+]]:gr32_nosp = AND32ri8 [[INDEX]], 7, implicit-def dead $eflags
+; CHECK:    [[MASKED_INDEX:%[0-9]+]]:gr32_nosp = AND32ri [[INDEX]], 7, implicit-def dead $eflags
 ; CHECK:    [[POINTER:%[0-9]+]]:gr32 = MOV32rm %fixed-stack.1, 1, $noreg, 0, $noreg :: (load (s32) from %fixed-stack.1)
 ; CHECK:    [[LOAD:%[0-9]+]]:gr32 = MOV32rm killed [[POINTER]], 4, killed [[MASKED_INDEX]], 0, $noreg :: (load (s32))
 ; CHECK:    $eax = COPY [[LOAD]]
 ; CHECK:    RET 0, $eax
 define i32 @variable_index(ptr %v, i32 %i) {
   %a = load <8 x i32>, ptr %v
   %b = extractelement <8 x i32> %a, i32 %i
   ret i32 %b
 }
 
 ; CHECK: name: variable_index_with_addrspace
 ; CHECK:  bb.0 (%ir-block.0):
 ; CHECK:    [[INDEX:%[0-9]+]]:gr32 = MOV32rm %fixed-stack.0, 1, $noreg, 0, $noreg :: (load (s32) from %fixed-stack.0)
-; CHECK:    [[MASKED_INDEX:%[0-9]+]]:gr32_nosp = AND32ri8 [[INDEX]], 7, implicit-def dead $eflags
+; CHECK:    [[MASKED_INDEX:%[0-9]+]]:gr32_nosp = AND32ri [[INDEX]], 7, implicit-def dead $eflags
 ; CHECK:    [[POINTER:%[0-9]+]]:gr32 = MOV32rm %fixed-stack.1, 1, $noreg, 0, $noreg :: (load (s32) from %fixed-stack.1)
 ; CHECK:    [[LOAD:%[0-9]+]]:gr32 = MOV32rm killed [[POINTER]], 4, killed [[MASKED_INDEX]], 0, $noreg :: (load (s32), addrspace 1)
 ; CHECK:    $eax = COPY [[LOAD]]
 ; CHECK:    RET 0, $eax
 define i32 @variable_index_with_addrspace(ptr addrspace(1) %v, i32 %i) {
   %a = load <8 x i32>, ptr addrspace(1) %v
   %b = extractelement <8 x i32> %a, i32 %i
   ret i32 %b
 }

llvm/test/DebugInfo/MIR/InstrRef/stack-coloring-dbg-phi.mir

body:             |
   bb.4:
     %24:gr32 = MOV32ri 1
   
   bb.5:
     successors: %bb.3(0x20000000), %bb.6(0x60000000)
   
     %1:gr32 = PHI %27, %bb.3, %24, %bb.4, debug-location !9
     %25:gr32 = nsw ADD32rr %1, %0, implicit-def dead $eflags, debug-location !9
-    CMP32ri8 killed %25, 6, implicit-def $eflags, debug-location !9
+    CMP32ri killed %25, 6, implicit-def $eflags, debug-location !9
     JCC_1 %bb.3, 7, implicit killed $eflags, debug-location !9
     JMP_1 %bb.6, debug-location !9
   
   bb.6:
     successors: %bb.3(0x2aaaaaab), %bb.7(0x55555555)
   
     %28:gr8 = COPY %27.sub_8bit
     TEST8rr killed %28, %28, implicit-def $eflags, debug-location !9
bb.8:
     %30:gr8 = COPY %27.sub_8bit
     TEST8rr killed %30, %30, implicit-def $eflags, debug-location !9
     JCC_1 %bb.3, 5, implicit killed $eflags, debug-location !9
     JMP_1 %bb.9, debug-location !9
   
   bb.9:
     successors: %bb.10(0x80000000), %bb.12(0x00000000)
   
-    CMP32ri8 undef %32:gr32, 16, implicit-def $eflags, debug-location !9
+    CMP32ri undef %32:gr32, 16, implicit-def $eflags, debug-location !9
     JCC_1 %bb.12, 15, implicit killed $eflags, debug-location !9
     JMP_1 %bb.10, debug-location !9
   
   bb.10:
     successors: %bb.11, %bb.3
   
     %34:gr8 = COPY %27.sub_8bit
     TEST8rr killed %34, %34, implicit-def $eflags, debug-location !9
bb.21:
     $rdi = COPY %15, debug-location !9
     $esi = COPY killed %49, debug-location !9
     $edx = COPY killed %12, debug-location !9
     $ecx = COPY %54, debug-location !9
     $r8 = COPY %50, debug-location !9
     CALL64r undef %55:gr64, csr_64, implicit $rsp, implicit $ssp, implicit killed $rdi, implicit killed $esi, implicit killed $edx, implicit killed $ecx, implicit killed $r8, implicit-def $rsp, implicit-def $ssp, debug-location !9
     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp, debug-location !9
     %13:gr64 = nuw nsw INC64r killed %3, implicit-def dead $eflags, debug-location !9
-    %14:gr32 = ADD32ri8 killed %2, -8, implicit-def dead $eflags, debug-location !9
-    CMP32ri8 %14, 8, implicit-def $eflags, debug-location !9
+    %14:gr32 = ADD32ri killed %2, -8, implicit-def dead $eflags, debug-location !9
+    CMP32ri %14, 8, implicit-def $eflags, debug-location !9
     JCC_1 %bb.13, 15, implicit killed $eflags, debug-location !9
     JMP_1 %bb.3, debug-location !9
 
 ...

llvm/test/DebugInfo/MIR/InstrRef/twoaddr-to-threeaddr-sub.mir

frameInfo:
   maxAlignment:    1
 machineFunctionInfo: {}
 body:             |
   bb.0:
     liveins: $edi
 
     %0:gr32 = COPY killed $edi
     %1:gr32 = SHL32ri killed %0, 5, implicit-def dead $eflags
-    %2:gr32 = ADD32ri8_DB killed %1, 3, implicit-def dead $eflags, debug-instr-number 1
+    %2:gr32 = ADD32ri_DB killed %1, 3, implicit-def dead $eflags, debug-instr-number 1
     DBG_INSTR_REF dbg-instr-ref(1, 0)
     $eax = COPY killed %2
     RET 0, killed $eax
 
 ...
 

llvm/test/DebugInfo/MIR/InstrRef/x86-lea-fixup-2.mir

liveins:
   - { reg: '$eax' }
   - { reg: '$ebp' }
 # CHECK:       debugValueSubstitutions:
 # CHECK-NAME:  - { srcinst: 1, srcop: 0, dstinst: 2, dstop: 0, subreg: 0 }
 body:             |
   bb.0:
     liveins: $eax, $ebp
 
-    ; CHECK: $eax = ADD32ri8 {{.*}} debug-instr-number 2
+    ; CHECK: $eax = ADD32ri {{.*}} debug-instr-number 2
     $eax = LEA32r killed $eax, 1, killed $ebp, -5, $noreg, debug-instr-number 1
     RET64 $eax
 
 ...
 ---
 name:            testleais_ebp_32
 # CHECK-LABEL: name: testleais_ebp_32
 alignment:       16

llvm/test/DebugInfo/MIR/InstrRef/x86-lea-fixup.mir

 # HASWELL-NEXT:  - { srcinst: 1, srcop: 0, dstinst: 3, dstop: 0, subreg: 0 }
 # HASWELL-NEXT:  - { srcinst: 2, srcop: 0, dstinst: 4, dstop: 0, subreg: 0 }
 body:             |
   bb.0:
     liveins: $edi
   
     renamable $edi = KILL $edi, implicit-def $rdi
     renamable $ecx = nsw LEA64_32r renamable $rdi, 8, renamable $rdi, 42, $noreg, debug-instr-number 1
-    ; HASWELL: ADD32ri8 {{.*}} debug-instr-number 3
+    ; HASWELL: ADD32ri {{.*}} debug-instr-number 3
     renamable $eax = nsw LEA64_32r killed renamable $rdi, 4, renamable $rdi, 2, $noreg, debug-instr-number 2
-    ; HASWELL: ADD32ri8 {{.*}} debug-instr-number 4
+    ; HASWELL: ADD32ri {{.*}} debug-instr-number 4
     renamable $eax = nsw IMUL32rr killed renamable $eax, killed renamable $ecx, implicit-def dead $eflags
     RET64 $eax
 
 ...
 ---
 name:            testthree
 # ATOM-LABEL: name: testthree
 alignment:       16

llvm/test/DebugInfo/MIR/X86/empty-inline.mir

frameInfo:
   hasMustTailInVarArgFunc: false
 #stack:
 #  - { id: 0, name: '<unnamed alloca>', offset: -16, size: 2, alignment: 8 }
 body:             |
   bb.0 (%ir-block.1):
     successors: %bb.1(0x30000000), %bb.2(0x50000000)
     liveins: $rdi
 
-    CMP64mi8 $rip, 1, _, @a, _, 0, implicit-def $eflags :: (dereferenceable load (s64) from @a, align 4)
+    CMP64mi32 $rip, 1, _, @a, _, 0, implicit-def $eflags :: (dereferenceable load (s64) from @a, align 4)
     JCC_1 %bb.1, 4, implicit $eflags
 
   bb.2 (%ir-block.5):
     liveins: $rdi
 
     $rax = MOV64rm $rdi, 1, _, 0, _ :: (load (s64) from %ir.6, align 4)
     $al = MOV8rm killed $rax, 1, _, 0, _ :: (load (s8) from %ir.8)
     MOV8mr killed $rdi, 1, _, 8, _, killed $al, debug-location !14 :: (store (s8) into %ir.12)

llvm/test/DebugInfo/MIR/X86/kill-after-spill.mir

bb.4.if.then8:
     renamable $rax = MOV64rm killed renamable $r13, 1, $noreg, 8, $noreg :: (load (s64) from %ir.13)
     TEST64rr renamable $rax, renamable $rax, implicit-def $eflags
     JCC_1 %bb.8, 4, implicit $eflags, debug-location !57
 
   bb.5.land.lhs.true:
     successors: %bb.6(0x30000000), %bb.7(0x50000000)
     liveins: $rax, $r12, $r15
 
-    CMP32mi8 renamable $r15, 1, $noreg, 0, $noreg, 0, implicit-def $eflags :: (load (s32) from %ir.tot_perf2, align 8)
+    CMP32mi renamable $r15, 1, $noreg, 0, $noreg, 0, implicit-def $eflags :: (load (s32) from %ir.tot_perf2, align 8)
     JCC_1 %bb.7, 5, implicit $eflags, debug-location !57
 
   bb.6.lor.lhs.false:
     successors: %bb.8(0x30000000), %bb.7(0x50000000)
     liveins: $rax, $r12, $r15
 
-    CMP32mi8 killed renamable $r15, 1, $noreg, 4, $noreg, 0, implicit-def $eflags :: (load (s32) from %ir.tot_bw)
+    CMP32mi killed renamable $r15, 1, $noreg, 4, $noreg, 0, implicit-def $eflags :: (load (s32) from %ir.tot_bw)
     JCC_1 %bb.8, 4, implicit $eflags, debug-location !57
 
   bb.7.if.then14:
     successors: %bb.8(0x80000000)
     liveins: $rax, $r12
 
     renamable $rdx = MOV64rm killed renamable $rax, 1, $noreg, 8, $noreg :: (load (s64) from %ir.20)
     $rdi = MOV64rr killed $r12
bb.2.if.then3:
     $r8d = MOV32rm $rbp, 1, $noreg, -48, $noreg :: (load (s32) from %stack.0)
     CALL64pcrel32 @func3, csr_64, implicit $rsp, implicit $ssp, implicit $edi, implicit $esi, implicit $edx, implicit $rcx, implicit $r8d, implicit-def $rsp, implicit-def $ssp
     renamable $ecx = XOR32rr undef $ecx, undef $ecx, implicit-def dead $eflags, debug-location !57
 
   bb.9.cleanup:
     liveins: $ecx
 
     $eax = MOV32rr killed $ecx
-    $rsp = ADD64ri8 $rsp, 8, implicit-def dead $eflags
+    $rsp = ADD64ri32 $rsp, 8, implicit-def dead $eflags
     $rbx = POP64r implicit-def $rsp, implicit $rsp
     $r12 = POP64r implicit-def $rsp, implicit $rsp
     $r13 = POP64r implicit-def $rsp, implicit $rsp
     $r14 = POP64r implicit-def $rsp, implicit $rsp
     $r15 = POP64r implicit-def $rsp, implicit $rsp
     $rbp = POP64r implicit-def $rsp, implicit $rsp
     RET64 $eax, debug-location !57
 
 ...

llvm/test/DebugInfo/MIR/X86/live-debug-values-stack-clobber.mir

bb.0.entry:
     frame-setup PUSH64r killed $r15, implicit-def $rsp, implicit $rsp, debug-location !28
     frame-setup PUSH64r killed $r14, implicit-def $rsp, implicit $rsp, debug-location !28
     frame-setup PUSH64r killed $r13, implicit-def $rsp, implicit $rsp, debug-location !28
     frame-setup PUSH64r killed $r12, implicit-def $rsp, implicit $rsp, debug-location !28
     frame-setup PUSH64r killed $rbx, implicit-def $rsp, implicit $rsp, debug-location !28
     $rsp = frame-setup SUB64ri8 $rsp, 24, implicit-def dead $eflags
     renamable $ecx = MOV32rm $rip, 1, $noreg, @bees, $noreg, debug-location !28 :: (volatile dereferenceable load (s32) from @bees)
     $eax = MOV32ri 3, implicit-def $rax
-    CMP32ri8 killed renamable $ecx, 12, implicit-def $eflags, debug-location !28
+    CMP32ri killed renamable $ecx, 12, implicit-def $eflags, debug-location !28
     JCC_1 %bb.4, 4, implicit $eflags, debug-location !28
   
   bb.1.if.end:
     successors: %bb.2, %bb.3
     liveins: $rdi, $rsi
   
     MOV64mr $rsp, 1, $noreg, 16, $noreg, killed renamable $rsi :: (store (s64) into %stack.1)
     MOV64mr $rsp, 1, $noreg, 8, $noreg, killed renamable $rdi :: (store (s64) into %stack.0)
     INLINEASM &"", 1, 12, implicit-def dead early-clobber $rax, 12, implicit-def dead early-clobber $rbx, 12, implicit-def dead early-clobber $rcx, 12, implicit-def dead early-clobber $rdx, 12, implicit-def dead early-clobber $rsi, 12, implicit-def dead early-clobber $rdi, 12, implicit-def dead early-clobber $rbp, 12, implicit-def dead early-clobber $r8, 12, implicit-def dead early-clobber $r9, 12, implicit-def dead early-clobber $r10, 12, implicit-def dead early-clobber $r11, 12, implicit-def dead early-clobber $r12, 12, implicit-def dead early-clobber $r13, 12, implicit-def dead early-clobber $r14, 12, implicit-def dead early-clobber $r15, 12, implicit-def dead early-clobber $df, 12, implicit-def dead early-clobber $fpsw, 12, implicit-def dead early-clobber $eflags, debug-location !28
     renamable $eax = MOV32rm $rip, 1, $noreg, @bees, $noreg, debug-location !28 :: (volatile dereferenceable load (s32) from @bees)
-    CMP32ri8 killed renamable $eax, 2, implicit-def $eflags, debug-location !28
+    CMP32ri killed renamable $eax, 2, implicit-def $eflags, debug-location !28
     JCC_1 %bb.3, 5, implicit killed $eflags, debug-location !28
   
   bb.2.if.then2:
     successors: %bb.4
   
     renamable $rax = MOV64rm $rsp, 1, $noreg, 8, $noreg :: (load (s64) from %stack.0)
     renamable $rax = SUB64rm killed renamable $rax, $rsp, 1, $noreg, 16, $noreg, implicit-def dead $eflags, debug-location !28 :: (load (s64) from %stack.1)
     JMP_1 %bb.4
   
   bb.3.if.end3:
     successors: %bb.4
   
     $edi = MOV32ri 1, implicit-def $rdi, debug-location !28
     $esi = MOV32ri 2, implicit-def $rsi, debug-location !28
     CALL64pcrel32 @sum, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit $rsi, implicit-def $rsp, implicit-def $ssp, implicit-def $rax, debug-location !28
     MOV64mr $rsp, 1, $noreg, 8, $noreg, $rax :: (store (s64) into %stack.0)
     INLINEASM &"", 1, 12, implicit-def dead early-clobber $rax, 12, implicit-def dead early-clobber $rbx, 12, implicit-def dead early-clobber $rcx, 12, implicit-def dead early-clobber $rdx, 12, implicit-def dead early-clobber $rsi, 12, implicit-def dead early-clobber $rdi, 12, implicit-def dead early-clobber $rbp, 12, implicit-def dead early-clobber $r8, 12, implicit-def dead early-clobber $r9, 12, implicit-def dead early-clobber $r10, 12, implicit-def dead early-clobber $r11, 12, implicit-def dead early-clobber $r12, 12, implicit-def dead early-clobber $r13, 12, implicit-def dead early-clobber $r14, 12, implicit-def dead early-clobber $r15, 12, implicit-def dead early-clobber $df, 12, implicit-def dead early-clobber $fpsw, 12, implicit-def dead early-clobber $eflags, debug-location !28
-    ADD32mi8 $rip, 1, $noreg, @bees, $noreg, 1, implicit-def dead $eflags, debug-location !28 :: (volatile store (s32) into @bees), (volatile dereferenceable load (s32) from @bees)
+    ADD32mi $rip, 1, $noreg, @bees, $noreg, 1, implicit-def dead $eflags, debug-location !28 :: (volatile store (s32) into @bees), (volatile dereferenceable load (s32) from @bees)
     renamable $rax = MOVSX64rm32 $rsp, 1, $noreg, 8, $noreg, debug-location !28 :: (load (s32) from %stack.0, align 8)
   
   bb.4.return:
     liveins: $rax
   
     $rsp = frame-destroy ADD64ri8 $rsp, 24, implicit-def dead $eflags, debug-location !28
     $rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !28
     $r12 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !28
     $r13 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !28
     $r14 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !28
     $r15 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !28
     $rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !28
     RET64 $rax, debug-location !28
 
 ...

llvm/test/DebugInfo/MIR/X86/machinesink-subreg.mir

bb.0.entry:
     ; CHECK-NEXT:  CMP32ri $esi, 0
     ; CHECK-NEXT:  DBG_VALUE $noreg, $noreg, [[VAR]]
     ; CHECK-NEXT:  CMP32ri $esi, 0
     ; CHECK-NEXT:  DBG_VALUE 0, $noreg, [[VAR]]
     ; CHECK-NEXT:  JCC_1 %bb.1, 4
     ; CHECK-NEXT:  JMP_1
 
     %2:gr64 = COPY $rdi
-    %5:gr64 = ADD64ri8 %2, 1, implicit-def dead $eflags
+    %5:gr64 = ADD64ri32 %2, 1, implicit-def dead $eflags
     CMP32ri $esi, 0, implicit-def $eflags
     DBG_VALUE %5.sub_32bit, $noreg, !16, !13, debug-location !17
     CMP32ri $esi, 0, implicit-def $eflags
     DBG_VALUE 0, $noreg, !16, !13, debug-location !17
     JCC_1 %bb.1.block1, 4, implicit $eflags
     JMP_1 %bb.2.exit
 
   bb.1.block1:
     successors: %bb.2.exit
 
-    %1:gr64 = ADD64ri8 %5, 4, implicit-def dead $eflags
+    %1:gr64 = ADD64ri32 %5, 4, implicit-def dead $eflags
     JMP_1 %bb.2.exit
 
   bb.2.exit:
     $rax = MOV64rr %2
     RET 0
 ...

llvm/test/DebugInfo/MIR/X86/machinesink.mir

body:             |
 
   bb.1.nou:
     successors: %bb.2.exit(0x80000000)
 
     ; This block should receive the sunk copy and DBG_VALUE
     ; CHECK-LABEL: bb.1.nou:
     ; CHECK:       [[SUNKVREG:%[0-9]+]]:gr64 = COPY [[ARG0VREG]]
     ; CHECK-NEXT:  DBG_VALUE [[SUNKVREG]], $noreg, [[VARNUM]]
-    ; CHECK-NEXT:  ADD64ri8
+    ; CHECK-NEXT:  ADD64ri32
     ; CHECK-NEXT:  JMP_1
-    %1:gr64 = ADD64ri8 %5, 4, implicit-def dead $eflags
+    %1:gr64 = ADD64ri32 %5, 4, implicit-def dead $eflags
     JMP_1 %bb.2.exit
 
   bb.2.exit:
     ; The DBG_VALUE below should have its operand copy-propagated after
     ; the copy to %5 is sunk.
     ; CHECK-LABEL: bb.2.exit:
     ; CHECK:       DBG_VALUE [[ARG0VREG]], $noreg, [[VARNUM]]
     ; CHECK-NEXT:  $rax = MOV64rr [[ARG0VREG]]
bb.0.entry:
     ; CHECK-NEXT:  CMP32ri $esi, 0
     ; CHECK-NEXT:  DBG_VALUE $noreg, $noreg, [[VAR2NUM]]
     ; CHECK-NEXT:  CMP32ri $esi, 0
     ; CHECK-NEXT:  DBG_VALUE 0, $noreg, [[VAR2NUM]]
     ; CHECK-NEXT:  JCC_1 %bb.1, 4
     ; CHECK-NEXT:  JMP_1
 
     %2:gr64 = COPY $rdi
-    %5:gr64 = ADD64ri8 %2, 1, implicit-def dead $eflags
+    %5:gr64 = ADD64ri32 %2, 1, implicit-def dead $eflags
     CMP32ri $esi, 0, implicit-def $eflags
     DBG_VALUE %5, $noreg, !103, !17, debug-location !104
     CMP32ri $esi, 0, implicit-def $eflags
     DBG_VALUE 0, $noreg, !103, !17, debug-location !104
     JCC_1 %bb.1.block1, 4, implicit $eflags
     JMP_1 %bb.2.exit
 
   bb.1.block1:
     successors: %bb.2.exit
 
     ; This block should receive no DBG_VALUE.
     ; CHECK-LABEL: bb.1.block1:
     ; CHECK-NOT:   DBG_VALUE
-    ; CHECK:       [[SUNKVREG2:%[0-9]+]]:gr64 = ADD64ri8 [[TEST2VREG]]
+    ; CHECK:       [[SUNKVREG2:%[0-9]+]]:gr64 = ADD64ri32 [[TEST2VREG]]
     ; CHECK-NOT:   DBG_VALUE
-    ; CHECK-NEXT:  ADD64ri8
+    ; CHECK-NEXT:  ADD64ri32
     ; CHECK: JMP_1 %bb.2
-    %1:gr64 = ADD64ri8 %5, 4, implicit-def dead $eflags
+    %1:gr64 = ADD64ri32 %5, 4, implicit-def dead $eflags
     JMP_1 %bb.2.exit
 
   bb.2.exit:
     $rax = MOV64rr %2
     RET 0
 ...
 ---
 name:            test3
body:             |
   bb.1.block1:
     successors: %bb.2.exit
 
     ; This block should receive no DBG_VALUE.
     ; CHECK-LABEL: bb.1.block1:
     ; CHECK-NOT:   DBG_VALUE
     ; CHECK:       COPY [[TEST3VREG]]
     ; CHECK-NOT:   DBG_VALUE
-    ; CHECK-NEXT:  ADD64ri8
+    ; CHECK-NEXT:  ADD64ri32
     ; CHECK: JMP_1 %bb.2
-    %1:gr64 = ADD64ri8 %5, 4, implicit-def dead $eflags
+    %1:gr64 = ADD64ri32 %5, 4, implicit-def dead $eflags
     JMP_1 %bb.2.exit
 
   bb.2.exit:
     $rax = MOV64rr %2
     RET 0
 ...

llvm/test/DebugInfo/MIR/X86/merge-inline-loc4.mir

 machineFunctionInfo: {}
 body:             |
   bb.0.entry:
     successors: %bb.1(0x00000800), %bb.2(0x7ffff800)
 
     frame-setup PUSH64r undef $rax, implicit-def $rsp, implicit $rsp
     frame-setup CFI_INSTRUCTION def_cfa_offset 16
     renamable $eax = MOV32rm $rip, 1, $noreg, @q1, $noreg, debug-location !12 :: (dereferenceable load (s32) from @q1, !tbaa !13)
-    CMP32ri8 renamable $eax, 4, implicit-def $eflags, debug-location !17
+    CMP32ri renamable $eax, 4, implicit-def $eflags, debug-location !17
     JCC_1 %bb.2, 12, implicit killed $eflags, debug-location !20
     JMP_1 %bb.1, debug-location !20
 
   bb.1.if.then.i:
     successors:
 
     CALL64pcrel32 target-flags(x86-plt) @abort, csr_64, implicit $rsp, implicit $ssp, implicit-def $rsp, implicit-def $ssp, debug-location !21
 
   bb.2.inl5.exit:
     successors: %bb.3(0x00000800), %bb.4(0x7ffff800)
     liveins: $eax
 
     renamable $eax = nsw IMUL32rri killed renamable $eax, 152, implicit-def dead $eflags, debug-location !22
     renamable $eax = nsw ADD32ri8 killed renamable $eax, 100, implicit-def dead $eflags, debug-location !23
     MOV32mr $rip, 1, $noreg, @g1, $noreg, killed renamable $eax, debug-location !24 :: (store (s32) into @g1, !tbaa !13)
-    CMP32mi8 $rip, 1, $noreg, @q2, $noreg, 6, implicit-def $eflags, debug-location !26 :: (dereferenceable load (s32) from @q2, !tbaa !13)
+    CMP32mi $rip, 1, $noreg, @q2, $noreg, 6, implicit-def $eflags, debug-location !26 :: (dereferenceable load (s32) from @q2, !tbaa !13)
     JCC_1 %bb.4, 12, implicit killed $eflags, debug-location !25
     JMP_1 %bb.3, debug-location !25
 
   bb.3.if.then:
     successors:
 
     CALL64pcrel32 target-flags(x86-plt) @abort, csr_64, implicit $rsp, implicit $ssp, implicit-def $rsp, implicit-def $ssp, debug-location !27
 

llvm/test/DebugInfo/MIR/X86/mlicm-hoist-post-regalloc.mir

bb.0.entry:
     %2 = COPY $rdi
     DBG_VALUE %2, _, !17, !DIExpression(), debug-location !18
 
   bb.1.while.body:
     successors: %bb.1.while.body(0x80000000)
 
     %0 = PHI %2, %bb.0.entry, %1, %bb.1.while.body
     DBG_VALUE %0, _, !17, !DIExpression(), debug-location !18
-    %1 = ADD64ri8 %0, 4, implicit-def dead $eflags, debug-location !20
+    %1 = ADD64ri32 %0, 4, implicit-def dead $eflags, debug-location !20
     DBG_VALUE %1, _, !17, !DIExpression(), debug-location !18
     %3 = MOV32rm %0, 1, _, 0, _, debug-location !21 :: (load (s32) from %ir.p.addr.0)
     %4 = MOV64rm $rip, 1, _, target-flags(x86-gotpcrel) @x, _, debug-location !22 :: (load (s64) from got)
     MOV32mr killed %4, 1, _, 0, _, killed %3, debug-location !22 :: (store (s32) into @x)
     JMP_1 %bb.1.while.body, debug-location !23
 
 ...

llvm/test/DebugInfo/X86/debug-loc-asan.mir

bb.0.entry:
     frame-setup PUSH64r killed $rbp, implicit-def $rsp, implicit $rsp
     CFI_INSTRUCTION def_cfa_offset 16
     CFI_INSTRUCTION offset $rbp, -16
     $rbp = frame-setup MOV64rr $rsp
     CFI_INSTRUCTION def_cfa_register $rbp
     $rsp = frame-setup AND64ri8 $rsp, -32, implicit-def dead $eflags
     $rsp = frame-setup SUB64ri32 $rsp, 160, implicit-def dead $eflags
     renamable $rax = LEA64r $rsp, 1, $noreg, 64, $noreg
-    CMP32mi8 $noreg, 1, $noreg, @__asan_option_detect_stack_use_after_return, $noreg, 0, implicit-def $eflags :: (load (s32) from @__asan_option_detect_stack_use_after_return)
+    CMP32mi $noreg, 1, $noreg, @__asan_option_detect_stack_use_after_return, $noreg, 0, implicit-def $eflags :: (load (s32) from @__asan_option_detect_stack_use_after_return)
     $rcx = MOV64rr $rax
     MOV32mr $rsp, 1, $noreg, 60, $noreg, killed $edi :: (store (s32) into %stack.1)
     MOV64mr $rsp, 1, $noreg, 48, $noreg, killed $rax :: (store (s64) into %stack.2)
     MOV64mr $rsp, 1, $noreg, 40, $noreg, killed $rcx :: (store (s64) into %stack.3)
     JCC_1 %bb.2, 4, implicit $eflags
   
   bb.1 (%ir-block.3):
     $edi = MOV32ri 64, implicit-def $rdi

llvm/test/DebugInfo/X86/debug-loc-offset.mir

bb.0.entry:
     CFI_INSTRUCTION def_cfa_offset 8
     CFI_INSTRUCTION offset $ebp, -8
     $ebp = frame-setup MOV32rr $esp
     CFI_INSTRUCTION def_cfa_register $ebp
     $esp = frame-setup SUB32ri8 $esp, 24, implicit-def dead $eflags
     renamable $eax = MOV32rm $ebp, 1, $noreg, 8, $noreg :: (load (s32) from %fixed-stack.1)
     DBG_VALUE renamable $eax, 0, !20, !DIExpression(DW_OP_deref), debug-location !21
     MOV32mi $ebp, 1, $noreg, -4, $noreg, 2, debug-location !23 :: (store (s32) into %ir.z)
-    CMP32mi8 renamable $eax, 1, $noreg, 4, $noreg, 2, implicit-def $eflags, debug-location !24 :: (load (s32) from %ir.var)
+    CMP32mi renamable $eax, 1, $noreg, 4, $noreg, 2, implicit-def $eflags, debug-location !24 :: (load (s32) from %ir.var)
     MOV32mr $ebp, 1, $noreg, -8, $noreg, killed $eax :: (store (s32) into %stack.1)
     DBG_VALUE $ebp, 0, !20, !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref, DW_OP_deref), debug-location !21
     JCC_1 %bb.2, 14, implicit $eflags, debug-location !24
   
   bb.1.if.then:
     DBG_VALUE $ebp, 0, !20, !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref, DW_OP_deref), debug-location !21
     renamable $eax = MOV32rm $ebp, 1, $noreg, -4, $noreg, debug-location !26 :: (load (s32) from %ir.z)
     renamable $eax = ADD32ri8 renamable $eax, 1, implicit-def $eflags, debug-location !26

llvm/test/DebugInfo/X86/location-range.mir

 
 ...
 ---
 name:            funone
 body:             |
   bb.0.entry:
     successors: %bb.1(0x50000000), %bb.2(0x30000000)
 
-    CMP64mi8 $rip, 1, $noreg, @c, $noreg, 0, implicit-def $eflags, debug-location !21 :: (dereferenceable load (s64) from @c)
+    CMP64mi32 $rip, 1, $noreg, @c, $noreg, 0, implicit-def $eflags, debug-location !21 :: (dereferenceable load (s64) from @c)
     JCC_1 %bb.2, 4, implicit killed $eflags, debug-location !27
 
   bb.1.if.then:
     renamable $rax = MOV64rm $rip, 1, $noreg, @b, $noreg, debug-location !21 :: (dereferenceable load (s64) from @b)
     RET64 $rax, debug-location !27
 
   bb.2.if.end:
     DBG_VALUE 0, $noreg, !19, !DIExpression(), debug-location !27

llvm/test/DebugInfo/X86/machinecse-wrongdebug-hoist.ll

 ; RUN: llc %s -o - -print-after=machine-cse -mtriple=x86_64-- 2>&1 | FileCheck %s --match-full-lines
 
-; CHECK: %5:gr32 = SUB32ri8 %0:gr32(tied-def 0), 1, implicit-def $eflags, debug-location !24; a.c:3:13
+; CHECK: %5:gr32 = SUB32ri %0:gr32(tied-def 0), 1, implicit-def $eflags, debug-location !24; a.c:3:13
 ; CHECK-NEXT: %10:gr32 = MOVSX32rr8 %4:gr8
 ; CHECK-NEXT: JCC_1 %bb.2, 15, implicit $eflags, debug-location !25; a.c:3:18
 
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.15.0"
 
 @a = dso_local local_unnamed_addr global i32 0, align 4, !dbg !0
 

llvm/test/DebugInfo/X86/sdag-dbgvalue-ssareg.ll

 source_filename = "debug.c"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: nounwind uwtable
 define dso_local i32 @main(i32 %arg0, i32 %arg1) local_unnamed_addr !dbg !11 {
 entry:
 ; CHECK-LABEL: bb.0.entry:
-; INSTRREF: ADD32ri8 {{.*}} debug-instr-number 1
+; INSTRREF: ADD32ri {{.*}} debug-instr-number 1
   %0 = add i32 %arg0, 42, !dbg !26
   %1 = add i32 %arg1, 101, !dbg !26
   %cmp = icmp eq i32 %1, 0
   br i1 %cmp, label %nextbb, label %exit, !dbg !26
 
 nextbb:
 ; CHECK-LABEL: bb.{{.*}}.nextbb
   %2 = mul i32 %0, %arg1, !dbg !26

llvm/test/DebugInfo/assignment-tracking/X86/lower-to-value.ll

 ; CHECK-NEXT: DBG_VALUE %stack.0.X, $noreg, ![[VAR]], !DIExpression(DW_OP_deref), debug-location
 
 ;; Then there is a store to the upper 64 bits.
 ; CHECK: MOV64mi32 %stack.0.X, 1, $noreg, 8, $noreg, 0, debug-location
 ;; No change in variable location: the stack home is still valid.
 
 ;; The final assignment (X.B += 2) doesn't get stored back to the alloca. This
 ;; means that that the stack location isn't valid for the entire lifetime of X.
-; DBGVALUE: %2:gr64 = nsw ADD64ri8 %1, 2, implicit-def dead $eflags, debug-location
+; DBGVALUE: %2:gr64 = nsw ADD64ri32 %1, 2, implicit-def dead $eflags, debug-location
 ; DBGVALUE-NEXT: DBG_VALUE %2, $noreg, ![[VAR]], !DIExpression(DW_OP_LLVM_fragment, 64, 64), debug-location
-; INSTRREF: %2:gr64 = nsw ADD64ri8 %1, 2, implicit-def dead $eflags, debug-instr-number 1
+; INSTRREF: %2:gr64 = nsw ADD64ri32 %1, 2, implicit-def dead $eflags, debug-instr-number 1
 ; INSTRREF-NEXT: DBG_INSTR_REF ![[VAR]], !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_fragment, 64, 64), dbg-instr-ref(1, 0), debug-location
 
 ;; Bits [0, 64) are still stack homed. FIXME, this particular reinstatement is
 ;; unnecessary.
 ; CHECK-NEXT: DBG_VALUE %stack.0.X, $noreg, ![[VAR]], !DIExpression(DW_OP_deref, DW_OP_LLVM_fragment, 0, 64)
 
 source_filename = "test.cpp"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"

llvm/test/TableGen/x86-fold-tables.inc

 static const X86MemoryFoldTableEntry MemoryFoldTable2Addr[] = {
-  {X86::ADD16ri8_DB, X86::ADD16mi8, TB_NO_REVERSE},
   {X86::ADD16ri_DB, X86::ADD16mi, TB_NO_REVERSE},
   {X86::ADD16rr_DB, X86::ADD16mr, TB_NO_REVERSE},
-  {X86::ADD32ri8_DB, X86::ADD32mi8, TB_NO_REVERSE},
   {X86::ADD32ri_DB, X86::ADD32mi, TB_NO_REVERSE},
   {X86::ADD32rr_DB, X86::ADD32mr, TB_NO_REVERSE},
   {X86::ADD64ri32_DB, X86::ADD64mi32, TB_NO_REVERSE},
-  {X86::ADD64ri8_DB, X86::ADD64mi8, TB_NO_REVERSE},
   {X86::ADD64rr_DB, X86::ADD64mr, TB_NO_REVERSE},
   {X86::ADD8ri_DB, X86::ADD8mi, TB_NO_REVERSE},
   {X86::ADD8rr_DB, X86::ADD8mr, TB_NO_REVERSE},
   {X86::ADC16ri, X86::ADC16mi, 0},
   {X86::ADC16ri8, X86::ADC16mi8, 0},
   {X86::ADC16rr, X86::ADC16mr, 0},
   {X86::ADC32ri, X86::ADC32mi, 0},
   {X86::ADC32ri8, X86::ADC32mi8, 0},

llvm/test/Transforms/SampleProfile/pseudo-probe-twoaddr.ll

 for.body14:                                       ; preds = %for.body14, %for.body14.preheader.new
   %indvars.iv127 = phi i64 [ 1, %for.body14.preheader.new ], [ %indvars.iv.next128.3, %for.body14 ]
   %niter137 = phi i64 [ %unroll_iter136, %for.body14.preheader.new ], [ %niter137.nsub.3, %for.body14 ]
   %indvars.iv.next128.3 = add nuw nsw i64 %indvars.iv127, 4
 ; CHECK: PSEUDO_PROBE -6878943695821059507, 9, 0, 0
   call void @llvm.pseudoprobe(i64 -6878943695821059507, i64 9, i32 0, i64 -1)
 ;; Check an opeq form of instruction is created.
 ; CHECK: %[[#REG:]]:gr64_nosp = COPY killed %[[#]]
-; CHECK: %[[#REG]]:gr64_nosp = nuw ADD64ri8 %[[#REG]], 4, implicit-def dead $eflags
+; CHECK: %[[#REG]]:gr64_nosp = nuw ADD64ri32 %[[#REG]], 4, implicit-def dead $eflags
   %niter137.nsub.3 = add i64 %niter137, -4
   %niter137.ncmp.3 = icmp eq i64 %niter137.nsub.3, 0
   br i1 %niter137.ncmp.3, label %for.cond25.preheader.loopexit.unr-lcssa, label %for.body14
 }
 
 ; Function Attrs: inaccessiblememonly nounwind willreturn
 declare void @llvm.pseudoprobe(i64, i64, i32, i64) #0
 
 attributes #0 = { inaccessiblememonly nounwind willreturn }

llvm/utils/TableGen/X86ManualFoldTables.def

 #undef NOFOLD
 
 #ifndef ENTRY
 #define ENTRY(REG, MEM, FLAGS)
 #endif
 // The following entries are added manually b/c the encodings of reg form does not match the
 // encoding of memory form
 ENTRY(ADD16ri_DB, ADD16mi, TB_NO_REVERSE)
-ENTRY(ADD16ri8_DB, ADD16mi8, TB_NO_REVERSE)
 ENTRY(ADD16rr_DB, ADD16mr, TB_NO_REVERSE)
 ENTRY(ADD32ri_DB, ADD32mi, TB_NO_REVERSE)
-ENTRY(ADD32ri8_DB, ADD32mi8, TB_NO_REVERSE)
 ENTRY(ADD32rr_DB, ADD32mr, TB_NO_REVERSE)
 ENTRY(ADD64ri32_DB, ADD64mi32, TB_NO_REVERSE)
-ENTRY(ADD64ri8_DB, ADD64mi8, TB_NO_REVERSE)
 ENTRY(ADD64rr_DB, ADD64mr, TB_NO_REVERSE)
 ENTRY(ADD8ri_DB, ADD8mi, TB_NO_REVERSE)
 ENTRY(ADD8rr_DB, ADD8mr, TB_NO_REVERSE)
 ENTRY(ADD16rr_DB, ADD16rm, TB_NO_REVERSE)
 ENTRY(ADD32rr_DB, ADD32rm, TB_NO_REVERSE)
 ENTRY(ADD64rr_DB, ADD64rm, TB_NO_REVERSE)
 ENTRY(ADD8rr_DB, ADD8rm, TB_NO_REVERSE)
 ENTRY(MMX_MOVD64from64rr, MMX_MOVQ64mr, TB_FOLDED_STORE)