[mips] [IAS] Improve support for the LI/DLI pseudo-instructions.

[tomatabacu]

Summary

Changed emission of two consecutive DSLL's of 16 into one DSLL32 of 0,
changed helper function to take the shift amount as an argument and to avoid emitting an ORi if the immediate is 0,
improved error reporting,
made the code clearer, rewrote some comments,
and rewrote a couple of tests.

[dsanders]

There seems to be several unrelated changes in this patch. Could you split it up?

[tomatabacu]

Most of this patch has been split up into: D8924 D8968 D8969 D8973 D8974 and rL234584 rL234595.

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

bool MipsAsmParser::needsExpansion(MCInst &Inst) {
   }
 }
 
 bool MipsAsmParser::expandInstruction(MCInst &Inst, SMLoc IDLoc,
                                       SmallVectorImpl<MCInst> &Instructions) {
   switch (Inst.getOpcode()) {
   default: llvm_unreachable("unimplemented expansion");
   case Mips::LoadImm32:
-    return expandLoadImm(Inst, IDLoc, Instructions);
   case Mips::LoadImm64:
-    if (!isGP64bit()) {
-      Error(IDLoc, "instruction requires a 64-bit architecture");
-      return true;
-    }
     return expandLoadImm(Inst, IDLoc, Instructions);
   case Mips::LoadAddrImm32:
     return expandLoadAddressImm(Inst, IDLoc, Instructions);
   case Mips::LoadAddrReg32:
     return expandLoadAddressReg(Inst, IDLoc, Instructions);
   case Mips::B_MM_Pseudo:
     return expandUncondBranchMMPseudo(Inst, IDLoc, Instructions);
   case Mips::SWM_MM:
   case Mips::LWM_MM:
     return expandLoadStoreMultiple(Inst, IDLoc, Instructions);
   case Mips::JalOneReg:
   case Mips::JalTwoReg:
     return expandJalWithRegs(Inst, IDLoc, Instructions);
   }
 }
 
 namespace {
-template <bool PerformShift>
-void createShiftOr(MCOperand Operand, unsigned RegNo, SMLoc IDLoc,
+template <unsigned ShiftAmount>
+void createLShiftOri(MCOperand Operand, unsigned RegNo, SMLoc IDLoc,
                      SmallVectorImpl<MCInst> &Instructions) {
   MCInst tmpInst;
-  if (PerformShift) {
+  if (ShiftAmount >= 32) {
+    tmpInst.setOpcode(Mips::DSLL32);
+    tmpInst.addOperand(MCOperand::CreateReg(RegNo));
+    tmpInst.addOperand(MCOperand::CreateReg(RegNo));
+    tmpInst.addOperand(MCOperand::CreateImm(ShiftAmount - 32));
+    tmpInst.setLoc(IDLoc);
+    Instructions.push_back(tmpInst);
+    tmpInst.clear();
+  } else if (ShiftAmount > 0) {
     tmpInst.setOpcode(Mips::DSLL);
     tmpInst.addOperand(MCOperand::CreateReg(RegNo));
     tmpInst.addOperand(MCOperand::CreateReg(RegNo));
-    tmpInst.addOperand(MCOperand::CreateImm(16));
+    tmpInst.addOperand(MCOperand::CreateImm(ShiftAmount));
     tmpInst.setLoc(IDLoc);
     Instructions.push_back(tmpInst);
     tmpInst.clear();
   }
+  // There's no need for an ORi, if the immediate is 0.
+  if (Operand.isImm() && Operand.getImm() == 0)
+    return;
+
   tmpInst.setOpcode(Mips::ORi);
   tmpInst.addOperand(MCOperand::CreateReg(RegNo));
   tmpInst.addOperand(MCOperand::CreateReg(RegNo));
   tmpInst.addOperand(Operand);
   tmpInst.setLoc(IDLoc);
   Instructions.push_back(tmpInst);
 }
 
-template <int Shift, bool PerformShift>
-void createShiftOr(int64_t Value, unsigned RegNo, SMLoc IDLoc,
+template <unsigned ShiftAmount>
+void createLShiftOri(int64_t Value, unsigned RegNo, SMLoc IDLoc,
                      SmallVectorImpl<MCInst> &Instructions) {
-  createShiftOr<PerformShift>(
-      MCOperand::CreateImm(((Value & (0xffffLL << Shift)) >> Shift)), RegNo,
-      IDLoc, Instructions);
+  createLShiftOri<ShiftAmount>(MCOperand::CreateImm(Value), RegNo, IDLoc,
+                               Instructions);
 }
 }
 
 bool MipsAsmParser::expandJalWithRegs(MCInst &Inst, SMLoc IDLoc,
                                       SmallVectorImpl<MCInst> &Instructions) {
   // Create a JALR instruction which is going to replace the pseudo-JAL.
   MCInst JalrInst;
   JalrInst.setLoc(IDLoc);
if (AssemblerOptions.back()->isReorder()) {
     Instructions.push_back(NopInst);
   }
 
   return false;
 }
 
 bool MipsAsmParser::expandLoadImm(MCInst &Inst, SMLoc IDLoc,
                                   SmallVectorImpl<MCInst> &Instructions) {
+  if (Inst.getOpcode() == Mips::LoadImm64 && !isGP64bit()) {
+    Error(IDLoc, "instruction requires a 64-bit architecture");
+    return true;
+  }
+
   MCInst tmpInst;
   const MCOperand &ImmOp = Inst.getOperand(1);
   assert(ImmOp.isImm() && "expected immediate operand kind");
   const MCOperand &RegOp = Inst.getOperand(0);
   assert(RegOp.isReg() && "expected register operand kind");
 
   int64_t ImmValue = ImmOp.getImm();
+  unsigned Reg = RegOp.getReg();
   tmpInst.setLoc(IDLoc);
   // FIXME: gas has a special case for values that are 000...1111, which
   // becomes a li -1 and then a dsrl
   if (0 <= ImmValue && ImmValue <= 65535) {
-    // For 0 <= j <= 65535.
+    // For unsigned 16-bit values and positive signed 16-bit values
+    // (0 <= j <= 65535) expand to:
     // li d,j => ori d,$zero,j
     tmpInst.setOpcode(Mips::ORi);
-    tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
+    tmpInst.addOperand(MCOperand::CreateReg(Reg));
     tmpInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
     tmpInst.addOperand(MCOperand::CreateImm(ImmValue));
     Instructions.push_back(tmpInst);
   } else if (ImmValue < 0 && ImmValue >= -32768) {
-    // For -32768 <= j < 0.
+    // For negative signed 16-bit values (-32768 <= j < 0) expand to:
     // li d,j => addiu d,$zero,j
     tmpInst.setOpcode(Mips::ADDiu);
-    tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
+    tmpInst.addOperand(MCOperand::CreateReg(Reg));
     tmpInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
     tmpInst.addOperand(MCOperand::CreateImm(ImmValue));
     Instructions.push_back(tmpInst);
   } else if ((ImmValue & 0xffffffff) == ImmValue) {
-    // For any value of j that is representable as a 32-bit integer, create
-    // a sequence of:
+    // For all other 32-bit values expand to:
     // li d,j => lui d,hi16(j)
     //           ori d,d,lo16(j)
+    uint16_t Hi16 = (ImmValue & (0xffffLL << 16)) >> 16;
+    uint16_t Lo16 = ImmValue & 0xffffLL;
+
     tmpInst.setOpcode(Mips::LUi);
-    tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
-    tmpInst.addOperand(MCOperand::CreateImm((ImmValue & 0xffff0000) >> 16));
+    tmpInst.addOperand(MCOperand::CreateReg(Reg));
+    tmpInst.addOperand(MCOperand::CreateImm(Hi16));
     Instructions.push_back(tmpInst);
-    createShiftOr<0, false>(ImmValue, RegOp.getReg(), IDLoc, Instructions);
+
+    createLShiftOri<0>(Lo16, Reg, IDLoc, Instructions);
   } else if ((ImmValue & (0xffffLL << 48)) == 0) {
-    if (!isGP64bit()) {
-      Error(IDLoc, "instruction requires a 64-bit architecture");
+    if (Inst.getOpcode() == Mips::LoadImm32) {
+      Error(IDLoc, "instruction requires a 32-bit immediate");
       return true;
     }
-
     //            <-------  lo32 ------>
     // <-------  hi32 ------>
     // <- hi16 ->             <- lo16 ->
     //  _________________________________
     // |          |          |          |
     // | 16-bytes | 16-bytes | 16-bytes |
     // |__________|__________|__________|
     //
-    // For any value of j that is representable as a 48-bit integer, create
-    // a sequence of:
-    // li d,j => lui d,hi16(j)
+    // For any 64-bit value that is representable as a 48-bit integer expand to:
+    // li d,j => lui d,lo16(hi32(j))
     //           ori d,d,hi16(lo32(j))
     //           dsll d,d,16
     //           ori d,d,lo16(lo32(j))
+    uint16_t Lo16OfHi32 = (ImmValue & (0xffffLL << 32)) >> 32;
+    uint16_t Hi16OfLo32 = (ImmValue & (0xffffLL << 16)) >> 16;
+    uint16_t Lo16OfLo32 = ImmValue & 0xffffLL;
+
     tmpInst.setOpcode(Mips::LUi);
-    tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
-    tmpInst.addOperand(
-        MCOperand::CreateImm((ImmValue & (0xffffLL << 32)) >> 32));
+    tmpInst.addOperand(MCOperand::CreateReg(Reg));
+    tmpInst.addOperand(MCOperand::CreateImm(Lo16OfHi32));
     Instructions.push_back(tmpInst);
-    createShiftOr<16, false>(ImmValue, RegOp.getReg(), IDLoc, Instructions);
-    createShiftOr<0, true>(ImmValue, RegOp.getReg(), IDLoc, Instructions);
+
+    createLShiftOri<0>(Hi16OfLo32, Reg, IDLoc, Instructions);
+    createLShiftOri<16>(Lo16OfLo32, Reg, IDLoc, Instructions);
   } else {
-    if (!isGP64bit()) {
-      Error(IDLoc, "instruction requires a 64-bit architecture");
+    if (Inst.getOpcode() == Mips::LoadImm32) {
+      Error(IDLoc, "instruction requires a 32-bit immediate");
       return true;
     }
-
     // <-------  hi32 ------> <-------  lo32 ------>
     // <- hi16 ->                        <- lo16 ->
     //  ___________________________________________
     // |          |          |          |          |
     // | 16-bytes | 16-bytes | 16-bytes | 16-bytes |
     // |__________|__________|__________|__________|
     //
-    // For any value of j that isn't representable as a 48-bit integer.
-    // li d,j => lui d,hi16(j)
+    // For 64-bit values which don't fit in 48 bits expand to:
+    // li d,j => lui d,hi16(hi32(j))
     //           ori d,d,lo16(hi32(j))
     //           dsll d,d,16
     //           ori d,d,hi16(lo32(j))
     //           dsll d,d,16
     //           ori d,d,lo16(lo32(j))
+    uint16_t Hi16OfHi32 = (ImmValue & (0xffffLL << 48)) >> 48;
+    uint16_t Lo16OfHi32 = (ImmValue & (0xffffLL << 32)) >> 32;
+    uint16_t Hi16OfLo32 = (ImmValue & (0xffffLL << 16)) >> 16;
+    uint16_t Lo16OfLo32 = ImmValue & 0xffffLL;
+
     tmpInst.setOpcode(Mips::LUi);
-    tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
-    tmpInst.addOperand(
-        MCOperand::CreateImm((ImmValue & (0xffffLL << 48)) >> 48));
+    tmpInst.addOperand(MCOperand::CreateReg(Reg));
+    tmpInst.addOperand(MCOperand::CreateImm(Hi16OfHi32));
     Instructions.push_back(tmpInst);
-    createShiftOr<32, false>(ImmValue, RegOp.getReg(), IDLoc, Instructions);
-    createShiftOr<16, true>(ImmValue, RegOp.getReg(), IDLoc, Instructions);
-    createShiftOr<0, true>(ImmValue, RegOp.getReg(), IDLoc, Instructions);
+    createLShiftOri<0>(Lo16OfHi32, Reg, IDLoc, Instructions);
+
+    // When Hi16OfLo32 is 0, do a left shift of 32 bits instead of doing
+    // two left shifts of 16 bits.
+    if (Hi16OfLo32 == 0) {
+      createLShiftOri<32>(0, Reg, IDLoc, Instructions);
+      createLShiftOri<0>(Lo16OfLo32, Reg, IDLoc, Instructions);
+    } else {
+      createLShiftOri<16>(Hi16OfLo32, Reg, IDLoc, Instructions);
+      createLShiftOri<16>(Lo16OfLo32, Reg, IDLoc, Instructions);
+    }
   }
   return false;
 }
 
 bool
 MipsAsmParser::expandLoadAddressReg(MCInst &Inst, SMLoc IDLoc,
                                     SmallVectorImpl<MCInst> &Instructions) {
   MCInst tmpInst;
const MCSymbolRefExpr *HigherExpr =
         MCSymbolRefExpr::Create(Symbol->getSymbol().getName(),
                                 MCSymbolRefExpr::VK_Mips_HIGHER, getContext());
 
     tmpInst.setOpcode(Mips::LUi);
     tmpInst.addOperand(MCOperand::CreateReg(RegNo));
     tmpInst.addOperand(MCOperand::CreateExpr(HighestExpr));
     Instructions.push_back(tmpInst);
 
-    createShiftOr<false>(MCOperand::CreateExpr(HigherExpr), RegNo, SMLoc(),
-                         Instructions);
-    createShiftOr<true>(MCOperand::CreateExpr(HiExpr), RegNo, SMLoc(),
+    createLShiftOri<0>(MCOperand::CreateExpr(HigherExpr), RegNo, SMLoc(),
+    createLShiftOri<16>(MCOperand::CreateExpr(HiExpr), RegNo, SMLoc(),
                         Instructions);
-    createShiftOr<true>(MCOperand::CreateExpr(LoExpr), RegNo, SMLoc(),
+    createLShiftOri<16>(MCOperand::CreateExpr(LoExpr), RegNo, SMLoc(),
                         Instructions);
   } else {
     // Otherwise, expand to:
     // la d,sym => lui  d,hi16(sym)
     //             ori  d,d,lo16(sym)
     tmpInst.setOpcode(Mips::LUi);
     tmpInst.addOperand(MCOperand::CreateReg(RegNo));
     tmpInst.addOperand(MCOperand::CreateExpr(HiExpr));
     Instructions.push_back(tmpInst);
 
-    createShiftOr<false>(MCOperand::CreateExpr(LoExpr), RegNo, SMLoc(),
-                         Instructions);
+    createLShiftOri<0>(MCOperand::CreateExpr(LoExpr), RegNo, SMLoc(),
   }
 }
 
 bool MipsAsmParser::expandUncondBranchMMPseudo(
     MCInst &Inst, SMLoc IDLoc, SmallVectorImpl<MCInst> &Instructions) {
   assert(getInstDesc(Inst.getOpcode()).getNumOperands() == 1 &&
          "unexpected number of operands");
 

test/MC/Mips/mips-expansions-bad.s

-# RUN: not llvm-mc %s -arch=mips -mcpu=mips32r2 2>%t1
-# RUN: FileCheck %s < %t1
+# RUN: not llvm-mc %s -arch=mips -mcpu=mips32r2 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=32-BIT
+
+# RUN: not llvm-mc %s -arch=mips64 -mcpu=mips64 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=64-BIT
 
-        .text
-        li $5, 0x100000000 # CHECK: :[[@LINE]]:9: error: instruction requires a 64-bit architecture
-        dli $5, 1 # CHECK: :[[@LINE]]:9: error: instruction requires a 64-bit architecture
+  li  $5, 0x100000000
+  # 32-BIT: :[[@LINE-1]]:3: error: instruction requires a 32-bit immediate
+  # 64-BIT: :[[@LINE-2]]:3: error: instruction requires a 32-bit immediate
+
+  dli $5, 1
+  # 32-BIT: :[[@LINE-1]]:3: error: instruction requires a 64-bit architecture

test/MC/Mips/mips-expansions.s

 # RUN: llvm-mc %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips32r2 | FileCheck %s
 # Check that the assembler can handle the documented syntax
 # for macro instructions
 #------------------------------------------------------------------------------
 # Load immediate instructions
 #------------------------------------------------------------------------------
 # CHECK: ori     $5, $zero, 123      # encoding: [0x7b,0x00,0x05,0x34]
 # CHECK: addiu   $6, $zero, -2345    # encoding: [0xd7,0xf6,0x06,0x24]
 # CHECK: lui     $7, 1               # encoding: [0x01,0x00,0x07,0x3c]
 # CHECK: ori     $7, $7, 2           # encoding: [0x02,0x00,0xe7,0x34]
 # CHECK: addiu   $8, $zero, -8       # encoding: [0xf8,0xff,0x08,0x24]
+# CHECK: lui     $9, 1               # encoding: [0x01,0x00,0x09,0x3c]
+# CHECK-NOT: ori $9, $9, 0           # encoding: [0x00,0x00,0x29,0x35]
 
 # CHECK: addiu   $4, $zero, 20       # encoding: [0x14,0x00,0x04,0x24]
 # CHECK: lui     $7, 1               # encoding: [0x01,0x00,0x07,0x3c]
 # CHECK: ori     $7, $7, 2           # encoding: [0x02,0x00,0xe7,0x34]
 # CHECK: addiu   $4, $5, 20          # encoding: [0x14,0x00,0xa4,0x24]
 # CHECK: lui     $7, 1               # encoding: [0x01,0x00,0x07,0x3c]
 # CHECK: ori     $7, $7, 2           # encoding: [0x02,0x00,0xe7,0x34]
 # CHECK: addu    $7, $7, $8          # encoding: [0x21,0x38,0xe8,0x00]

 # CHECK: ldc1    $f0, %lo(symbol)($1)
 # CHECK: lui     $1, %hi(symbol)
 # CHECK: sdc1    $f0, %lo(symbol)($1)
 
     li $5,123
     li $6,-2345
     li $7,65538
     li $8, ~7
+    li $9, 0x10000
 
     la $a0, 20
     la $7,65538
     la $a0, 20($a1)
     la $7,65538($8)
     la $t0, symbol
     .set mips64
     la $t0, symbol

test/MC/Mips/mips64-expansions.s

 # RUN: llvm-mc %s -triple=mips64el-unknown-linux -show-encoding -mcpu=mips64r2 | FileCheck %s
 #
-# The GNU assembler implements 'dli' and 'dla' variants on 'li' and 'la'
-# supporting double-word lengths.  Test that not only are they present, bu
-# that they also seem to handle 64-bit values.
-#
-# XXXRW: Does using powers of ten make me a bad person?
-#
-# CHECK: ori  $12, $zero, 1           # encoding: [0x01,0x00,0x0c,0x34]
-# CHECK: ori  $12, $zero, 10          # encoding: [0x0a,0x00,0x0c,0x34]
-# CHECK: ori  $12, $zero, 100         # encoding: [0x64,0x00,0x0c,0x34]
-# CHECK: ori  $12, $zero, 1000        # encoding: [0xe8,0x03,0x0c,0x34]
-# CHECK: ori  $12, $zero, 10000       # encoding: [0x10,0x27,0x0c,0x34]
-# CHECK: lui  $12, 1                  # encoding: [0x01,0x00,0x0c,0x3c]
-# CHECK: ori  $12, $12, 34464         # encoding: [0xa0,0x86,0x8c,0x35]
-# CHECK: lui  $12, 15                 # encoding: [0x0f,0x00,0x0c,0x3c]
-# CHECK: ori  $12, $12, 16960         # encoding: [0x40,0x42,0x8c,0x35]
-# CHECK: lui  $12, 152                # encoding: [0x98,0x00,0x0c,0x3c]
-# CHECK: ori  $12, $12, 38528         # encoding: [0x80,0x96,0x8c,0x35]
-# CHECK: lui  $12, 1525               # encoding: [0xf5,0x05,0x0c,0x3c]
-# CHECK: ori  $12, $12, 57600         # encoding: [0x00,0xe1,0x8c,0x35]
-# CHECK: lui  $12, 15258              # encoding: [0x9a,0x3b,0x0c,0x3c]
-# CHECK: ori  $12, $12, 51712         # encoding: [0x00,0xca,0x8c,0x35]
-# CHECK: lui  $12, 2                  # encoding: [0x02,0x00,0x0c,0x3c]
-# CHECK: ori  $12, $12, 21515         # encoding: [0x0b,0x54,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 58368         # encoding: [0x00,0xe4,0x8c,0x35]
-# CHECK: lui  $12, 23                 # encoding: [0x17,0x00,0x0c,0x3c]
-# CHECK: ori  $12, $12, 18550         # encoding: [0x76,0x48,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 59392         # encoding: [0x00,0xe8,0x8c,0x35]
-# CHECK: lui  $12, 232                # encoding: [0xe8,0x00,0x0c,0x3c]
-# CHECK: ori  $12, $12, 54437         # encoding: [0xa5,0xd4,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 4096          # encoding: [0x00,0x10,0x8c,0x35]
-# CHECK: lui  $12, 2328               # encoding: [0x18,0x09,0x0c,0x3c]
-# CHECK: ori  $12, $12, 20082         # encoding: [0x72,0x4e,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 40960         # encoding: [0x00,0xa0,0x8c,0x35]
-# CHECK: lui  $12, 23283              # encoding: [0xf3,0x5a,0x0c,0x3c]
-# CHECK: ori  $12, $12, 4218          # encoding: [0x7a,0x10,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 16384         # encoding: [0x00,0x40,0x8c,0x35]
-# CHECK: lui  $12, 3                  # encoding: [0x03,0x00,0x0c,0x3c]
-# CHECK: ori  $12, $12, 36222         # encoding: [0x7e,0x8d,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 42182         # encoding: [0xc6,0xa4,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 32768         # encoding: [0x00,0x80,0x8c,0x35]
-# CHECK: lui  $12, 35                 # encoding: [0x23,0x00,0x0c,0x3c]
-# CHECK: ori  $12, $12, 34546         # encoding: [0xf2,0x86,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 28609         # encoding: [0xc1,0x6f,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 0             # encoding: [0x00,0x00,0x8c,0x35]
-# CHECK: lui  $12, 355                # encoding: [0x63,0x01,0x0c,0x3c]
-# CHECK: ori  $12, $12, 17784         # encoding: [0x78,0x45,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 23946         # encoding: [0x8a,0x5d,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 0             # encoding: [0x00,0x00,0x8c,0x35]
-# CHECK: lui  $12, 3552               # encoding: [0xe0,0x0d,0x0c,0x3c]
-# CHECK: ori  $12, $12, 46771         # encoding: [0xb3,0xb6,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 42852         # encoding: [0x64,0xa7,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 0             # encoding: [0x00,0x00,0x8c,0x35]
-# CHECK: lui  $12, 35527              # encoding: [0xc7,0x8a,0x0c,0x3c]
-# CHECK: ori  $12, $12, 8964          # encoding: [0x04,0x23,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 35304         # encoding: [0xe8,0x89,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 0             # encoding: [0x00,0x00,0x8c,0x35]
-# CHECK: addiu  $12, $zero, -1          # encoding: [0xff,0xff,0x0c,0x24]
-# CHECK: addiu  $12, $zero, -10         # encoding: [0xf6,0xff,0x0c,0x24]
-# CHECK: addiu  $12, $zero, -100        # encoding: [0x9c,0xff,0x0c,0x24]
-# CHECK: addiu  $12, $zero, -1000       # encoding: [0x18,0xfc,0x0c,0x24]
-# CHECK: addiu  $12, $zero, -10000      # encoding: [0xf0,0xd8,0x0c,0x24]
-# CHECK: lui  $12, 65535              # encoding: [0xff,0xff,0x0c,0x3c]
-# CHECK: ori  $12, $12, 65535         # encoding: [0xff,0xff,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 65534         # encoding: [0xfe,0xff,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 31072         # encoding: [0x60,0x79,0x8c,0x35]
-# CHECK: lui  $12, 65535              # encoding: [0xff,0xff,0x0c,0x3c]
-# CHECK: ori  $12, $12, 65535         # encoding: [0xff,0xff,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 65520         # encoding: [0xf0,0xff,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 48576         # encoding: [0xc0,0xbd,0x8c,0x35]
-# CHECK: lui  $12, 65535              # encoding: [0xff,0xff,0x0c,0x3c]
-# CHECK: ori  $12, $12, 65535         # encoding: [0xff,0xff,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 65383         # encoding: [0x67,0xff,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 27008         # encoding: [0x80,0x69,0x8c,0x35]
-# CHECK: lui  $12, 65535              # encoding: [0xff,0xff,0x0c,0x3c]
-# CHECK: ori  $12, $12, 65535         # encoding: [0xff,0xff,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 64010         # encoding: [0x0a,0xfa,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 7936          # encoding: [0x00,0x1f,0x8c,0x35]
-# CHECK: lui  $12, 65535              # encoding: [0xff,0xff,0x0c,0x3c]
-# CHECK: ori  $12, $12, 65535         # encoding: [0xff,0xff,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 50277         # encoding: [0x65,0xc4,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 13824         # encoding: [0x00,0x36,0x8c,0x35]
-# CHECK: lui  $12, 65535              # encoding: [0xff,0xff,0x0c,0x3c]
-# CHECK: ori  $12, $12, 65533         # encoding: [0xfd,0xff,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 44020         # encoding: [0xf4,0xab,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 7168          # encoding: [0x00,0x1c,0x8c,0x35]
-# CHECK: lui  $12, 65535              # encoding: [0xff,0xff,0x0c,0x3c]
-# CHECK: ori  $12, $12, 65512         # encoding: [0xe8,0xff,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 46985         # encoding: [0x89,0xb7,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 6144          # encoding: [0x00,0x18,0x8c,0x35]
-# CHECK: lui  $12, 65535              # encoding: [0xff,0xff,0x0c,0x3c]
-# CHECK: ori  $12, $12, 65303         # encoding: [0x17,0xff,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 11098         # encoding: [0x5a,0x2b,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 61440         # encoding: [0x00,0xf0,0x8c,0x35]
-# CHECK: lui  $12, 65535              # encoding: [0xff,0xff,0x0c,0x3c]
-# CHECK: ori  $12, $12, 63207         # encoding: [0xe7,0xf6,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 45453         # encoding: [0x8d,0xb1,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 24576         # encoding: [0x00,0x60,0x8c,0x35]
-# CHECK: lui  $12, 65535              # encoding: [0xff,0xff,0x0c,0x3c]
-# CHECK: ori  $12, $12, 42252         # encoding: [0x0c,0xa5,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 61317         # encoding: [0x85,0xef,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 49152         # encoding: [0x00,0xc0,0x8c,0x35]
-# CHECK: lui  $12, 65532              # encoding: [0xfc,0xff,0x0c,0x3c]
-# CHECK: ori  $12, $12, 29313         # encoding: [0x81,0x72,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 23353         # encoding: [0x39,0x5b,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 32768         # encoding: [0x00,0x80,0x8c,0x35]
-# CHECK: lui  $12, 65500              # encoding: [0xdc,0xff,0x0c,0x3c]
-# CHECK: ori  $12, $12, 30989         # encoding: [0x0d,0x79,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 36927         # encoding: [0x3f,0x90,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 0             # encoding: [0x00,0x00,0x8c,0x35]
-# CHECK: lui  $12, 65180              # encoding: [0x9c,0xfe,0x0c,0x3c]
-# CHECK: ori  $12, $12, 47751         # encoding: [0x87,0xba,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 41590         # encoding: [0x76,0xa2,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 0             # encoding: [0x00,0x00,0x8c,0x35]
-# CHECK: lui  $12, 61983              # encoding: [0x1f,0xf2,0x0c,0x3c]
-# CHECK: ori  $12, $12, 18764         # encoding: [0x4c,0x49,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 22684         # encoding: [0x9c,0x58,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 0             # encoding: [0x00,0x00,0x8c,0x35]
-# CHECK: lui  $12, 30008              # encoding: [0x38,0x75,0x0c,0x3c]
-# CHECK: ori  $12, $12, 56571         # encoding: [0xfb,0xdc,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 30232         # encoding: [0x18,0x76,0x8c,0x35]
-# CHECK: dsll $12, $12, 16            # encoding: [0x38,0x64,0x0c,0x00]
-# CHECK: ori  $12, $12, 0             # encoding: [0x00,0x00,0x8c,0x35]
-
-  dli  $t0, 1
-  dli  $t0, 10
-  dli  $t0, 100
-  dli  $t0, 1000
-  dli  $t0, 10000
-  dli  $t0, 100000
-  dli  $t0, 1000000
-  dli  $t0, 10000000
-  dli  $t0, 100000000
-  dli  $t0, 1000000000
-  dli  $t0, 10000000000
-  dli $t0, 100000000000
-  dli $t0, 1000000000000
-  dli $t0, 10000000000000
-  dli $t0, 100000000000000
-  dli $t0, 1000000000000000
-  dli $t0, 10000000000000000
-  dli $t0, 100000000000000000
-  dli $t0, 1000000000000000000
-  dli $t0, 10000000000000000000
-  dli $t0, -1
-  dli $t0, -10
-  dli $t0, -100
-  dli $t0, -1000
-  dli $t0, -10000
-  dli $t0, -100000
-  dli $t0, -1000000
-  dli $t0, -10000000
-  dli $t0, -100000000
-  dli $t0, -1000000000
-  dli $t0, -10000000000
-  dli $t0, -100000000000
-  dli $t0, -1000000000000
-  dli $t0, -10000000000000
-  dli $t0, -100000000000000
-  dli $t0, -1000000000000000
-  dli $t0, -10000000000000000
-  dli $t0, -100000000000000000
-  dli $t0, -1000000000000000000
-  dli $t0, -10000000000000000000
+# Test the 'dli' and 'dla' 64-bit variants of 'li' and 'la'.
+
+# Immediate is <= 32 bits.
+  dli $5, 123
+# CHECK:     ori   $5, $zero, 123   # encoding: [0x7b,0x00,0x05,0x34]
+
+  dli $6, -2345
+# CHECK:     addiu $6, $zero, -2345 # encoding: [0xd7,0xf6,0x06,0x24]
+
+  dli $7, 65538
+# CHECK:     lui   $7, 1            # encoding: [0x01,0x00,0x07,0x3c]
+# CHECK:     ori   $7, $7, 2        # encoding: [0x02,0x00,0xe7,0x34]
+
+  dli $8, ~7
+# CHECK:     addiu $8, $zero, -8    # encoding: [0xf8,0xff,0x08,0x24]
+
+  dli $9, 0x10000
+# CHECK:     lui   $9, 1            # encoding: [0x01,0x00,0x09,0x3c]
+# CHECK-NOT: ori   $9, $9, 0        # encoding: [0x00,0x00,0x29,0x35]
+
+
+# Positive immediate which is => 32 bits and <= 48 bits.
+  dli $8, 0x100000000
+# CHECK: lui  $8, 1                 # encoding: [0x01,0x00,0x08,0x3c]
+# CHECK: dsll $8, $8, 16            # encoding: [0x38,0x44,0x08,0x00]
+
+  dli $8, 0x100000001
+# CHECK: lui  $8, 1                 # encoding: [0x01,0x00,0x08,0x3c]
+# CHECK: dsll $8, $8, 16            # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori  $8, $8, 1             # encoding: [0x01,0x00,0x08,0x35]
+
+  dli $8, 0x100010000
+# CHECK: lui  $8, 1                 # encoding: [0x01,0x00,0x08,0x3c]
+# CHECK: ori  $8, $8, 1             # encoding: [0x01,0x00,0x08,0x35]
+# CHECK: dsll $8, $8, 16            # encoding: [0x38,0x44,0x08,0x00]
+
+  dli $8, 0x100010001
+# CHECK: lui  $8, 1                 # encoding: [0x01,0x00,0x08,0x3c]
+# CHECK: ori  $8, $8, 1             # encoding: [0x01,0x00,0x08,0x35]
+# CHECK: dsll $8, $8, 16            # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori  $8, $8, 1             # encoding: [0x01,0x00,0x08,0x35]
+
+
+# Positive immediate which is > 48 bits.
+  dli $8, 0x1000000000000
+# CHECK: lui    $8, 1               # encoding: [0x01,0x00,0x08,0x3c]
+# CHECK: dsll32 $8, $8, 0           # encoding: [0x3c,0x40,0x08,0x00]
+
+  dli $8, 0x1000000000001
+# CHECK: lui    $8, 1               # encoding: [0x01,0x00,0x08,0x3c]
+# CHECK: dsll32 $8, $8, 0           # encoding: [0x3c,0x40,0x08,0x00]
+# CHECK: ori    $8, $8, 1           # encoding: [0x01,0x00,0x08,0x35]
+
+  dli $8, 0x1000000010000
+# CHECK: lui    $8, 1               # encoding: [0x01,0x00,0x08,0x3c]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 1           # encoding: [0x01,0x00,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+
+  dli $8, 0x1000100000000
+# CHECK: lui    $8, 1               # encoding: [0x01,0x00,0x08,0x3c]
+# CHECK: ori    $8, $8, 1           # encoding: [0x01,0x00,0x08,0x35]
+# CHECK: dsll32 $8, $8, 0           # encoding: [0x3c,0x40,0x08,0x00]
+
+  dli $8, 0x1000000010001
+# CHECK: lui    $8, 1               # encoding: [0x01,0x00,0x08,0x3c]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 1           # encoding: [0x01,0x00,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 1           # encoding: [0x01,0x00,0x08,0x35]
+
+  dli $8, 0x1000100010000
+# CHECK: lui    $8, 1               # encoding: [0x01,0x00,0x08,0x3c]
+# CHECK: ori    $8, $8, 1           # encoding: [0x01,0x00,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 1           # encoding: [0x01,0x00,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+
+  dli $8, 0x1000100000001
+# CHECK: lui    $8, 1               # encoding: [0x01,0x00,0x08,0x3c]
+# CHECK: ori    $8, $8, 1           # encoding: [0x01,0x00,0x08,0x35]
+# CHECK: dsll32 $8, $8, 0           # encoding: [0x3c,0x40,0x08,0x00]
+# CHECK: ori    $8, $8, 1           # encoding: [0x01,0x00,0x08,0x35]
+
+  dli $8, 0x1000100010001
+# CHECK: lui    $8, 1               # encoding: [0x01,0x00,0x08,0x3c]
+# CHECK: ori    $8, $8, 1           # encoding: [0x01,0x00,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 1           # encoding: [0x01,0x00,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 1           # encoding: [0x01,0x00,0x08,0x35]
+
+
+# Negative immediate which is => 32 bits and <= 48 bits.
+  dli $8, -0x100000000
+# CHECK: lui    $8, 65535           # encoding: [0xff,0xff,0x08,0x3c]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+# CHECK: dsll32 $8, $8, 0           # encoding: [0x3c,0x40,0x08,0x00]
+
+  dli $8, -0x100000001
+# CHECK: lui    $8, 65535           # encoding: [0xff,0xff,0x08,0x3c]
+# CHECK: ori    $8, $8, 65534       # encoding: [0xfe,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+
+  dli $8, -0x100010000
+# CHECK: lui    $8, 65535           # encoding: [0xff,0xff,0x08,0x3c]
+# CHECK: ori    $8, $8, 65534       # encoding: [0xfe,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+
+  dli $8, -0x100010001
+# CHECK: lui    $8, 65535           # encoding: [0xff,0xff,0x08,0x3c]
+# CHECK: ori    $8, $8, 65534       # encoding: [0xfe,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65534       # encoding: [0xfe,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+
+
+# Negative immediate which is > 48 bits.
+  dli $8, -0x1000000000000
+# CHECK: lui    $8, 65535           # encoding: [0xff,0xff,0x08,0x3c]
+# CHECK: dsll32 $8, $8, 0           # encoding: [0x3c,0x40,0x08,0x00]
+
+  dli $8, -0x1000000000001
+# CHECK: lui    $8, 65534           # encoding: [0xfe,0xff,0x08,0x3c]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+
+  dli $8, -0x1000000010000
+# CHECK: lui    $8, 65534           # encoding: [0xfe,0xff,0x08,0x3c]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+
+  dli $8, -0x1000100000000
+# CHECK: lui    $8, 65534           # encoding: [0xfe,0xff,0x08,0x3c]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+# CHECK: dsll32 $8, $8, 0           # encoding: [0x3c,0x40,0x08,0x00]
+
+  dli $8, -0x1000000010001
+# CHECK: lui    $8, 65534           # encoding: [0xfe,0xff,0x08,0x3c]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65534       # encoding: [0xfe,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+
+  dli $8, -0x1000100010000
+# CHECK: lui    $8, 65534           # encoding: [0xfe,0xff,0x08,0x3c]
+# CHECK: ori    $8, $8, 65534       # encoding: [0xfe,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+
+  dli $8, -0x1000100000001
+# CHECK: lui    $8, 65534           # encoding: [0xfe,0xff,0x08,0x3c]
+# CHECK: ori    $8, $8, 65534       # encoding: [0xfe,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]
+
+  dli $8, -0x1000100010001
+# CHECK: lui    $8, 65534           # encoding: [0xfe,0xff,0x08,0x3c]
+# CHECK: ori    $8, $8, 65534       # encoding: [0xfe,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65534       # encoding: [0xfe,0xff,0x08,0x35]
+# CHECK: dsll   $8, $8, 16          # encoding: [0x38,0x44,0x08,0x00]
+# CHECK: ori    $8, $8, 65535       # encoding: [0xff,0xff,0x08,0x35]