[mips] Handle 64 bit immediate in and/or/xor pseudo instructions on mips64

[arichardson]

Summary

Previously LLVM was assuming 32-bit signed immediates which results in and with a bitmask that has bit 31 set to incorrectly include bits 63-32 in the result.
After applying this patch I can now compile all of the FreeBSD mips assembly code with clang.

This issue also affects the nor, slt and sltu macros and I will fix those in a separate review.

[arichardson]

rebased on master

[sdardis]

Hi,

Thanks for taking a look at this, I was about to start on it today, but your patch arrived first.

I am not sure what the correct approach is but it seems I need to add the GPR_32 constraint because otherwise the 32 bit aliases will be used for 64 bit code generation.

Yes, this approach is correct. The asm parser considers the predicates of the instruction definition to chose which entry in the matcher table should be considered.

This issue also affects the nor, slt and sltu macros but I don't know how to change the tablegen to make these work.

I've inlined a comment on how to get slt and sltu macros working. They're different from the rest of the instructions you're changing due to legalization issues.

To handle NorImm, change the def of NORImm into a class NORIMM_DESC_BASE which takes two parameters, RegisterOperand and DAGOperand which are then used instead of GPR32Opnd and simm32_relaxed. You can then introduce a def of NORImm which takes GPR32Opnd and simm32_relaxed, and a def NORImm64 which takes GPR64Opnd and imm64. These two instructions will need GPR_32 and GPR_64 predicates attached to them otherwise the result of parsing 'nor $4, $5, -1' will give results based on the order of the matcher table.

For the TableGen side of things, you can look at the class LoadImmediate32 and how it is used with def LoadImm32 just below it for a reference. You'll also need to look at where NORImm get handled in the cpp side and provide similar support for NORImm64.

Thanks again,
Simon

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

3833–3850

For the 64 bit case, you need to pick the corresponding 64 bit instruction definition. Picking the 32 bit version introduces a very subtle bug in that the instruction emitted will be (harmless) malformed.

lib/Target/Mips/MipsInstrInfo.td

2322–2323

Add another parameter here which defaults to RO, use it with $rs.

Then you can modify just the macro definitions for slt and sltu to produce a result as a GPR32Opnd.

test/MC/Mips/mips64-instalias-imm-expanding.s

382–384

This should not be sign extended.

470

Change that XXXAR to FIXME, so I can find it later.

We currently don't do many possible optimizations regarding constant synthesis in the assembler. I'd like to improve that but other things have higher priority.

[arichardson]

fixed issues with and/or/xor. Will add a separate review for nor/slt/sltu later today.

[sdardis]

LGTM to with inline comment addressed.

lib/Target/Mips/Mips64InstrInfo.td

710–715

These need to be guarded by GPR_64.

[arichardson]

Fixed inline issues.

I don't have commit access, could you submit for me?

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

if ((Inst.getNumOperands() == 3) && Inst.getOperand(0).isReg() &&
       int64_t ImmValue = Inst.getOperand(2).getImm();
       if (isInt<16>(ImmValue))
         return MER_NotAMacro;
       return expandAliasImmediate(Inst, IDLoc, Out, STI) ? MER_Fail
                                                          : MER_Success;
     }
     return MER_NotAMacro;
   case Mips::ANDi:
+  case Mips::ANDi64:
   case Mips::ORi:
+  case Mips::ORi64:
   case Mips::XORi:
+  case Mips::XORi64:
     if ((Inst.getNumOperands() == 3) && Inst.getOperand(0).isReg() &&
         Inst.getOperand(1).isReg() && Inst.getOperand(2).isImm()) {
       int64_t ImmValue = Inst.getOperand(2).getImm();
       if (isUInt<16>(ImmValue))
         return MER_NotAMacro;
       return expandAliasImmediate(Inst, IDLoc, Out, STI) ? MER_Fail
                                                          : MER_Success;
     }
