[mips] Add support for unaligned load/store macros.

Add missing unaligned store macros (ush/usw) and fix the exisiting
implementation of the unaligned load macros in order to generate
identical expansions with the GNU assembler.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@287646 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Target/Mips/AsmParser/MipsAsmParser.cpp b/lib/Target/Mips/AsmParser/MipsAsmParser.cpp
index 8daba92d3541b77cecb0eff5f3988ad19fc34d18..1be67ab7cfc163182cf5b2eb2ff8b415c7c5c2dc 100644 (file)
--- a/lib/Target/Mips/AsmParser/MipsAsmParser.cpp
+++ b/lib/Target/Mips/AsmParser/MipsAsmParser.cpp
@@ -234,7 +234,10 @@ class MipsAsmParser : public MCTargetAsmParser {
   bool expandUlh(MCInst &Inst, bool Signed, SMLoc IDLoc, MCStreamer &Out,
                  const MCSubtargetInfo *STI);
 
-  bool expandUlw(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
+  bool expandUsh(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
+                 const MCSubtargetInfo *STI);
+
+  bool expandUxw(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
                  const MCSubtargetInfo *STI);
 
   bool expandRotation(MCInst &Inst, SMLoc IDLoc,
@@ -2180,8 +2183,11 @@ MipsAsmParser::tryExpandInstruction(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
     return expandUlh(Inst, true, IDLoc, Out, STI) ? MER_Fail : MER_Success;
   case Mips::Ulhu:
     return expandUlh(Inst, false, IDLoc, Out, STI) ? MER_Fail : MER_Success;
+  case Mips::Ush:
+    return expandUsh(Inst, IDLoc, Out, STI) ? MER_Fail : MER_Success;
   case Mips::Ulw:
-    return expandUlw(Inst, IDLoc, Out, STI) ? MER_Fail : MER_Success;
+  case Mips::Usw:
+    return expandUxw(Inst, IDLoc, Out, STI) ? MER_Fail : MER_Success;
   case Mips::NORImm:
     return expandAliasImmediate(Inst, IDLoc, Out, STI) ? MER_Fail : MER_Success;
   case Mips::ADDi:
@@ -3325,143 +3331,158 @@ bool MipsAsmParser::expandTrunc(MCInst &Inst, bool IsDouble, bool Is64FPU,
 
 bool MipsAsmParser::expandUlh(MCInst &Inst, bool Signed, SMLoc IDLoc,
                               MCStreamer &Out, const MCSubtargetInfo *STI) {
-  MipsTargetStreamer &TOut = getTargetStreamer();
-
   if (hasMips32r6() || hasMips64r6()) {
     return Error(IDLoc, "instruction not supported on mips32r6 or mips64r6");
   }
 
-  warnIfNoMacro(IDLoc);
-
   const MCOperand &DstRegOp = Inst.getOperand(0);
   assert(DstRegOp.isReg() && "expected register operand kind");
-
   const MCOperand &SrcRegOp = Inst.getOperand(1);
   assert(SrcRegOp.isReg() && "expected register operand kind");
-
   const MCOperand &OffsetImmOp = Inst.getOperand(2);
   assert(OffsetImmOp.isImm() && "expected immediate operand kind");
 
+  MipsTargetStreamer &TOut = getTargetStreamer();
   unsigned DstReg = DstRegOp.getReg();
   unsigned SrcReg = SrcRegOp.getReg();
   int64_t OffsetValue = OffsetImmOp.getImm();
 
   // NOTE: We always need AT for ULHU, as it is always used as the source
   // register for one of the LBu's.
+  warnIfNoMacro(IDLoc);
   unsigned ATReg = getATReg(IDLoc);
   if (!ATReg)
     return true;
 
-  // When the value of offset+1 does not fit in 16 bits, we have to load the
-  // offset in AT, (D)ADDu the original source register (if there was one), and
-  // then use AT as the source register for the 2 generated LBu's.
-  bool LoadedOffsetInAT = false;
-  if (!isInt<16>(OffsetValue + 1) || !isInt<16>(OffsetValue)) {
-    LoadedOffsetInAT = true;
-
-    if (loadImmediate(OffsetValue, ATReg, Mips::NoRegister, !ABI.ArePtrs64bit(),
-                      true, IDLoc, Out, STI))
+  bool IsLargeOffset = !(isInt<16>(OffsetValue + 1) && isInt<16>(OffsetValue));
+  if (IsLargeOffset) {
+    if (loadImmediate(OffsetValue, ATReg, SrcReg, !ABI.ArePtrs64bit(), true,
+                      IDLoc, Out, STI))
       return true;
-
-    // NOTE: We do this (D)ADDu here instead of doing it in loadImmediate()
-    // because it will make our output more similar to GAS'. For example,
-    // generating an "ori $1, $zero, 32768" followed by an "addu $1, $1, $9",
-    // instead of just an "ori $1, $9, 32768".
-    // NOTE: If there is no source register specified in the ULHU, the parser
-    // will interpret it as $0.
-    if (SrcReg != Mips::ZERO && SrcReg != Mips::ZERO_64)
-      TOut.emitAddu(ATReg, ATReg, SrcReg, ABI.ArePtrs64bit(), STI);
   }
 
-  unsigned FirstLbuDstReg = LoadedOffsetInAT ? DstReg : ATReg;
-  unsigned SecondLbuDstReg = LoadedOffsetInAT ? ATReg : DstReg;
-  unsigned LbuSrcReg = LoadedOffsetInAT ? ATReg : SrcReg;
+  int64_t FirstOffset = IsLargeOffset ? 0 : OffsetValue;
+  int64_t SecondOffset = IsLargeOffset ? 1 : (OffsetValue + 1);
+  if (isLittle())
+    std::swap(FirstOffset, SecondOffset);
 
-  int64_t FirstLbuOffset = 0, SecondLbuOffset = 0;
-  if (isLittle()) {
-    FirstLbuOffset = LoadedOffsetInAT ? 1 : (OffsetValue + 1);
-    SecondLbuOffset = LoadedOffsetInAT ? 0 : OffsetValue;
-  } else {
-    FirstLbuOffset = LoadedOffsetInAT ? 0 : OffsetValue;
-    SecondLbuOffset = LoadedOffsetInAT ? 1 : (OffsetValue + 1);
-  }
+  unsigned FirstLbuDstReg = IsLargeOffset ? DstReg : ATReg;
+  unsigned SecondLbuDstReg = IsLargeOffset ? ATReg : DstReg;
 
-  unsigned SllReg = LoadedOffsetInAT ? DstReg : ATReg;
+  unsigned LbuSrcReg = IsLargeOffset ? ATReg : SrcReg;
+  unsigned SllReg = IsLargeOffset ? DstReg : ATReg;
 
   TOut.emitRRI(Signed ? Mips::LB : Mips::LBu, FirstLbuDstReg, LbuSrcReg,
-               FirstLbuOffset, IDLoc, STI);
-
-  TOut.emitRRI(Mips::LBu, SecondLbuDstReg, LbuSrcReg, SecondLbuOffset, IDLoc,
-               STI);
-
+               FirstOffset, IDLoc, STI);
+  TOut.emitRRI(Mips::LBu, SecondLbuDstReg, LbuSrcReg, SecondOffset, IDLoc, STI);
   TOut.emitRRI(Mips::SLL, SllReg, SllReg, 8, IDLoc, STI);
-
   TOut.emitRRR(Mips::OR, DstReg, DstReg, ATReg, IDLoc, STI);
 
   return false;
 }
 
-bool MipsAsmParser::expandUlw(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
+bool MipsAsmParser::expandUsh(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
                               const MCSubtargetInfo *STI) {
+  if (hasMips32r6() || hasMips64r6()) {
+    return Error(IDLoc, "instruction not supported on mips32r6 or mips64r6");
+  }
+
+  const MCOperand &DstRegOp = Inst.getOperand(0);
+  assert(DstRegOp.isReg() && "expected register operand kind");
+  const MCOperand &SrcRegOp = Inst.getOperand(1);
+  assert(SrcRegOp.isReg() && "expected register operand kind");
+  const MCOperand &OffsetImmOp = Inst.getOperand(2);
+  assert(OffsetImmOp.isImm() && "expected immediate operand kind");
+
   MipsTargetStreamer &TOut = getTargetStreamer();
+  unsigned DstReg = DstRegOp.getReg();
+  unsigned SrcReg = SrcRegOp.getReg();
+  int64_t OffsetValue = OffsetImmOp.getImm();
 
-  if (hasMips32r6() || hasMips64r6())
+  warnIfNoMacro(IDLoc);
+  unsigned ATReg = getATReg(IDLoc);
+  if (!ATReg)
+    return true;
+
+  bool IsLargeOffset = !(isInt<16>(OffsetValue + 1) && isInt<16>(OffsetValue));
+  if (IsLargeOffset) {
+    if (loadImmediate(OffsetValue, ATReg, SrcReg, !ABI.ArePtrs64bit(), true,
+                      IDLoc, Out, STI))
+      return true;
+  }
+
+  int64_t FirstOffset = IsLargeOffset ? 1 : (OffsetValue + 1);
+  int64_t SecondOffset = IsLargeOffset ? 0 : OffsetValue;
+  if (isLittle())
+    std::swap(FirstOffset, SecondOffset);
+
+  if (IsLargeOffset) {
+    TOut.emitRRI(Mips::SB, DstReg, ATReg, FirstOffset, IDLoc, STI);
+    TOut.emitRRI(Mips::SRL, DstReg, DstReg, 8, IDLoc, STI);
+    TOut.emitRRI(Mips::SB, DstReg, ATReg, SecondOffset, IDLoc, STI);
+    TOut.emitRRI(Mips::LBu, ATReg, ATReg, 0, IDLoc, STI);
+    TOut.emitRRI(Mips::SLL, DstReg, DstReg, 8, IDLoc, STI);
+    TOut.emitRRR(Mips::OR, DstReg, DstReg, ATReg, IDLoc, STI);
+  } else {
+    TOut.emitRRI(Mips::SB, DstReg, SrcReg, FirstOffset, IDLoc, STI);
+    TOut.emitRRI(Mips::SRL, ATReg, DstReg, 8, IDLoc, STI);
+    TOut.emitRRI(Mips::SB, ATReg, SrcReg, SecondOffset, IDLoc, STI);
+  }
+
+  return false;
+}
+
+bool MipsAsmParser::expandUxw(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
+                              const MCSubtargetInfo *STI) {
+  if (hasMips32r6() || hasMips64r6()) {
     return Error(IDLoc, "instruction not supported on mips32r6 or mips64r6");
+  }
 
   const MCOperand &DstRegOp = Inst.getOperand(0);
   assert(DstRegOp.isReg() && "expected register operand kind");
-
   const MCOperand &SrcRegOp = Inst.getOperand(1);
   assert(SrcRegOp.isReg() && "expected register operand kind");
-
   const MCOperand &OffsetImmOp = Inst.getOperand(2);
   assert(OffsetImmOp.isImm() && "expected immediate operand kind");
 
+  MipsTargetStreamer &TOut = getTargetStreamer();
+  unsigned DstReg = DstRegOp.getReg();
   unsigned SrcReg = SrcRegOp.getReg();
   int64_t OffsetValue = OffsetImmOp.getImm();
-  unsigned ATReg = 0;
-
-  // When the value of offset+3 does not fit in 16 bits, we have to load the
-  // offset in AT, (D)ADDu the original source register (if there was one), and
-  // then use AT as the source register for the generated LWL and LWR.
-  bool LoadedOffsetInAT = false;
-  if (!isInt<16>(OffsetValue + 3) || !isInt<16>(OffsetValue)) {
-    ATReg = getATReg(IDLoc);
-    if (!ATReg)
-      return true;
-    LoadedOffsetInAT = true;
 
+  // Compute left/right load/store offsets.
+  bool IsLargeOffset = !(isInt<16>(OffsetValue + 3) && isInt<16>(OffsetValue));
+  int64_t LxlOffset = IsLargeOffset ? 0 : OffsetValue;
+  int64_t LxrOffset = IsLargeOffset ? 3 : (OffsetValue + 3);
+  if (isLittle())
+    std::swap(LxlOffset, LxrOffset);
+
+  bool IsLoadInst = (Inst.getOpcode() == Mips::Ulw);
+  bool DoMove = IsLoadInst && (SrcReg == DstReg) && !IsLargeOffset;
+  unsigned TmpReg = SrcReg;
+  if (IsLargeOffset || DoMove) {
     warnIfNoMacro(IDLoc);
-
-    if (loadImmediate(OffsetValue, ATReg, Mips::NoRegister, !ABI.ArePtrs64bit(),
-                      true, IDLoc, Out, STI))
+    TmpReg = getATReg(IDLoc);
+    if (!TmpReg)
       return true;
+  }
 
-    // NOTE: We do this (D)ADDu here instead of doing it in loadImmediate()
-    // because it will make our output more similar to GAS'. For example,
-    // generating an "ori $1, $zero, 32768" followed by an "addu $1, $1, $9",
-    // instead of just an "ori $1, $9, 32768".
-    // NOTE: If there is no source register specified in the ULW, the parser
-    // will interpret it as $0.
-    if (SrcReg != Mips::ZERO && SrcReg != Mips::ZERO_64)
-      TOut.emitAddu(ATReg, ATReg, SrcReg, ABI.ArePtrs64bit(), STI);
-  }
-
-  unsigned FinalSrcReg = LoadedOffsetInAT ? ATReg : SrcReg;
-  int64_t LeftLoadOffset = 0, RightLoadOffset  = 0;
-  if (isLittle()) {
-    LeftLoadOffset = LoadedOffsetInAT ? 3 : (OffsetValue + 3);
-    RightLoadOffset  = LoadedOffsetInAT ? 0 : OffsetValue;
-  } else {
-    LeftLoadOffset = LoadedOffsetInAT ? 0 : OffsetValue;
-    RightLoadOffset  = LoadedOffsetInAT ? 3 : (OffsetValue + 3);
+  if (IsLargeOffset) {
+    if (loadImmediate(OffsetValue, TmpReg, SrcReg, !ABI.ArePtrs64bit(), true,
+                      IDLoc, Out, STI))
+      return true;
   }
 
-  TOut.emitRRI(Mips::LWL, DstRegOp.getReg(), FinalSrcReg, LeftLoadOffset, IDLoc,
-               STI);
+  if (DoMove)
+    std::swap(DstReg, TmpReg);
 
-  TOut.emitRRI(Mips::LWR, DstRegOp.getReg(), FinalSrcReg, RightLoadOffset,
-               IDLoc, STI);
+  unsigned XWL = IsLoadInst ? Mips::LWL : Mips::SWL;
+  unsigned XWR = IsLoadInst ? Mips::LWR : Mips::SWR;
+  TOut.emitRRI(XWL, DstReg, TmpReg, LxlOffset, IDLoc, STI);
+  TOut.emitRRI(XWR, DstReg, TmpReg, LxrOffset, IDLoc, STI);
+
+  if (DoMove)
+    TOut.emitRRR(Mips::OR, TmpReg, DstReg, Mips::ZERO, IDLoc, STI);
 
   return false;
 }

diff --git a/lib/Target/Mips/MipsInstrInfo.td b/lib/Target/Mips/MipsInstrInfo.td
index 1c825b442d07cdf738929e6c47a49252677fa50a..5ab9a23087ae1e22aefc1aca63fb5176eac0fe8a 100644 (file)
--- a/lib/Target/Mips/MipsInstrInfo.td
+++ b/lib/Target/Mips/MipsInstrInfo.td
@@ -2569,6 +2569,12 @@ def Ulhu : MipsAsmPseudoInst<(outs GPR32Opnd:$rt), (ins mem:$addr),
 def Ulw : MipsAsmPseudoInst<(outs GPR32Opnd:$rt), (ins mem:$addr),
                             "ulw\t$rt, $addr">; //, ISA_MIPS1_NOT_32R6_64R6;
 
+def Ush : MipsAsmPseudoInst<(outs GPR32Opnd:$rt), (ins mem:$addr),
+                            "ush\t$rt, $addr">; //, ISA_MIPS1_NOT_32R6_64R6;
+
+def Usw : MipsAsmPseudoInst<(outs GPR32Opnd:$rt), (ins mem:$addr),
+                            "usw\t$rt, $addr">; //, ISA_MIPS1_NOT_32R6_64R6;
+
 def LDMacro : MipsAsmPseudoInst<(outs GPR32Opnd:$rt),
                                 (ins mem_simm16:$addr), "ld $rt, $addr">,
                                 ISA_MIPS1_NOT_MIPS3;

diff --git a/test/MC/Mips/mips-expansions.s b/test/MC/Mips/mips-expansions.s
index d07dfc05cf5c25ccd8df202f506f34a062890336..7e900ec696cad167b44d83256dcde50b67a8e7ac 100644 (file)
--- a/test/MC/Mips/mips-expansions.s
+++ b/test/MC/Mips/mips-expansions.s
@@ -326,14 +326,12 @@ ulh_reg: # CHECK-LABEL: ulh_reg:
 # CHECK-LE: or   $8, $8, $1        # encoding: [0x25,0x40,0x01,0x01]
 
   ulh $8, 32767($9)
-# CHECK-BE: addiu $1, $zero, 32767 # encoding: [0x24,0x01,0x7f,0xff]
-# CHECK-BE: addu $1, $1, $9        # encoding: [0x00,0x29,0x08,0x21]
+# CHECK-BE: addiu $1, $9, 32767    # encoding: [0x25,0x21,0x7f,0xff]
 # CHECK-BE: lb   $8, 0($1)         # encoding: [0x80,0x28,0x00,0x00]
 # CHECK-BE: lbu  $1, 1($1)         # encoding: [0x90,0x21,0x00,0x01]
 # CHECK-BE: sll  $8, $8, 8         # encoding: [0x00,0x08,0x42,0x00]
 # CHECK-BE: or   $8, $8, $1        # encoding: [0x01,0x01,0x40,0x25]
-# CHECK-LE: addiu $1, $zero, 32767 # encoding: [0xff,0x7f,0x01,0x24]
-# CHECK-LE: addu $1, $1, $9        # encoding: [0x21,0x08,0x29,0x00]
+# CHECK-LE: addiu $1, $9, 32767    # encoding: [0xff,0x7f,0x21,0x25]
 # CHECK-LE: lb   $8, 1($1)         # encoding: [0x01,0x00,0x28,0x80]
 # CHECK-LE: lbu  $1, 0($1)         # encoding: [0x00,0x00,0x21,0x90]
 # CHECK-LE: sll  $8, $8, 8         # encoding: [0x00,0x42,0x08,0x00]
@@ -527,14 +525,12 @@ ulhu_imm: # CHECK-LABEL: ulhu_imm:
 # CHECK-LE: or   $8, $8, $1        # encoding: [0x25,0x40,0x01,0x01]
 
   ulhu $8, 32767($9)
-# CHECK-BE: addiu $1, $zero, 32767 # encoding: [0x24,0x01,0x7f,0xff]
-# CHECK-BE: addu $1, $1, $9        # encoding: [0x00,0x29,0x08,0x21]
+# CHECK-BE: addiu   $1, $9, 32767  # encoding: [0x25,0x21,0x7f,0xff]
 # CHECK-BE: lbu  $8, 0($1)         # encoding: [0x90,0x28,0x00,0x00]
 # CHECK-BE: lbu  $1, 1($1)         # encoding: [0x90,0x21,0x00,0x01]
 # CHECK-BE: sll  $8, $8, 8         # encoding: [0x00,0x08,0x42,0x00]
 # CHECK-BE: or   $8, $8, $1        # encoding: [0x01,0x01,0x40,0x25]
-# CHECK-LE: addiu $1, $zero, 32767 # encoding: [0xff,0x7f,0x01,0x24]
-# CHECK-LE: addu $1, $1, $9        # encoding: [0x21,0x08,0x29,0x00]
+# CHECK-LE: addiu $1, $9, 32767    # encoding: [0xff,0x7f,0x21,0x25]
 # CHECK-LE: lbu  $8, 1($1)         # encoding: [0x01,0x00,0x28,0x90]
 # CHECK-LE: lbu  $1, 0($1)         # encoding: [0x00,0x00,0x21,0x90]
 # CHECK-LE: sll  $8, $8, 8         # encoding: [0x00,0x42,0x08,0x00]
@@ -667,14 +663,658 @@ ulhu_imm: # CHECK-LABEL: ulhu_imm:
 # CHECK-LE: lwr  $8, 0($1)         # encoding: [0x00,0x00,0x28,0x98]
 
   ulw $8, 32765($9)
-# CHECK-BE: addiu $1, $zero, 32765 # encoding: [0x24,0x01,0x7f,0xfd]
-# CHECK-BE: addu $1, $1, $9        # encoding: [0x00,0x29,0x08,0x21]
+# CHECK-BE: addiu $1, $9, 32765    # encoding: [0x25,0x21,0x7f,0xfd]
 # CHECK-BE: lwl  $8, 0($1)         # encoding: [0x88,0x28,0x00,0x00]
 # CHECK-BE: lwr  $8, 3($1)         # encoding: [0x98,0x28,0x00,0x03]
-# CHECK-LE: addiu $1, $zero, 32765 # encoding: [0xfd,0x7f,0x01,0x24]
-# CHECK-LE: addu $1, $1, $9        # encoding: [0x21,0x08,0x29,0x00]
+# CHECK-LE: addiu $1, $9, 32765    # encoding: [0xfd,0x7f,0x21,0x25]
 # CHECK-LE: lwl  $8, 3($1)         # encoding: [0x03,0x00,0x28,0x88]
 # CHECK-LE: lwr  $8, 0($1)         # encoding: [0x00,0x00,0x28,0x98]
 
+  ulw $8, 0($8)
+# CHECK-BE: lwl $1, 0($8)          # encoding: [0x89,0x01,0x00,0x00]
+# CHECK-BE: lwr $1, 3($8)          # encoding: [0x99,0x01,0x00,0x03]
+# CHECK-BE: move $8, $1            # encoding: [0x00,0x20,0x40,0x25]
+# CHECK-LE: lwl $1, 3($8)          # encoding: [0x03,0x00,0x01,0x89]
+# CHECK-LE: lwr $1, 0($8)          # encoding: [0x00,0x00,0x01,0x99]
+# CHECK-LE: move $8, $1            # encoding: [0x25,0x40,0x20,0x00]
+
+  ulw $8, 2($8)
+# CHECK-BE: lwl $1, 2($8)          # encoding: [0x89,0x01,0x00,0x02]
+# CHECK-BE: lwr $1, 5($8)          # encoding: [0x99,0x01,0x00,0x05]
+# CHECK-BE: move $8, $1            # encoding: [0x00,0x20,0x40,0x25]
+# CHECK-LE: lwl $1, 5($8)          # encoding: [0x05,0x00,0x01,0x89]
+# CHECK-LE: lwr $1, 2($8)          # encoding: [0x02,0x00,0x01,0x99]
+# CHECK-LE: move $8, $1            # encoding: [0x25,0x40,0x20,0x00]
+
+  ulw $8, 0x8000($8)
+# CHECK-BE: ori $1, $zero, 32768   # encoding: [0x34,0x01,0x80,0x00]
+# CHECK-BE: addu $1, $1, $8        # encoding: [0x00,0x28,0x08,0x21]
+# CHECK-BE: lwl $8, 0($1)          # encoding: [0x88,0x28,0x00,0x00]
+# CHECK-BE: lwr $8, 3($1)          # encoding: [0x98,0x28,0x00,0x03]
+# CHECK-LE: ori $1, $zero, 32768   # encoding: [0x00,0x80,0x01,0x34]
+# CHECK-LE: addu $1, $1, $8        # encoding: [0x21,0x08,0x28,0x00]
+# CHECK-LE: lwl $8, 3($1)          # encoding: [0x03,0x00,0x28,0x88]
+# CHECK-LE: lwr $8, 0($1)          # encoding: [0x00,0x00,0x28,0x98]
+
+  ulw $8, -0x8000($8)
+# CHECK-BE: lwl $1, -32768($8)     # encoding: [0x89,0x01,0x80,0x00]
+# CHECK-BE: lwr $1, -32765($8)     # encoding: [0x99,0x01,0x80,0x03]
+# CHECK-BE: move $8, $1            # encoding: [0x00,0x20,0x40,0x25]
+# CHECK-LE: lwl $1, -32765($8)     # encoding: [0x03,0x80,0x01,0x89]
+# CHECK-LE: lwr $1, -32768($8)     # encoding: [0x00,0x80,0x01,0x99]
+# CHECK-LE: move $8, $1            # encoding: [0x25,0x40,0x20,0x00]
+
+  ulw $8, 0x10000($8)
+# CHECK-BE: lui $1, 1              # encoding: [0x3c,0x01,0x00,0x01]
+# CHECK-BE: addu $1, $1, $8        # encoding: [0x00,0x28,0x08,0x21]
+# CHECK-BE: lwl $8, 0($1)          # encoding: [0x88,0x28,0x00,0x00]
+# CHECK-BE: lwr $8, 3($1)          # encoding: [0x98,0x28,0x00,0x03]
+# CHECK-LE: lui $1, 1              # encoding: [0x01,0x00,0x01,0x3c]
+# CHECK-LE: addu $1, $1, $8        # encoding: [0x21,0x08,0x28,0x00]
+# CHECK-LE: lwl $8, 3($1)          # encoding: [0x03,0x00,0x28,0x88]
+# CHECK-LE: lwr $8, 0($1)          # encoding: [0x00,0x00,0x28,0x98]
+
+  ulw $8, 0x18888($8)
+# CHECK-BE: lui $1, 1              # encoding: [0x3c,0x01,0x00,0x01]
+# CHECK-BE: ori $1, $1, 34952      # encoding: [0x34,0x21,0x88,0x88]
+# CHECK-BE: addu $1, $1, $8        # encoding: [0x00,0x28,0x08,0x21]
+# CHECK-BE: lwl $8, 0($1)          # encoding: [0x88,0x28,0x00,0x00]
+# CHECK-BE: lwr $8, 3($1)          # encoding: [0x98,0x28,0x00,0x03]
+# CHECK-LE: lui $1, 1              # encoding: [0x01,0x00,0x01,0x3c]
+# CHECK-LE: ori $1, $1, 34952      # encoding: [0x88,0x88,0x21,0x34]
+# CHECK-LE: addu $1, $1, $8        # encoding: [0x21,0x08,0x28,0x00]
+# CHECK-LE: lwl $8, 3($1)          # encoding: [0x03,0x00,0x28,0x88]
+# CHECK-LE: lwr $8, 0($1)          # encoding: [0x00,0x00,0x28,0x98]
+
+  ulw $8, -32771($8)
+# CHECK-BE: lui $1, 65535          # encoding: [0x3c,0x01,0xff,0xff]
+# CHECK-BE: ori $1, $1, 32765      # encoding: [0x34,0x21,0x7f,0xfd]
+# CHECK-BE: addu $1, $1, $8        # encoding: [0x00,0x28,0x08,0x21]
+# CHECK-BE: lwl $8, 0($1)          # encoding: [0x88,0x28,0x00,0x00]
+# CHECK-BE: lwr $8, 3($1)          # encoding: [0x98,0x28,0x00,0x03]
+# CHECK-LE: lui $1, 65535          # encoding: [0xff,0xff,0x01,0x3c]
+# CHECK-LE: ori $1, $1, 32765      # encoding: [0xfd,0x7f,0x21,0x34]
+# CHECK-LE: addu $1, $1, $8        # encoding: [0x21,0x08,0x28,0x00]
+# CHECK-LE: lwl $8, 3($1)          # encoding: [0x03,0x00,0x28,0x88]
+# CHECK-LE: lwr $8, 0($1)          # encoding: [0x00,0x00,0x28,0x98]
+
+  ulw $8, 32765($8)
+# CHECK-BE: addiu $1, $8, 32765    # encoding: [0x25,0x01,0x7f,0xfd]
+# CHECK-BE: lwl $8, 0($1)          # encoding: [0x88,0x28,0x00,0x00]
+# CHECK-BE: lwr $8, 3($1)          # encoding: [0x98,0x28,0x00,0x03]
+# CHECK-LE: addiu $1, $8, 32765    # encoding: [0xfd,0x7f,0x01,0x25]
+# CHECK-LE: lwl $8, 3($1)          # encoding: [0x03,0x00,0x28,0x88]
+# CHECK-LE: lwr $8, 0($1)          # encoding: [0x00,0x00,0x28,0x98]
+
+ush_imm: # CHECK-LABEL: ush_imm
+  ush $8, 0
+  # CHECK-BE: sb        $8, 1($zero)            # encoding: [0xa0,0x08,0x00,0x01]
+  # CHECK-BE: srl       $1, $8, 8               # encoding: [0x00,0x08,0x0a,0x02]
+  # CHECK-BE: sb        $1, 0($zero)            # encoding: [0xa0,0x01,0x00,0x00]
+  # CHECK-LE: sb        $8, 0($zero)            # encoding: [0x00,0x00,0x08,0xa0]
+  # CHECK-LE: srl       $1, $8, 8               # encoding: [0x02,0x0a,0x08,0x00]
+  # CHECK-LE: sb        $1, 1($zero)            # encoding: [0x01,0x00,0x01,0xa0]
+
+  ush $8, 2
+  # CHECK-BE: sb        $8, 3($zero)            # encoding: [0xa0,0x08,0x00,0x03]
+  # CHECK-BE: srl       $1, $8, 8               # encoding: [0x00,0x08,0x0a,0x02]
+  # CHECK-BE: sb        $1, 2($zero)            # encoding: [0xa0,0x01,0x00,0x02]
+  # CHECK-LE: sb        $8, 2($zero)            # encoding: [0x02,0x00,0x08,0xa0]
+  # CHECK-LE: srl       $1, $8, 8               # encoding: [0x02,0x0a,0x08,0x00]
+  # CHECK-LE: sb        $1, 3($zero)            # encoding: [0x03,0x00,0x01,0xa0]
+
+  # FIXME: Remove the identity moves (move $1, $1) coming from loadImmediate
+  ush $8, 0x8000
+  # CHECK-BE: ori       $1, $zero, 32768        # encoding: [0x34,0x01,0x80,0x00]
+  # CHECK-BE: move      $1, $1                  # encoding: [0x00,0x20,0x08,0x21]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: ori       $1, $zero, 32768        # encoding: [0x00,0x80,0x01,0x34]
+  # CHECK-LE: move      $1, $1                  # encoding: [0x21,0x08,0x20,0x00]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+  ush $8, -0x8000
+  # CHECK-BE: sb        $8, -32767($zero)       # encoding: [0xa0,0x08,0x80,0x01]
+  # CHECK-BE: srl       $1, $8, 8               # encoding: [0x00,0x08,0x0a,0x02]
+  # CHECK-BE: sb        $1, -32768($zero)       # encoding: [0xa0,0x01,0x80,0x00]
+  # CHECK-LE: sb        $8, -32768($zero)       # encoding: [0x00,0x80,0x08,0xa0]
+  # CHECK-LE: srl       $1, $8, 8               # encoding: [0x02,0x0a,0x08,0x00]
+  # CHECK-LE: sb        $1, -32767($zero)       # encoding: [0x01,0x80,0x01,0xa0]
+
+  # FIXME: Remove the identity moves (move $1, $1) coming from loadImmediate
+  ush $8, 0x10000
+  # CHECK-BE: lui       $1, 1                   # encoding: [0x3c,0x01,0x00,0x01]
+  # CHECK-BE: move      $1, $1                  # encoding: [0x00,0x20,0x08,0x21]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: lui       $1, 1                   # encoding: [0x01,0x00,0x01,0x3c]
+  # CHECK-LE: move      $1, $1                  # encoding: [0x21,0x08,0x20,0x00]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+  # FIXME: Remove the identity moves (move $1, $1) coming from loadImmediate
+  ush $8, 0x18888
+  # CHECK-BE: lui       $1, 1                   # encoding: [0x3c,0x01,0x00,0x01]
+  # CHECK-BE: ori       $1, $1, 34952           # encoding: [0x34,0x21,0x88,0x88]
+  # CHECK-BE: move      $1, $1                  # encoding: [0x00,0x20,0x08,0x21]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: lui       $1, 1                   # encoding: [0x01,0x00,0x01,0x3c]
+  # CHECK-LE: ori       $1, $1, 34952           # encoding: [0x88,0x88,0x21,0x34]
+  # CHECK-LE: move      $1, $1                  # encoding: [0x21,0x08,0x20,0x00]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+  # FIXME: Remove the identity moves (move $1, $1) coming from loadImmediate
+  ush $8, -32769
+  # CHECK-BE: lui       $1, 65535               # encoding: [0x3c,0x01,0xff,0xff]
+  # CHECK-BE: ori       $1, $1, 32767           # encoding: [0x34,0x21,0x7f,0xff]
+  # CHECK-BE: move      $1, $1                  # encoding: [0x00,0x20,0x08,0x21]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: lui       $1, 65535               # encoding: [0xff,0xff,0x01,0x3c]
+  # CHECK-LE: ori       $1, $1, 32767           # encoding: [0xff,0x7f,0x21,0x34]
+  # CHECK-LE: move      $1, $1                  # encoding: [0x21,0x08,0x20,0x00]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+  ush $8, 32767
+  # CHECK-BE: addiu     $1, $zero, 32767        # encoding: [0x24,0x01,0x7f,0xff]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: addiu     $1, $zero, 32767        # encoding: [0xff,0x7f,0x01,0x24]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+ush_reg: # CHECK-LABEL: ush_reg
+  ush $8, 0($9)
+  # CHECK-BE: sb        $8, 1($9)               # encoding: [0xa1,0x28,0x00,0x01]
+  # CHECK-BE: srl       $1, $8, 8               # encoding: [0x00,0x08,0x0a,0x02]
+  # CHECK-BE: sb        $1, 0($9)               # encoding: [0xa1,0x21,0x00,0x00]
+  # CHECK-LE: sb        $8, 0($9)               # encoding: [0x00,0x00,0x28,0xa1]
+  # CHECK-LE: srl       $1, $8, 8               # encoding: [0x02,0x0a,0x08,0x00]
+  # CHECK-LE: sb        $1, 1($9)               # encoding: [0x01,0x00,0x21,0xa1]
+
+  ush $8, 2($9)
+  # CHECK-BE: sb        $8, 3($9)               # encoding: [0xa1,0x28,0x00,0x03]
+  # CHECK-BE: srl       $1, $8, 8               # encoding: [0x00,0x08,0x0a,0x02]
+  # CHECK-BE: sb        $1, 2($9)               # encoding: [0xa1,0x21,0x00,0x02]
+  # CHECK-LE: sb        $8, 2($9)               # encoding: [0x02,0x00,0x28,0xa1]
+  # CHECK-LE: srl       $1, $8, 8               # encoding: [0x02,0x0a,0x08,0x00]
+  # CHECK-LE: sb        $1, 3($9)               # encoding: [0x03,0x00,0x21,0xa1]
+
+  ush $8, 0x8000($9)
+  # CHECK-BE: ori       $1, $zero, 32768        # encoding: [0x34,0x01,0x80,0x00]
+  # CHECK-BE: addu      $1, $1, $9              # encoding: [0x00,0x29,0x08,0x21]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: ori       $1, $zero, 32768        # encoding: [0x00,0x80,0x01,0x34]
+  # CHECK-LE: addu      $1, $1, $9              # encoding: [0x21,0x08,0x29,0x00]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+  ush $8, -0x8000($9)
+  # CHECK-BE: sb        $8, -32767($9)          # encoding: [0xa1,0x28,0x80,0x01]
+  # CHECK-BE: srl       $1, $8, 8               # encoding: [0x00,0x08,0x0a,0x02]
+  # CHECK-BE: sb        $1, -32768($9)          # encoding: [0xa1,0x21,0x80,0x00]
+  # CHECK-LE: sb        $8, -32768($9)          # encoding: [0x00,0x80,0x28,0xa1]
+  # CHECK-LE: srl       $1, $8, 8               # encoding: [0x02,0x0a,0x08,0x00]
+  # CHECK-LE: sb        $1, -32767($9)          # encoding: [0x01,0x80,0x21,0xa1]
+
+  ush $8, 0x10000($9)
+  # CHECK-BE: lui       $1, 1                   # encoding: [0x3c,0x01,0x00,0x01]
+  # CHECK-BE: addu      $1, $1, $9              # encoding: [0x00,0x29,0x08,0x21]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: lui       $1, 1                   # encoding: [0x01,0x00,0x01,0x3c]
+  # CHECK-LE: addu      $1, $1, $9              # encoding: [0x21,0x08,0x29,0x00]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+  ush $8, 0x18888($9)
+  # CHECK-BE: lui       $1, 1                   # encoding: [0x3c,0x01,0x00,0x01]
+  # CHECK-BE: ori       $1, $1, 34952           # encoding: [0x34,0x21,0x88,0x88]
+  # CHECK-BE: addu      $1, $1, $9              # encoding: [0x00,0x29,0x08,0x21]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: lui       $1, 1                   # encoding: [0x01,0x00,0x01,0x3c]
+  # CHECK-LE: ori       $1, $1, 34952           # encoding: [0x88,0x88,0x21,0x34]
+  # CHECK-LE: addu      $1, $1, $9              # encoding: [0x21,0x08,0x29,0x00]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+  ush $8, -32769($9)
+  # CHECK-BE: lui       $1, 65535               # encoding: [0x3c,0x01,0xff,0xff]
+  # CHECK-BE: ori       $1, $1, 32767           # encoding: [0x34,0x21,0x7f,0xff]
+  # CHECK-BE: addu      $1, $1, $9              # encoding: [0x00,0x29,0x08,0x21]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: lui       $1, 65535               # encoding: [0xff,0xff,0x01,0x3c]
+  # CHECK-LE: ori       $1, $1, 32767           # encoding: [0xff,0x7f,0x21,0x34]
+  # CHECK-LE: addu      $1, $1, $9              # encoding: [0x21,0x08,0x29,0x00]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+  ush $8, 32767($9)
+  # CHECK-BE: addiu     $1, $9, 32767           # encoding: [0x25,0x21,0x7f,0xff]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: addiu     $1, $9, 32767           # encoding: [0xff,0x7f,0x21,0x25]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+  ush $8, 0($8)
+  # CHECK-BE: sb        $8, 1($8)               # encoding: [0xa1,0x08,0x00,0x01]
+  # CHECK-BE: srl       $1, $8, 8               # encoding: [0x00,0x08,0x0a,0x02]
+  # CHECK-BE: sb        $1, 0($8)               # encoding: [0xa1,0x01,0x00,0x00]
+  # CHECK-LE: sb        $8, 0($8)               # encoding: [0x00,0x00,0x08,0xa1]
+  # CHECK-LE: srl       $1, $8, 8               # encoding: [0x02,0x0a,0x08,0x00]
+  # CHECK-LE: sb        $1, 1($8)               # encoding: [0x01,0x00,0x01,0xa1]
+
+  ush $8, 2($8)
+  # CHECK-BE: sb        $8, 3($8)               # encoding: [0xa1,0x08,0x00,0x03]
+  # CHECK-BE: srl       $1, $8, 8               # encoding: [0x00,0x08,0x0a,0x02]
+  # CHECK-BE: sb        $1, 2($8)               # encoding: [0xa1,0x01,0x00,0x02]
+  # CHECK-LE: sb        $8, 2($8)               # encoding: [0x02,0x00,0x08,0xa1]
+  # CHECK-LE: srl       $1, $8, 8               # encoding: [0x02,0x0a,0x08,0x00]
+  # CHECK-LE: sb        $1, 3($8)               # encoding: [0x03,0x00,0x01,0xa1]
+
+  ush $8, 0x8000($8)
+  # CHECK-BE: ori       $1, $zero, 32768        # encoding: [0x34,0x01,0x80,0x00]
+  # CHECK-BE: addu      $1, $1, $8              # encoding: [0x00,0x28,0x08,0x21]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: ori       $1, $zero, 32768        # encoding: [0x00,0x80,0x01,0x34]
+  # CHECK-LE: addu      $1, $1, $8              # encoding: [0x21,0x08,0x28,0x00]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+  ush $8, -0x8000($8)
+  # CHECK-BE: sb        $8, -32767($8)          # encoding: [0xa1,0x08,0x80,0x01]
+  # CHECK-BE: srl       $1, $8, 8               # encoding: [0x00,0x08,0x0a,0x02]
+  # CHECK-BE: sb        $1, -32768($8)          # encoding: [0xa1,0x01,0x80,0x00]
+  # CHECK-LE: sb        $8, -32768($8)          # encoding: [0x00,0x80,0x08,0xa1]
+  # CHECK-LE: srl       $1, $8, 8               # encoding: [0x02,0x0a,0x08,0x00]
+  # CHECK-LE: sb        $1, -32767($8)          # encoding: [0x01,0x80,0x01,0xa1]
+
+  ush $8, 0x10000($8)
+  # CHECK-BE: lui       $1, 1                   # encoding: [0x3c,0x01,0x00,0x01]
+  # CHECK-BE: addu      $1, $1, $8              # encoding: [0x00,0x28,0x08,0x21]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: lui       $1, 1                   # encoding: [0x01,0x00,0x01,0x3c]
+  # CHECK-LE: addu      $1, $1, $8              # encoding: [0x21,0x08,0x28,0x00]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+  ush $8, 0x18888($8)
+  # CHECK-BE: lui       $1, 1                   # encoding: [0x3c,0x01,0x00,0x01]
+  # CHECK-BE: ori       $1, $1, 34952           # encoding: [0x34,0x21,0x88,0x88]
+  # CHECK-BE: addu      $1, $1, $8              # encoding: [0x00,0x28,0x08,0x21]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: lui       $1, 1                   # encoding: [0x01,0x00,0x01,0x3c]
+  # CHECK-LE: ori       $1, $1, 34952           # encoding: [0x88,0x88,0x21,0x34]
+  # CHECK-LE: addu      $1, $1, $8              # encoding: [0x21,0x08,0x28,0x00]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+  ush $8, -32769($8)
+  # CHECK-BE: lui       $1, 65535               # encoding: [0x3c,0x01,0xff,0xff]
+  # CHECK-BE: ori       $1, $1, 32767           # encoding: [0x34,0x21,0x7f,0xff]
+  # CHECK-BE: addu      $1, $1, $8              # encoding: [0x00,0x28,0x08,0x21]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: lui       $1, 65535               # encoding: [0xff,0xff,0x01,0x3c]
+  # CHECK-LE: ori       $1, $1, 32767           # encoding: [0xff,0x7f,0x21,0x34]
+  # CHECK-LE: addu      $1, $1, $8              # encoding: [0x21,0x08,0x28,0x00]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+  ush $8, 32767($8)
+  # CHECK-BE: addiu     $1, $8, 32767           # encoding: [0x25,0x01,0x7f,0xff]
+  # CHECK-BE: sb        $8, 1($1)               # encoding: [0xa0,0x28,0x00,0x01]
+  # CHECK-BE: srl       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x02]
+  # CHECK-BE: sb        $8, 0($1)               # encoding: [0xa0,0x28,0x00,0x00]
+  # CHECK-BE: lbu       $1, 0($1)               # encoding: [0x90,0x21,0x00,0x00]
+  # CHECK-BE: sll       $8, $8, 8               # encoding: [0x00,0x08,0x42,0x00]
+  # CHECK-BE: or        $8, $8, $1              # encoding: [0x01,0x01,0x40,0x25]
+  # CHECK-LE: addiu     $1, $8, 32767           # encoding: [0xff,0x7f,0x01,0x25]
+  # CHECK-LE: sb        $8, 0($1)               # encoding: [0x00,0x00,0x28,0xa0]
+  # CHECK-LE: srl       $8, $8, 8               # encoding: [0x02,0x42,0x08,0x00]
+  # CHECK-LE: sb        $8, 1($1)               # encoding: [0x01,0x00,0x28,0xa0]
+  # CHECK-LE: lbu       $1, 0($1)               # encoding: [0x00,0x00,0x21,0x90]
+  # CHECK-LE: sll       $8, $8, 8               # encoding: [0x00,0x42,0x08,0x00]
+  # CHECK-LE: or        $8, $8, $1              # encoding: [0x25,0x40,0x01,0x01]
+
+usw_imm: # CHECK-LABEL: usw_imm:
+  usw $8, 0
+  # CHECK-BE:   swl     $8, 0($zero)            # encoding: [0xa8,0x08,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($zero)            # encoding: [0xb8,0x08,0x00,0x03]
+  # CHECK-LE:   swl     $8, 3($zero)            # encoding: [0x03,0x00,0x08,0xa8]
+  # CHECK-LE:   swr     $8, 0($zero)            # encoding: [0x00,0x00,0x08,0xb8]
+
+  usw $8, 2
+  # CHECK-BE:   swl     $8, 2($zero)            # encoding: [0xa8,0x08,0x00,0x02]
+  # CHECK-BE:   swr     $8, 5($zero)            # encoding: [0xb8,0x08,0x00,0x05]
+  # CHECK-LE:   swl     $8, 5($zero)            # encoding: [0x05,0x00,0x08,0xa8]
+  # CHECK-LE:   swr     $8, 2($zero)            # encoding: [0x02,0x00,0x08,0xb8]
+
+  # FIXME: Remove the identity moves (move $1, $1) coming from loadImmediate
+  usw $8, 0x8000
+  # CHECK-BE:   ori     $1, $zero, 32768        # encoding: [0x34,0x01,0x80,0x00]
+  # CHECK-BE:   move     $1, $1                 # encoding: [0x00,0x20,0x08,0x21]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   ori     $1, $zero, 32768        # encoding: [0x00,0x80,0x01,0x34]
+  # CHECK-LE:   move     $1, $1                 # encoding: [0x21,0x08,0x20,0x00]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+  usw $8, -0x8000
+  # CHECK-BE:   swl     $8, -32768($zero)       # encoding: [0xa8,0x08,0x80,0x00]
+  # CHECK-BE:   swr     $8, -32765($zero)       # encoding: [0xb8,0x08,0x80,0x03]
+  # CHECK-LE:   swl     $8, -32765($zero)       # encoding: [0x03,0x80,0x08,0xa8]
+  # CHECK-LE:   swr     $8, -32768($zero)       # encoding: [0x00,0x80,0x08,0xb8]
+
+  # FIXME: Remove the identity moves (move $1, $1) coming from loadImmediate
+  usw $8, 0x10000
+  # CHECK-BE:   lui     $1, 1                   # encoding: [0x3c,0x01,0x00,0x01]
+  # CHECK-BE:   move    $1, $1                  # encoding: [0x00,0x20,0x08,0x21]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   lui     $1, 1                   # encoding: [0x01,0x00,0x01,0x3c]
+  # CHECK-LE:   move    $1, $1                  # encoding: [0x21,0x08,0x20,0x00]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+  # FIXME: Remove the identity moves (move $1, $1) coming from loadImmediate
+  usw $8, 0x18888
+  # CHECK-BE:   lui     $1, 1                   # encoding: [0x3c,0x01,0x00,0x01]
+  # CHECK-BE:   ori     $1, $1, 34952           # encoding: [0x34,0x21,0x88,0x88]
+  # CHECK-BE:   move    $1, $1                  # encoding: [0x00,0x20,0x08,0x21]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   lui     $1, 1                   # encoding: [0x01,0x00,0x01,0x3c]
+  # CHECK-LE:   ori     $1, $1, 34952           # encoding: [0x88,0x88,0x21,0x34]
+  # CHECK-LE:   move    $1, $1                  # encoding: [0x21,0x08,0x20,0x00]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+  # FIXME: Remove the identity moves (move $1, $1) coming from loadImmediate
+  usw $8, -32769
+  # CHECK-BE:   lui     $1, 65535               # encoding: [0x3c,0x01,0xff,0xff]
+  # CHECK-BE:   ori     $1, $1, 32767           # encoding: [0x34,0x21,0x7f,0xff]
+  # CHECK-BE:   move    $1, $1                  # encoding: [0x00,0x20,0x08,0x21]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   lui     $1, 65535               # encoding: [0xff,0xff,0x01,0x3c]
+  # CHECK-LE:   ori     $1, $1, 32767           # encoding: [0xff,0x7f,0x21,0x34]
+  # CHECK-LE:   move    $1, $1                  # encoding: [0x21,0x08,0x20,0x00]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+  usw $8, 32767
+  # CHECK-BE:   addiu   $1, $zero, 32767        # encoding: [0x24,0x01,0x7f,0xff]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   addiu   $1, $zero, 32767        # encoding: [0xff,0x7f,0x01,0x24]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+usw_reg: # CHECK-LABEL: usw_reg:
+  usw $8, 0($9)
+  # CHECK-BE:   swl     $8, 0($9)               # encoding: [0xa9,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($9)               # encoding: [0xb9,0x28,0x00,0x03]
+  # CHECK-LE:   swl     $8, 3($9)               # encoding: [0x03,0x00,0x28,0xa9]
+  # CHECK-LE:   swr     $8, 0($9)               # encoding: [0x00,0x00,0x28,0xb9]
+
+  usw $8, 2($9)
+  # CHECK-BE:   swl     $8, 2($9)               # encoding: [0xa9,0x28,0x00,0x02]
+  # CHECK-BE:   swr     $8, 5($9)               # encoding: [0xb9,0x28,0x00,0x05]
+  # CHECK-LE:   swl     $8, 5($9)               # encoding: [0x05,0x00,0x28,0xa9]
+  # CHECK-LE:   swr     $8, 2($9)               # encoding: [0x02,0x00,0x28,0xb9]
+
+  usw $8, 0x8000($9)
+  # CHECK-BE:   ori     $1, $zero, 32768        # encoding: [0x34,0x01,0x80,0x00]
+  # CHECK-BE:   addu    $1, $1, $9              # encoding: [0x00,0x29,0x08,0x21]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   ori     $1, $zero, 32768        # encoding: [0x00,0x80,0x01,0x34]
+  # CHECK-LE:   addu    $1, $1, $9              # encoding: [0x21,0x08,0x29,0x00]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+  usw $8, -0x8000($9)
+  # CHECK-BE:   swl     $8, -32768($9)          # encoding: [0xa9,0x28,0x80,0x00]
+  # CHECK-BE:   swr     $8, -32765($9)          # encoding: [0xb9,0x28,0x80,0x03]
+  # CHECK-LE:   swl     $8, -32765($9)          # encoding: [0x03,0x80,0x28,0xa9]
+  # CHECK-LE:   swr     $8, -32768($9)          # encoding: [0x00,0x80,0x28,0xb9]
+
+  usw $8, 0x10000($9)
+  # CHECK-BE:   lui     $1, 1                   # encoding: [0x3c,0x01,0x00,0x01]
+  # CHECK-BE:   addu    $1, $1, $9              # encoding: [0x00,0x29,0x08,0x21]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   lui     $1, 1                   # encoding: [0x01,0x00,0x01,0x3c]
+  # CHECK-LE:   addu    $1, $1, $9              # encoding: [0x21,0x08,0x29,0x00]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+  usw $8, 0x18888($9)
+  # CHECK-BE:   lui     $1, 1                   # encoding: [0x3c,0x01,0x00,0x01]
+  # CHECK-BE:   ori     $1, $1, 34952           # encoding: [0x34,0x21,0x88,0x88]
+  # CHECK-BE:   addu    $1, $1, $9              # encoding: [0x00,0x29,0x08,0x21]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   lui     $1, 1                   # encoding: [0x01,0x00,0x01,0x3c]
+  # CHECK-LE:   ori     $1, $1, 34952           # encoding: [0x88,0x88,0x21,0x34]
+  # CHECK-LE:   addu    $1, $1, $9              # encoding: [0x21,0x08,0x29,0x00]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+  usw $8, -32769($9)
+  # CHECK-BE:   lui     $1, 65535               # encoding: [0x3c,0x01,0xff,0xff]
+  # CHECK-BE:   ori     $1, $1, 32767           # encoding: [0x34,0x21,0x7f,0xff]
+  # CHECK-BE:   addu    $1, $1, $9              # encoding: [0x00,0x29,0x08,0x21]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   lui     $1, 65535               # encoding: [0xff,0xff,0x01,0x3c]
+  # CHECK-LE:   ori     $1, $1, 32767           # encoding: [0xff,0x7f,0x21,0x34]
+  # CHECK-LE:   addu    $1, $1, $9              # encoding: [0x21,0x08,0x29,0x00]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+  usw $8, 32767($9)
+  # CHECK-BE:   addiu   $1, $9, 32767           # encoding: [0x25,0x21,0x7f,0xff]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   addiu   $1, $9, 32767           # encoding: [0xff,0x7f,0x21,0x25]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+  usw $8, 0($8)
+  # CHECK-BE:   swl     $8, 0($8)               # encoding: [0xa9,0x08,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($8)               # encoding: [0xb9,0x08,0x00,0x03]
+  # CHECK-LE:   swl     $8, 3($8)               # encoding: [0x03,0x00,0x08,0xa9]
+  # CHECK-LE:   swr     $8, 0($8)               # encoding: [0x00,0x00,0x08,0xb9]
+
+  usw $8, 2($8)
+  # CHECK-BE:   swl     $8, 2($8)               # encoding: [0xa9,0x08,0x00,0x02]
+  # CHECK-BE:   swr     $8, 5($8)               # encoding: [0xb9,0x08,0x00,0x05]
+  # CHECK-LE:   swl     $8, 5($8)               # encoding: [0x05,0x00,0x08,0xa9]
+  # CHECK-LE:   swr     $8, 2($8)               # encoding: [0x02,0x00,0x08,0xb9]
+
+  usw $8, 0x8000($8)
+  # CHECK-BE:   ori     $1, $zero, 32768        # encoding: [0x34,0x01,0x80,0x00]
+  # CHECK-BE:   addu    $1, $1, $8              # encoding: [0x00,0x28,0x08,0x21]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   ori     $1, $zero, 32768        # encoding: [0x00,0x80,0x01,0x34]
+  # CHECK-LE:   addu    $1, $1, $8              # encoding: [0x21,0x08,0x28,0x00]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+  usw $8, -0x8000($8)
+  # CHECK-BE:   swl     $8, -32768($8)          # encoding: [0xa9,0x08,0x80,0x00]
+  # CHECK-BE:   swr     $8, -32765($8)          # encoding: [0xb9,0x08,0x80,0x03]
+  # CHECK-LE:   swl     $8, -32765($8)          # encoding: [0x03,0x80,0x08,0xa9]
+  # CHECK-LE:   swr     $8, -32768($8)          # encoding: [0x00,0x80,0x08,0xb9]
+
+  usw $8, 0x10000($8)
+  # CHECK-BE:   lui     $1, 1                   # encoding: [0x3c,0x01,0x00,0x01]
+  # CHECK-BE:   addu    $1, $1, $8              # encoding: [0x00,0x28,0x08,0x21]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   lui     $1, 1                   # encoding: [0x01,0x00,0x01,0x3c]
+  # CHECK-LE:   addu    $1, $1, $8              # encoding: [0x21,0x08,0x28,0x00]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+  usw $8, 0x18888($8)
+  # CHECK-BE:   lui     $1, 1                   # encoding: [0x3c,0x01,0x00,0x01]
+  # CHECK-BE:   ori     $1, $1, 34952           # encoding: [0x34,0x21,0x88,0x88]
+  # CHECK-BE:   addu    $1, $1, $8              # encoding: [0x00,0x28,0x08,0x21]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   lui     $1, 1                   # encoding: [0x01,0x00,0x01,0x3c]
+  # CHECK-LE:   ori     $1, $1, 34952           # encoding: [0x88,0x88,0x21,0x34]
+  # CHECK-LE:   addu    $1, $1, $8              # encoding: [0x21,0x08,0x28,0x00]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+  usw $8, -32769($8)
+  # CHECK-BE:   lui     $1, 65535               # encoding: [0x3c,0x01,0xff,0xff]
+  # CHECK-BE:   ori     $1, $1, 32767           # encoding: [0x34,0x21,0x7f,0xff]
+  # CHECK-BE:   addu    $1, $1, $8              # encoding: [0x00,0x28,0x08,0x21]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   lui     $1, 65535               # encoding: [0xff,0xff,0x01,0x3c]
+  # CHECK-LE:   ori     $1, $1, 32767           # encoding: [0xff,0x7f,0x21,0x34]
+  # CHECK-LE:   addu    $1, $1, $8              # encoding: [0x21,0x08,0x28,0x00]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
+  usw $8, 32767($8)
+  # CHECK-BE:   addiu   $1, $8, 32767           # encoding: [0x25,0x01,0x7f,0xff]
+  # CHECK-BE:   swl     $8, 0($1)               # encoding: [0xa8,0x28,0x00,0x00]
+  # CHECK-BE:   swr     $8, 3($1)               # encoding: [0xb8,0x28,0x00,0x03]
+  # CHECK-LE:   addiu   $1, $8, 32767           # encoding: [0xff,0x7f,0x01,0x25]
+  # CHECK-LE:   swl     $8, 3($1)               # encoding: [0x03,0x00,0x28,0xa8]
+  # CHECK-LE:   swr     $8, 0($1)               # encoding: [0x00,0x00,0x28,0xb8]
+
 1:
   add $4, $4, $4