if (isUInt<16>(ImmValue)) {
     return false;
   }
 
   if (isInt<32>(ImmValue) || isUInt<32>(ImmValue)) {
     warnIfNoMacro(IDLoc);
 
     uint16_t Bits31To16 = (ImmValue >> 16) & 0xffff;
     uint16_t Bits15To0 = ImmValue & 0xffff;
-
     if (!Is32BitImm && !isInt<32>(ImmValue)) {
       // Traditional behaviour seems to special case this particular value. It's
       // not clear why other masks are handled differently.
       if (ImmValue == 0xffffffff) {
         TOut.emitRI(Mips::LUi, TmpReg, 0xffff, IDLoc, STI);
         TOut.emitRRI(Mips::DSRL32, TmpReg, TmpReg, 0, IDLoc, STI);
         if (UseSrcReg)
           TOut.emitRRR(AdduOp, DstReg, TmpReg, SrcReg, IDLoc, STI);
assert(Inst.getOperand(0).isReg() &&
          Inst.getOperand(2).isImm() && "Invalid instruction operand.");
 
   unsigned ATReg = Mips::NoRegister;
   unsigned FinalDstReg = Mips::NoRegister;
   unsigned DstReg = Inst.getOperand(0).getReg();
   unsigned SrcReg = Inst.getOperand(1).getReg();
   int64_t ImmValue = Inst.getOperand(2).getImm();
 
-  bool Is32Bit = isInt<32>(ImmValue) || isUInt<32>(ImmValue);
+  bool Is32Bit = isInt<32>(ImmValue) || (!isGP64bit() && isUInt<32>(ImmValue));
 
   unsigned FinalOpcode = Inst.getOpcode();
 
   if (DstReg == SrcReg) {
     ATReg = getATReg(Inst.getLoc());
     if (!ATReg)
       return true;
     FinalDstReg = DstReg;
     DstReg = ATReg;
   }
 
   if (!loadImmediate(ImmValue, DstReg, Mips::NoRegister, Is32Bit, false, Inst.getLoc(), Out, STI)) {
     switch (FinalOpcode) {
     default:
       llvm_unreachable("unimplemented expansion");
     case (Mips::ADDi):
       FinalOpcode = Mips::ADD;
       break;
     case (Mips::ADDiu):
       FinalOpcode = Mips::ADDu;
       break;
     case (Mips::ANDi):
+    case (Mips::ANDi64):
       FinalOpcode = Mips::AND;
       break;
     case (Mips::NORImm):
       FinalOpcode = Mips::NOR;
       break;
     case (Mips::ORi):
+    case (Mips::ORi64):
       FinalOpcode = Mips::OR;
       break;
     case (Mips::SLTi):
       FinalOpcode = Mips::SLT;
       break;
     case (Mips::SLTiu):
       FinalOpcode = Mips::SLTu;
       break;
     case (Mips::XORi):
+    case (Mips::XORi64):
       FinalOpcode = Mips::XOR;
       break;
     }
 
     if (FinalDstReg == Mips::NoRegister)
       TOut.emitRRR(FinalOpcode, DstReg, DstReg, SrcReg, IDLoc, STI);
     else
       TOut.emitRRR(FinalOpcode, FinalDstReg, FinalDstReg, DstReg, IDLoc, STI);

lib/Target/Mips/Mips64InstrInfo.td

def : MipsInstAlias<"dadd $rs, $imm",
                       (DADDi GPR64Opnd:$rs, GPR64Opnd:$rs, simm16_64:$imm),
                       0>, ISA_MIPS3_NOT_32R6_64R6;
   def : MipsInstAlias<"daddu $rs, $rt, $imm",
                       (DADDiu GPR64Opnd:$rs, GPR64Opnd:$rt, simm16_64:$imm),
                       0>, ISA_MIPS3;
   def : MipsInstAlias<"daddu $rs, $imm",
                       (DADDiu GPR64Opnd:$rs, GPR64Opnd:$rs, simm16_64:$imm),
                       0>, ISA_MIPS3;
+  def : MipsInstAlias<"and $rs, $rt, $imm",
+          (ANDi64 GPR64Opnd:$rs, GPR64Opnd:$rt, imm64:$imm), 0>, GPR_64;
+  def : MipsInstAlias<"and $rs, $imm",
+          (ANDi64 GPR64Opnd:$rs, GPR64Opnd:$rs, imm64:$imm), 0>, GPR_64;
+  def : MipsInstAlias<"or $rs, $rt, $imm",
+          (ORi64 GPR64Opnd:$rs, GPR64Opnd:$rt, imm64:$imm), 0>, GPR_64;
+  def : MipsInstAlias<"or $rs, $imm",
+          (ORi64 GPR64Opnd:$rs, GPR64Opnd:$rs, imm64:$imm), 0>, GPR_64;
+  def : MipsInstAlias<"xor $rs, $rt, $imm",
+          (XORi64 GPR64Opnd:$rs, GPR64Opnd:$rt, imm64:$imm), 0>, GPR_64;
+  def : MipsInstAlias<"xor $rs, $imm",
+          (XORi64 GPR64Opnd:$rs, GPR64Opnd:$rs, imm64:$imm), 0>, GPR_64;
 }
 def : MipsInstAlias<"dsll $rd, $rt, $rs",
                     (DSLLV GPR64Opnd:$rd, GPR64Opnd:$rt, GPR32Opnd:$rs), 0>,
                     ISA_MIPS3;
 let AdditionalPredicates = [NotInMicroMips] in {
   def : MipsInstAlias<"dneg $rt, $rs",
                       (DSUB GPR64Opnd:$rt, ZERO_64, GPR64Opnd:$rs), 1>,
                       ISA_MIPS3;

lib/Target/Mips/MipsInstrInfo.td

def MULOMacro : MipsAsmPseudoInst<(outs), (ins GPR32Opnd:$rd, GPR32Opnd:$rs,
                 ISA_MIPS1_NOT_32R6_64R6;
 def MULOUMacro : MipsAsmPseudoInst<(outs), (ins GPR32Opnd:$rd, GPR32Opnd:$rs,
                                                 GPR32Opnd:$rt),
                                    "mulou\t$rd, $rs, $rt">,
                  ISA_MIPS1_NOT_32R6_64R6;
 
 //===----------------------------------------------------------------------===//
 // Instruction aliases
 //===----------------------------------------------------------------------===//
 def : MipsInstAlias<"move $dst, $src",
                     (OR GPR32Opnd:$dst, GPR32Opnd:$src, ZERO), 1>,
       GPR_32 {
   let AdditionalPredicates = [NotInMicroMips];
 }
 def : MipsInstAlias<"move $dst, $src",
                     (ADDu GPR32Opnd:$dst, GPR32Opnd:$src, ZERO), 1>,
       GPR_32 {
   let AdditionalPredicates = [NotInMicroMips];
def : MipsInstAlias<
           (ADDi GPR32Opnd:$rs, GPR32Opnd:$rt, simm32_relaxed:$imm), 0>,
           ISA_MIPS1_NOT_32R6_64R6;
 def : MipsInstAlias<
           "add $rs, $imm",
           (ADDi GPR32Opnd:$rs, GPR32Opnd:$rs, simm32_relaxed:$imm), 0>,
           ISA_MIPS1_NOT_32R6_64R6;
 def : MipsInstAlias<
           "and $rs, $rt, $imm",
-          (ANDi GPR32Opnd:$rs, GPR32Opnd:$rt, simm32_relaxed:$imm), 0>;
+          (ANDi GPR32Opnd:$rs, GPR32Opnd:$rt, simm32_relaxed:$imm), 0>, GPR_32;
 def : MipsInstAlias<
           "and $rs, $imm",
-          (ANDi GPR32Opnd:$rs, GPR32Opnd:$rs, simm32_relaxed:$imm), 0>;
+          (ANDi GPR32Opnd:$rs, GPR32Opnd:$rs, simm32_relaxed:$imm), 0>, GPR_32;
 def : MipsInstAlias<"j $rs", (JR GPR32Opnd:$rs), 0>;
 let Predicates = [NotInMicroMips] in {
 def : MipsInstAlias<"jalr $rs", (JALR RA, GPR32Opnd:$rs), 0>;
 }
 def : MipsInstAlias<"jalr.hb $rs", (JALR_HB RA, GPR32Opnd:$rs), 1>, ISA_MIPS32;
 def : MipsInstAlias<"neg $rt, $rs",
                     (SUB GPR32Opnd:$rt, ZERO, GPR32Opnd:$rs), 1>;
 def : MipsInstAlias<"neg $rt",
let AdditionalPredicates = [NotInMicroMips] in {
   def : MipsInstAlias<
           "slt $rs, $rt, $imm",
           (SLTi GPR32Opnd:$rs, GPR32Opnd:$rt, simm32_relaxed:$imm), 0>;
   def : MipsInstAlias<
           "sltu $rt, $rs, $imm",
           (SLTiu GPR32Opnd:$rt, GPR32Opnd:$rs, simm32_relaxed:$imm), 0>;
   def : MipsInstAlias<
           "and $rs, $rt, $imm",
-          (ANDi GPR32Opnd:$rs, GPR32Opnd:$rt, simm32_relaxed:$imm), 0>;
+          (ANDi GPR32Opnd:$rs, GPR32Opnd:$rt, simm32_relaxed:$imm), 0>, GPR_32;
   def : MipsInstAlias<
           "and $rs, $imm",
-          (ANDi GPR32Opnd:$rs, GPR32Opnd:$rs, simm32_relaxed:$imm), 0>;
+          (ANDi GPR32Opnd:$rs, GPR32Opnd:$rs, simm32_relaxed:$imm), 0>, GPR_32;
   def : MipsInstAlias<
           "xor $rs, $rt, $imm",
-          (XORi GPR32Opnd:$rs, GPR32Opnd:$rt, simm32_relaxed:$imm), 0>;
+          (XORi GPR32Opnd:$rs, GPR32Opnd:$rt, simm32_relaxed:$imm), 0>, GPR_32;
   def : MipsInstAlias<
           "xor $rs, $imm",
-          (XORi GPR32Opnd:$rs, GPR32Opnd:$rs, simm32_relaxed:$imm), 0>;
+          (XORi GPR32Opnd:$rs, GPR32Opnd:$rs, simm32_relaxed:$imm), 0>, GPR_32;
   def : MipsInstAlias<
           "or $rs, $rt, $imm",
-          (ORi GPR32Opnd:$rs, GPR32Opnd:$rt, simm32_relaxed:$imm), 0>;
+          (ORi GPR32Opnd:$rs, GPR32Opnd:$rt, simm32_relaxed:$imm), 0>, GPR_32;
   def : MipsInstAlias<
           "or $rs, $imm",
-          (ORi GPR32Opnd:$rs, GPR32Opnd:$rs, simm32_relaxed:$imm), 0>;
+          (ORi GPR32Opnd:$rs, GPR32Opnd:$rs, simm32_relaxed:$imm), 0>, GPR_32;
   def : MipsInstAlias<
           "not $rt, $rs",
           (NOR GPR32Opnd:$rt, GPR32Opnd:$rs, ZERO), 0>;
   def : MipsInstAlias<
           "not $rt",
           (NOR GPR32Opnd:$rt, GPR32Opnd:$rt, ZERO), 0>;
   def : MipsInstAlias<"nop", (SLL ZERO, ZERO, 0), 1>;
 }

test/MC/Mips/mips64-instalias-imm-expanding.s

+# RUN: llvm-mc -triple mips64el-unknown-linux -show-encoding -print-imm-hex %s | FileCheck %s
+
+  .text
+text_label:
+# CHECK: text_label:
+  add $4, -0x80000000
+# CHECK-NEXT: lui    $1, 0x8000              # encoding: [0x00,0x80,0x01,0x3c]
+# CHECK-NEXT: add    $4, $4, $1              # encoding: [0x20,0x20,0x81,0x00]
+  add $4, -0x8001
+# CHECK-NEXT: lui    $1, 0xffff              # encoding: [0xff,0xff,0x01,0x3c]
+# CHECK-NEXT: ori    $1, $1, 0x7fff          # encoding: [0xff,0x7f,0x21,0x34]
+# CHECK-NEXT: add    $4, $4, $1              # encoding: [0x20,0x20,0x81,0x00]
+  add $4, -0x8000
+# CHECK-NEXT: addi   $4, $4, -0x8000         # encoding: [0x00,0x80,0x84,0x20]
+  add $4, 0
+# CHECK-NEXT: addi   $4, $4, 0x0             # encoding: [0x00,0x00,0x84,0x20]
+  add $4, 0xFFFF
+# CHECK-NEXT: ori    $1, $zero, 0xffff       # encoding: [0xff,0xff,0x01,0x34]
+# CHECK-NEXT: add    $4, $4, $1              # encoding: [0x20,0x20,0x81,0x00]
+  add $4, 0x10000
+# CHECK-NEXT: lui    $1, 0x1                 # encoding: [0x01,0x00,0x01,0x3c]
+# CHECK-NEXT: add    $4, $4, $1              # encoding: [0x20,0x20,0x81,0x00]
+  add $4, 0xFFFFFFFF
+# This should be sign-extended because it's a 32-bit add
+# CHECK-NEXT: addi   $4, $4, -0x1            # encoding: [0xff,0xff,0x84,0x20]
+
+  add $4, $5, -0x80000000
+# CHECK:      lui    $4, 0x8000              # encoding: [0x00,0x80,0x04,0x3c]
+# CHECK-NEXT: add    $4, $4, $5              # encoding: [0x20,0x20,0x85,0x00]
+  add $4, $5, -0x8001
+# CHECK-NEXT: lui    $4, 0xffff              # encoding: [0xff,0xff,0x04,0x3c]
+# CHECK-NEXT: ori    $4, $4, 0x7fff          # encoding: [0xff,0x7f,0x84,0x34]
+# CHECK-NEXT: add    $4, $4, $5              # encoding: [0x20,0x20,0x85,0x00]
+  add $4, $5, -0x8000
+# CHECK-NEXT: addi   $4, $5, -0x8000         # encoding: [0x00,0x80,0xa4,0x20]
+  add $4, $5, 0
+# CHECK-NEXT: addi   $4, $5, 0x0             # encoding: [0x00,0x00,0xa4,0x20]
+  add $4, $5, 0xFFFF
+# CHECK-NEXT: ori    $4, $zero, 0xffff       # encoding: [0xff,0xff,0x04,0x34]
+# CHECK-NEXT: add    $4, $4, $5              # encoding: [0x20,0x20,0x85,0x00]
+  add $4, $5, 0x10000
+# CHECK-NEXT: lui    $4, 0x1                 # encoding: [0x01,0x00,0x04,0x3c]
+# CHECK-NEXT: add    $4, $4, $5              # encoding: [0x20,0x20,0x85,0x00]
+  add $4, $5, 0xFFFFFFFF
+# This should be sign-extended because it's a 32-bit addi
+# CHECK-NEXT: addi   $4, $5, -0x1            # encoding: [0xff,0xff,0xa4,0x20]
+
+
+  addu $4, -0x80000000
+# CHECK:      lui    $1, 0x8000              # encoding: [0x00,0x80,0x01,0x3c]
+# CHECK-NEXT: addu   $4, $4, $1              # encoding: [0x21,0x20,0x81,0x00]
+  addu $4, -0x8001
+# CHECK-NEXT: lui    $1, 0xffff              # encoding: [0xff,0xff,0x01,0x3c]
+# CHECK-NEXT: ori    $1, $1, 0x7fff          # encoding: [0xff,0x7f,0x21,0x34]
+# CHECK-NEXT: addu   $4, $4, $1              # encoding: [0x21,0x20,0x81,0x00]
+  addu $4, -0x8000
+# CHECK-NEXT: addiu  $4, $4, -0x8000         # encoding: [0x00,0x80,0x84,0x24]
+  addu $4, 0
+# CHECK-NEXT: addiu  $4, $4, 0x0             # encoding: [0x00,0x00,0x84,0x24]
+  addu $4, 0xFFFF
+# CHECK-NEXT: ori    $1, $zero, 0xffff       # encoding: [0xff,0xff,0x01,0x34]
+# CHECK-NEXT: addu   $4, $4, $1              # encoding: [0x21,0x20,0x81,0x00]
+  addu $4, 0x10000
+# CHECK-NEXT: lui    $1, 0x1                 # encoding: [0x01,0x00,0x01,0x3c]
+# CHECK-NEXT: addu   $4, $4, $1              # encoding: [0x21,0x20,0x81,0x00]
+  addu $4, 0xFFFFFFFF
+# This should be sign-extended because it's a 32-bit add
+# CHECK-NEXT: addiu  $4, $4, -0x1            # encoding: [0xff,0xff,0x84,0x24]
+
+  addu $4, $5, -0x80000000
+# CHECK:      lui    $4, 0x8000              # encoding: [0x00,0x80,0x04,0x3c]
+# CHECK-NEXT: addu   $4, $4, $5              # encoding: [0x21,0x20,0x85,0x00]
+  addu $4, $5, -0x8001
+# CHECK-NEXT: lui    $4, 0xffff              # encoding: [0xff,0xff,0x04,0x3c]
+# CHECK-NEXT: ori    $4, $4, 0x7fff          # encoding: [0xff,0x7f,0x84,0x34]
+# CHECK-NEXT: addu   $4, $4, $5              # encoding: [0x21,0x20,0x85,0x00]
+  addu $4, $5, -0x8000
+# CHECK-NEXT: addiu  $4, $5, -0x8000         # encoding: [0x00,0x80,0xa4,0x24]
+  addu $4, $5, 0
+# CHECK-NEXT: addiu  $4, $5, 0x0             # encoding: [0x00,0x00,0xa4,0x24]
+  addu $4, $5, 0xFFFF
+# CHECK-NEXT: ori    $4, $zero, 0xffff       # encoding: [0xff,0xff,0x04,0x34]
+# CHECK-NEXT: addu   $4, $4, $5              # encoding: [0x21,0x20,0x85,0x00]
+  addu $4, $5, 0x10000
+# CHECK-NEXT: lui    $4, 0x1                 # encoding: [0x01,0x00,0x04,0x3c]
+# CHECK-NEXT: addu   $4, $4, $5              # encoding: [0x21,0x20,0x85,0x00]
+  addu $4, $5, 0xFFFFFFFF
+# This should be sign-extended because it's a 32-bit add
+# CHECK-NEXT: addiu  $4, $5, -0x1              # encoding: [0xff,0xff,0xa4,0x24]
+
+
+  and $4, -0x80000000
+# CHECK:      lui    $1, 0x8000              # encoding: [0x00,0x80,0x01,0x3c]
+# CHECK-NEXT: and    $4, $4, $1              # encoding: [0x24,0x20,0x81,0x00]
+  and $4, -0x8001
+# CHECK-NEXT: lui    $1, 0xffff              # encoding: [0xff,0xff,0x01,0x3c]
+# CHECK-NEXT: ori    $1, $1, 0x7fff          # encoding: [0xff,0x7f,0x21,0x34]
+# CHECK-NEXT: and    $4, $4, $1              # encoding: [0x24,0x20,0x81,0x00]
+  and $4, -0x8000
+# CHECK-NEXT: addiu   $1, $zero, -0x8000     # encoding: [0x00,0x80,0x01,0x24]
+# CHECK-NEXT: and     $4, $4, $1             # encoding: [0x24,0x20,0x81,0x00]
+  and $4, 0
+# CHECK-NEXT: andi   $4, $4, 0x0             # encoding: [0x00,0x00,0x84,0x30]
+  and $4, 0xFFFF
+# CHECK-NEXT: andi   $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x30]
+  and $4, 0x10000
+# CHECK-NEXT: lui    $1, 0x1                 # encoding: [0x01,0x00,0x01,0x3c]
+# CHECK-NEXT: and    $4, $4, $1              # encoding: [0x24,0x20,0x81,0x00]
+  and $4, 0xFFFFFFFF
+# CHECK-NEXT: lui     $1, 0xffff              # encoding: [0xff,0xff,0x01,0x3c]
+# CHECK-NEXT: dsrl32  $1, $1, 0x0             # encoding: [0x3e,0x08,0x01,0x00]
+# CHECK-NEXT: and     $4, $4, $1              # encoding: [0x24,0x20,0x81,0x00]
+  and $4, 0xF0000000
+# CHECK-NEXT: ori     $1, $zero, 0xf000       # encoding: [0x00,0xf0,0x01,0x34]
+# CHECK-NEXT: dsll    $1, $1, 0x10            # encoding: [0x38,0x0c,0x01,0x00]
+# CHECK-NEXT: and     $4, $4, $1              # encoding: [0x24,0x20,0x81,0x00]
+  and $4, 0x7FFFFFFF
+# CHECK-NEXT: lui     $1, 0x7fff              # encoding: [0xff,0x7f,0x01,0x3c]
+# CHECK-NEXT: ori     $1, $1, 0xffff          # encoding: [0xff,0xff,0x21,0x34]
+# CHECK-NEXT: and     $4, $4, $1              # encoding: [0x24,0x20,0x81,0x00]
+  and $4, 0x7FFFFFFFFFFFFFFF
+# CHECK-NEXT: lui     $1, 0x7fff              # encoding: [0xff,0x7f,0x01,0x3c]
+# CHECK-NEXT: ori     $1, $1, 0xffff          # encoding: [0xff,0xff,0x21,0x34]
+# CHECK-NEXT: dsll    $1, $1, 0x10            # encoding: [0x38,0x0c,0x01,0x00]
+# CHECK-NEXT: ori     $1, $1, 0xffff          # encoding: [0xff,0xff,0x21,0x34]
+# CHECK-NEXT: dsll    $1, $1, 0x10            # encoding: [0x38,0x0c,0x01,0x00]
+# CHECK-NEXT: ori     $1, $1, 0xffff          # encoding: [0xff,0xff,0x21,0x34]
+# CHECK-NEXT: and     $4, $4, $1              # encoding: [0x24,0x20,0x81,0x00]
+  and $4, 0xFFFFFFFFFFFFFFFF
+# CHECK-NEXT: addiu   $1, $zero, -0x1         # encoding: [0xff,0xff,0x01,0x24]
+# CHECK-NEXT: and     $4, $4, $1              # encoding: [0x24,0x20,0x81,0x00]
+  and $4, 0xF000000000000000
+# CHECK-NEXT: ori     $1, $zero, 0xf000       # encoding: [0x00,0xf0,0x01,0x34]
+# CHECK-NEXT: dsll    $1, $1, 0x30            # encoding: [0x3c,0x0c,0x01,0x00]
+# CHECK-NEXT: and     $4, $4, $1              # encoding: [0x24,0x20,0x81,0x00]
+
+  and $4, $5, -0x80000000
+# CHECK:      lui    $4, 0x8000              # encoding: [0x00,0x80,0x04,0x3c]
+# CHECK-NEXT: and    $4, $4, $5              # encoding: [0x24,0x20,0x85,0x00]
+  and $4, $5, -0x8001
+# CHECK-NEXT: lui     $4, 0xffff              # encoding: [0xff,0xff,0x04,0x3c]
+# CHECK-NEXT: ori     $4, $4, 0x7fff          # encoding: [0xff,0x7f,0x84,0x34]
+# CHECK-NEXT: and     $4, $4, $5              # encoding: [0x24,0x20,0x85,0x00]
+  and $4, $5, -0x8000
+# CHECK-NEXT: addiu   $4, $zero, -0x8000      # encoding: [0x00,0x80,0x04,0x24]
+# CHECK-NEXT: and     $4, $4, $5              # encoding: [0x24,0x20,0x85,0x00]
+  and $4, $5, 0
+# CHECK-NEXT: andi    $4, $5, 0x0             # encoding: [0x00,0x00,0xa4,0x30]
+  and $4, $5, 0xFFFF
+# CHECK-NEXT: andi    $4, $5, 0xffff          # encoding: [0xff,0xff,0xa4,0x30]
+  and $4, $5, 0x10000
+# CHECK-NEXT: lui     $4, 0x1                 # encoding: [0x01,0x00,0x04,0x3c]
+# CHECK-NEXT: and     $4, $4, $5              # encoding: [0x24,0x20,0x85,0x00]
+  and $4, $5, 0xFFFFFFFF
+# CHECK-NEXT: lui     $4, 0xffff              # encoding: [0xff,0xff,0x04,0x3c]
+# CHECK-NEXT: dsrl32  $4, $4, 0x0             # encoding: [0x3e,0x20,0x04,0x00]
+# CHECK-NEXT: and     $4, $4, $5              # encoding: [0x24,0x20,0x85,0x00]
+  and $4, $5, 0xF0000000
+# CHECK-NEXT: ori     $4, $zero, 0xf000       # encoding: [0x00,0xf0,0x04,0x34]
+# CHECK-NEXT: dsll    $4, $4, 0x10            # encoding: [0x38,0x24,0x04,0x00]
+# CHECK-NEXT: and     $4, $4, $5              # encoding: [0x24,0x20,0x85,0x00]
+  and $4, $5, 0x7FFFFFFF
+# CHECK-NEXT: lui     $4, 0x7fff              # encoding: [0xff,0x7f,0x04,0x3c]
+# CHECK-NEXT: ori     $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x34]
+# CHECK-NEXT: and     $4, $4, $5              # encoding: [0x24,0x20,0x85,0x00]
+  and $4, $5, 0x7FFFFFFFFFFFFFFF
+# CHECK-NEXT: lui     $4, 0x7fff              # encoding: [0xff,0x7f,0x04,0x3c]
+# CHECK-NEXT: ori     $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x34]
+# CHECK-NEXT: dsll    $4, $4, 0x10            # encoding: [0x38,0x24,0x04,0x00]
+# CHECK-NEXT: ori     $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x34]
+# CHECK-NEXT: dsll    $4, $4, 0x10            # encoding: [0x38,0x24,0x04,0x00]
+# CHECK-NEXT: ori     $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x34]
+# CHECK-NEXT: and     $4, $4, $5              # encoding: [0x24,0x20,0x85,0x00]
+  and $4, $5, 0xFFFFFFFFFFFFFFFF
+# CHECK-NEXT: addiu   $4, $zero, -0x1         # encoding: [0xff,0xff,0x04,0x24]
+# CHECK-NEXT: and     $4, $4, $5              # encoding: [0x24,0x20,0x85,0x00]
+  and $4, $5, 0xF000000000000000
+# CHECK-NEXT: ori     $4, $zero, 0xf000       # encoding: [0x00,0xf0,0x04,0x34]
+# CHECK-NEXT: dsll    $4, $4, 0x30            # encoding: [0x3c,0x24,0x04,0x00]
+# CHECK-NEXT: and     $4, $4, $5              # encoding: [0x24,0x20,0x85,0x00]
+
+
+  nor $4, $5, 0
+# CHECK:      addiu   $4, $zero, 0x0          # encoding: [0x00,0x00,0x04,0x24]
+# CHECK-NEXT: nor     $4, $4, $5              # encoding: [0x27,0x20,0x85,0x00]
+  nor $4, $5, 1
+# CHECK-NEXT: addiu   $4, $zero, 0x1          # encoding: [0x01,0x00,0x04,0x24]
+# CHECK-NEXT: nor     $4, $4, $5              # encoding: [0x27,0x20,0x85,0x00]
+  nor $4, $5, 0x8000
+# CHECK-NEXT: ori     $4, $zero, 0x8000       # encoding: [0x00,0x80,0x04,0x34]
+# CHECK-NEXT: nor     $4, $4, $5              # encoding: [0x27,0x20,0x85,0x00]
+  nor $4, $5, -0x8000
+# CHECK-NEXT: addiu   $4, $zero, -0x8000      # encoding: [0x00,0x80,0x04,0x24]
+# CHECK-NEXT: nor     $4, $4, $5              # encoding: [0x27,0x20,0x85,0x00]
+  nor $4, $5, 0x10000
+# CHECK-NEXT: lui     $4, 0x1                 # encoding: [0x01,0x00,0x04,0x3c]
+# CHECK-NEXT: nor     $4, $4, $5              # encoding: [0x27,0x20,0x85,0x00]
+  nor $4, $5, 0x1a5a5
+# CHECK-NEXT: lui     $4, 0x1                 # encoding: [0x01,0x00,0x04,0x3c]
+# CHECK-NEXT: ori     $4, $4, 0xa5a5          # encoding: [0xa5,0xa5,0x84,0x34]
+# CHECK-NEXT: nor     $4, $4, $5              # encoding: [0x27,0x20,0x85,0x00]
+# TODO: do I need to fix nor 64 bit immediates?
+
+
+  or $4, -0x80000000
+# CHECK:      lui     $1, 0x8000              # encoding: [0x00,0x80,0x01,0x3c]
+# CHECK-NEXT: or      $4, $4, $1              # encoding: [0x25,0x20,0x81,0x00]
+  or $4, -0x8001
+# CHECK-NEXT: lui     $1, 0xffff              # encoding: [0xff,0xff,0x01,0x3c]
+# CHECK-NEXT: ori     $1, $1, 0x7fff          # encoding: [0xff,0x7f,0x21,0x34]
+# CHECK-NEXT: or      $4, $4, $1              # encoding: [0x25,0x20,0x81,0x00]
+  or $4, -0x8000
+# CHECK-NEXT: addiu   $1, $zero, -0x8000      # encoding: [0x00,0x80,0x01,0x24]
+# CHECK-NEXT: or      $4, $4, $1              # encoding: [0x25,0x20,0x81,0x00]
+  or $4, 0
+# CHECK-NEXT: ori     $4, $4, 0x0             # encoding: [0x00,0x00,0x84,0x34]
+  or $4, 0xFFFF
+# CHECK-NEXT: ori     $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x34]
+  or $4, 0x10000
+# CHECK-NEXT: lui     $1, 0x1                 # encoding: [0x01,0x00,0x01,0x3c]
+# CHECK-NEXT: or      $4, $4, $1              # encoding: [0x25,0x20,0x81,0x00]
+  or $4, 0xFFFFFFFF
+# CHECK-NEXT: lui     $1, 0xffff              # encoding: [0xff,0xff,0x01,0x3c]
+# CHECK-NEXT: dsrl32  $1, $1, 0x0             # encoding: [0x3e,0x08,0x01,0x00]
+# CHECK-NEXT: or      $4, $4, $1              # encoding: [0x25,0x20,0x81,0x00]
+  or $4, 0xF0000000
+# CHECK-NEXT: ori     $1, $zero, 0xf000       # encoding: [0x00,0xf0,0x01,0x34]
+# CHECK-NEXT: dsll    $1, $1, 0x10            # encoding: [0x38,0x0c,0x01,0x00]
+# CHECK-NEXT: or      $4, $4, $1              # encoding: [0x25,0x20,0x81,0x00]
+  or $4, 0x7FFFFFFF
+# CHECK-NEXT: lui     $1, 0x7fff              # encoding: [0xff,0x7f,0x01,0x3c]
+# CHECK-NEXT: ori     $1, $1, 0xffff          # encoding: [0xff,0xff,0x21,0x34]
+# CHECK-NEXT: or      $4, $4, $1              # encoding: [0x25,0x20,0x81,0x00]
+  or $4, 0x7FFFFFFFFFFFFFFF
+# CHECK-NEXT: lui     $1, 0x7fff              # encoding: [0xff,0x7f,0x01,0x3c]
+# CHECK-NEXT: ori     $1, $1, 0xffff          # encoding: [0xff,0xff,0x21,0x34]
+# CHECK-NEXT: dsll    $1, $1, 0x10            # encoding: [0x38,0x0c,0x01,0x00]
+# CHECK-NEXT: ori     $1, $1, 0xffff          # encoding: [0xff,0xff,0x21,0x34]
+# CHECK-NEXT: dsll    $1, $1, 0x10            # encoding: [0x38,0x0c,0x01,0x00]
+# CHECK-NEXT: ori     $1, $1, 0xffff          # encoding: [0xff,0xff,0x21,0x34]
+# CHECK-NEXT: or      $4, $4, $1              # encoding: [0x25,0x20,0x81,0x00]
+  or $4, 0xFFFFFFFFFFFFFFFF
+# CHECK-NEXT: addiu   $1, $zero, -0x1         # encoding: [0xff,0xff,0x01,0x24]
+# CHECK-NEXT: or      $4, $4, $1              # encoding: [0x25,0x20,0x81,0x00]
+  or $4, 0xF000000000000000
+# CHECK-NEXT: ori     $1, $zero, 0xf000       # encoding: [0x00,0xf0,0x01,0x34]
+# CHECK-NEXT: dsll    $1, $1, 0x30            # encoding: [0x3c,0x0c,0x01,0x00]
+# CHECK-NEXT: or      $4, $4, $1              # encoding: [0x25,0x20,0x81,0x00]
+
+  or $4, $5, -0x80000000
+# CHECK:      lui     $4, 0x8000              # encoding: [0x00,0x80,0x04,0x3c]
+# CHECK-NEXT: or      $4, $4, $5              # encoding: [0x25,0x20,0x85,0x00]
+  or $4, $5, -0x8001
+# CHECK-NEXT: lui     $4, 0xffff              # encoding: [0xff,0xff,0x04,0x3c]
+# CHECK-NEXT: ori     $4, $4, 0x7fff          # encoding: [0xff,0x7f,0x84,0x34]
+# CHECK-NEXT: or      $4, $4, $5              # encoding: [0x25,0x20,0x85,0x00]
+  or $4, $5, -0x8000
+# CHECK-NEXT: addiu   $4, $zero, -0x8000      # encoding: [0x00,0x80,0x04,0x24]
+# CHECK-NEXT: or      $4, $4, $5              # encoding: [0x25,0x20,0x85,0x00]
+  or $4, $5, 0
+# CHECK-NEXT: ori     $4, $5, 0x0             # encoding: [0x00,0x00,0xa4,0x34]
+  or $4, $5, 0xFFFF
+# CHECK-NEXT: ori     $4, $5, 0xffff          # encoding: [0xff,0xff,0xa4,0x34]
+  or $4, $5, 0x10000
+# CHECK-NEXT: lui     $4, 0x1                 # encoding: [0x01,0x00,0x04,0x3c]
+# CHECK-NEXT: or      $4, $4, $5              # encoding: [0x25,0x20,0x85,0x00]
+  or $4, $5, 0xFFFFFFFF
+# CHECK-NEXT: lui     $4, 0xffff              # encoding: [0xff,0xff,0x04,0x3c]
+# CHECK-NEXT: dsrl32  $4, $4, 0x0             # encoding: [0x3e,0x20,0x04,0x00]
+# CHECK-NEXT: or      $4, $4, $5              # encoding: [0x25,0x20,0x85,0x00]
+  or $4, $5, 0xF0000000
+# CHECK-NEXT: ori     $4, $zero, 0xf000       # encoding: [0x00,0xf0,0x04,0x34]
+# CHECK-NEXT: dsll    $4, $4, 0x10            # encoding: [0x38,0x24,0x04,0x00]
+# CHECK-NEXT: or      $4, $4, $5              # encoding: [0x25,0x20,0x85,0x00]
+  or $4, $5, 0x7FFFFFFF
+# CHECK-NEXT: lui     $4, 0x7fff              # encoding: [0xff,0x7f,0x04,0x3c]
+# CHECK-NEXT: ori     $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x34]
+# CHECK-NEXT: or      $4, $4, $5              # encoding: [0x25,0x20,0x85,0x00]
+  or $4, $5, 0x7FFFFFFFFFFFFFFF
+# CHECK-NEXT: lui     $4, 0x7fff              # encoding: [0xff,0x7f,0x04,0x3c]
+# CHECK-NEXT: ori     $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x34]
+# CHECK-NEXT: dsll    $4, $4, 0x10            # encoding: [0x38,0x24,0x04,0x00]
+# CHECK-NEXT: ori     $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x34]
+# CHECK-NEXT: dsll    $4, $4, 0x10            # encoding: [0x38,0x24,0x04,0x00]
+# CHECK-NEXT: ori     $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x34]
+# CHECK-NEXT: or      $4, $4, $5              # encoding: [0x25,0x20,0x85,0x00]
+  or $4, $5, 0xFFFFFFFFFFFFFFFF
+# CHECK-NEXT: addiu   $4, $zero, -0x1         # encoding: [0xff,0xff,0x04,0x24]
+# CHECK-NEXT: or      $4, $4, $5              # encoding: [0x25,0x20,0x85,0x00]
+  or $4, $5, 0xF000000000000000
+# CHECK-NEXT: ori     $4, $zero, 0xf000       # encoding: [0x00,0xf0,0x04,0x34]
+# CHECK-NEXT: dsll    $4, $4, 0x30            # encoding: [0x3c,0x24,0x04,0x00]
+# CHECK-NEXT: or      $4, $4, $5              # encoding: [0x25,0x20,0x85,0x00]
+
+
+# FIXME slt is broken.....
+
+  slt $4, $5, -0x80000000
+# CHECK:      lui     $4, 0x8000              # encoding: [0x00,0x80,0x04,0x3c]
+# CHECK-NEXT: slt     $4, $4, $5              # encoding: [0x2a,0x20,0x85,0x00]
+  slt $4, $5, -0x8001
+# CHECK-NEXT: lui     $4, 0xffff              # encoding: [0xff,0xff,0x04,0x3c]
+# CHECK-NEXT: ori     $4, $4, 0x7fff          # encoding: [0xff,0x7f,0x84,0x34]
+# CHECK-NEXT: slt     $4, $4, $5              # encoding: [0x2a,0x20,0x85,0x00]
+  slt $4, $5, -0x8000
+# CHECK-NEXT: slti    $4, $5, -0x8000         # encoding: [0x00,0x80,0xa4,0x28]
+  slt $4, $5, 0
+# CHECK-NEXT: slti    $4, $5, 0x0             # encoding: [0x00,0x00,0xa4,0x28]
+  slt $4, $5, 0xFFFF
+# CHECK-NEXT: ori     $4, $zero, 0xffff       # encoding: [0xff,0xff,0x04,0x34]
+# CHECK-NEXT: slt     $4, $4, $5              # encoding: [0x2a,0x20,0x85,0x00]
+  slt $4, $5, 0x10000
+# CHECK-NEXT: lui     $4, 0x1                 # encoding: [0x01,0x00,0x04,0x3c]
+# CHECK-NEXT: slt     $4, $4, $5              # encoding: [0x2a,0x20,0x85,0x00]
+  slt $4, $5, 0xFFFFFFFF
+# CHECK-NEXT: slti    $4, $5, -0x1            # encoding: [0xff,0xff,0xa4,0x28]
+
+  sltu $4, $5, -0x80000000
+# CHECK:      lui     $4, 0x8000              # encoding: [0x00,0x80,0x04,0x3c]
+# CHECK-NEXT: sltu    $4, $4, $5              # encoding: [0x2b,0x20,0x85,0x00]
+  sltu $4, $5, -0x8001
+# CHECK-NEXT: lui     $4, 0xffff              # encoding: [0xff,0xff,0x04,0x3c]
+# CHECK-NEXT: ori     $4, $4, 0x7fff          # encoding: [0xff,0x7f,0x84,0x34]
+# CHECK-NEXT: sltu    $4, $4, $5              # encoding: [0x2b,0x20,0x85,0x00]
+  sltu $4, $5, -0x8000
+# CHECK-NEXT: sltiu   $4, $5, -0x8000         # encoding: [0x00,0x80,0xa4,0x2c]
+  sltu $4, $5, 0
+# CHECK-NEXT: sltiu   $4, $5, 0x0             # encoding: [0x00,0x00,0xa4,0x2c]
+  sltu $4, $5, 0xFFFF
+# CHECK-NEXT: ori     $4, $zero, 0xffff       # encoding: [0xff,0xff,0x04,0x34]
+# CHECK-NEXT: sltu    $4, $4, $5              # encoding: [0x2b,0x20,0x85,0x00]
+  sltu $4, $5, 0x10000
+# CHECK-NEXT: lui     $4, 0x1                 # encoding: [0x01,0x00,0x04,0x3c]
+# CHECK-NEXT: sltu    $4, $4, $5              # encoding: [0x2b,0x20,0x85,0x00]
+# FIXME: should this be sign extended or not???
+  sltu $4, $5, 0xFFFFFFFF
+# CHECK-NEXT: sltiu   $4, $5, -0x1            # encoding: [0xff,0xff,0xa4,0x2c]
+
+
+
+  xor $4, -0x80000000
+# CHECK:      lui     $1, 0x8000              # encoding: [0x00,0x80,0x01,0x3c]
+# CHECK-NEXT: xor     $4, $4, $1              # encoding: [0x26,0x20,0x81,0x00]
+  xor $4, -0x8001
+# CHECK-NEXT: lui     $1, 0xffff              # encoding: [0xff,0xff,0x01,0x3c]
+# CHECK-NEXT: ori     $1, $1, 0x7fff          # encoding: [0xff,0x7f,0x21,0x34]
+# CHECK-NEXT: xor     $4, $4, $1              # encoding: [0x26,0x20,0x81,0x00]
+  xor $4, -0x8000
+# CHECK-NEXT: addiu   $1, $zero, -0x8000      # encoding: [0x00,0x80,0x01,0x24]
+# CHECK-NEXT: xor     $4, $4, $1              # encoding: [0x26,0x20,0x81,0x00]
+  xor $4, 0
+# CHECK-NEXT: xori    $4, $4, 0x0             # encoding: [0x00,0x00,0x84,0x38]
+  xor $4, 0xFFFF
+# CHECK-NEXT: xori    $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x38]
+  xor $4, 0x10000
+# CHECK-NEXT: lui     $1, 0x1                 # encoding: [0x01,0x00,0x01,0x3c]
+# CHECK-NEXT: xor     $4, $4, $1              # encoding: [0x26,0x20,0x81,0x00]
+  xor $4, 0xFFFFFFFF
+# CHECK-NEXT: lui     $1, 0xffff              # encoding: [0xff,0xff,0x01,0x3c]
+# CHECK-NEXT: dsrl32  $1, $1, 0x0             # encoding: [0x3e,0x08,0x01,0x00]
+# CHECK-NEXT: xor     $4, $4, $1              # encoding: [0x26,0x20,0x81,0x00]
+  xor $4, 0xF0000000
+# CHECK-NEXT: ori     $1, $zero, 0xf000       # encoding: [0x00,0xf0,0x01,0x34]
+# CHECK-NEXT: dsll    $1, $1, 0x10            # encoding: [0x38,0x0c,0x01,0x00]
+# CHECK-NEXT: xor     $4, $4, $1              # encoding: [0x26,0x20,0x81,0x00
+  xor $4, 0x7FFFFFFF
+# CHECK-NEXT: lui     $1, 0x7fff              # encoding: [0xff,0x7f,0x01,0x3c]
+# CHECK-NEXT: ori     $1, $1, 0xffff          # encoding: [0xff,0xff,0x21,0x34]
+# CHECK-NEXT: xor     $4, $4, $1              # encoding: [0x26,0x20,0x81,0x00]
+  xor $4, 0x7FFFFFFFFFFFFFFF
+# CHECK-NEXT: lui     $1, 0x7fff              # encoding: [0xff,0x7f,0x01,0x3c]
+# CHECK-NEXT: ori     $1, $1, 0xffff          # encoding: [0xff,0xff,0x21,0x34]
+# CHECK-NEXT: dsll    $1, $1, 0x10            # encoding: [0x38,0x0c,0x01,0x00]
+# CHECK-NEXT: ori     $1, $1, 0xffff          # encoding: [0xff,0xff,0x21,0x34]
+# CHECK-NEXT: dsll    $1, $1, 0x10            # encoding: [0x38,0x0c,0x01,0x00]
+# CHECK-NEXT: ori     $1, $1, 0xffff          # encoding: [0xff,0xff,0x21,0x34]
+# CHECK-NEXT: xor     $4, $4, $1              # encoding: [0x26,0x20,0x81,0x00]
+  xor $4, 0xFFFFFFFFFFFFFFFF
+# CHECK-NEXT: addiu   $1, $zero, -0x1         # encoding: [0xff,0xff,0x01,0x24]
+# CHECK-NEXT: xor     $4, $4, $1              # encoding: [0x26,0x20,0x81,0x00]
+  xor $4, 0xF000000000000000
+# CHECK-NEXT: ori     $1, $zero, 0xf000       # encoding: [0x00,0xf0,0x01,0x34]
+# CHECK-NEXT: dsll    $1, $1, 0x30            # encoding: [0x3c,0x0c,0x01,0x00]
+# CHECK-NEXT: xor     $4, $4, $1              # encoding: [0x26,0x20,0x81,0x00]
+  xor $4, $5, -0x80000000
+# CHECK-NEXT: lui     $4, 0x8000              # encoding: [0x00,0x80,0x04,0x3c]
+# CHECK-NEXT: xor     $4, $4, $5              # encoding: [0x26,0x20,0x85,0x00]
+  xor $4, $5, -0x8001
+# CHECK-NEXT: lui     $4, 0xffff              # encoding: [0xff,0xff,0x04,0x3c]
+# CHECK-NEXT: ori     $4, $4, 0x7fff          # encoding: [0xff,0x7f,0x84,0x34]
+# CHECK-NEXT: xor     $4, $4, $5              # encoding: [0x26,0x20,0x85,0x00]
+  xor $4, $5, -0x8000
+# CHECK-NEXT: addiu   $4, $zero, -0x8000      # encoding: [0x00,0x80,0x04,0x24]
+# CHECK-NEXT: xor     $4, $4, $5              # encoding: [0x26,0x20,0x85,0x00]
+  xor $4, $5, 0
+# CHECK-NEXT: xori    $4, $5, 0x0             # encoding: [0x00,0x00,0xa4,0x38]
+  xor $4, $5, 0xFFFF
+# CHECK-NEXT: xori    $4, $5, 0xffff          # encoding: [0xff,0xff,0xa4,0x38]
+  xor $4, $5, 0x10000
+# CHECK-NEXT: lui     $4, 0x1                 # encoding: [0x01,0x00,0x04,0x3c]
+# CHECK-NEXT: xor     $4, $4, $5              # encoding: [0x26,0x20,0x85,0x00]
+  xor $4, $5, 0xFFFFFFFF
+# CHECK-NEXT: lui     $4, 0xffff              # encoding: [0xff,0xff,0x04,0x3c]
+# CHECK-NEXT: dsrl32  $4, $4, 0x0             # encoding: [0x3e,0x20,0x04,0x00]
+# CHECK-NEXT: xor     $4, $4, $5              # encoding: [0x26,0x20,0x85,0x00]
+  xor $4, $5, 0xF0000000
+# CHECK-NEXT: ori     $4, $zero, 0xf000       # encoding: [0x00,0xf0,0x04,0x34]
+# CHECK-NEXT: dsll    $4, $4, 0x10            # encoding: [0x38,0x24,0x04,0x00]
+# CHECK-NEXT: xor     $4, $4, $5              # encoding: [0x26,0x20,0x85,0x00]
+  xor $4, $5, 0x7FFFFFFF
+# CHECK-NEXT: lui     $4, 0x7fff              # encoding: [0xff,0x7f,0x04,0x3c]
+# CHECK-NEXT: ori     $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x34]
+# CHECK-NEXT: xor     $4, $4, $5              # encoding: [0x26,0x20,0x85,0x00]
+  xor $4, $5, 0x7FFFFFFFFFFFFFFF
+# XXXAR: this is awfully inefficient...
+# CHECK-NEXT: lui     $4, 0x7fff              # encoding: [0xff,0x7f,0x04,0x3c]
+# CHECK-NEXT: ori     $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x34]
+# CHECK-NEXT: dsll    $4, $4, 0x10            # encoding: [0x38,0x24,0x04,0x00]
+# CHECK-NEXT: ori     $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x34]
+# CHECK-NEXT: dsll    $4, $4, 0x10            # encoding: [0x38,0x24,0x04,0x00]
+# CHECK-NEXT: ori     $4, $4, 0xffff          # encoding: [0xff,0xff,0x84,0x34]
+# CHECK-NEXT: xor     $4, $4, $5              # encoding: [0x26,0x20,0x85,0x00]
+  xor $4, $5, 0xFFFFFFFFFFFFFFFF
+# CHECK-NEXT: addiu   $4, $zero, -0x1         # encoding: [0xff,0xff,0x04,0x24]
+# CHECK-NEXT: xor     $4, $4, $5              # encoding: [0x26,0x20,0x85,0x00]
+  xor $4, $5, 0xF000000000000000
+# CHECK-NEXT: ori     $4, $zero, 0xf000       # encoding: [0x00,0xf0,0x04,0x34]
+# CHECK-NEXT: dsll    $4, $4, 0x30            # encoding: [0x3c,0x24,0x04,0x00]
+# CHECK-NEXT: xor     $4, $4, $5              # encoding: [0x26,0x20,0x85,0x00]