Index: lib/Target/Mips/AsmParser/MipsAsmParser.cpp
===================================================================
--- lib/Target/Mips/AsmParser/MipsAsmParser.cpp
+++ lib/Target/Mips/AsmParser/MipsAsmParser.cpp
@@ -13,6 +13,7 @@
 #include "MCTargetDesc/MipsMCTargetDesc.h"
 #include "MipsTargetStreamer.h"
 #include "MCTargetDesc/MipsBaseInfo.h"
+#include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
@@ -219,6 +220,10 @@
   bool expandLoadImm(MCInst &Inst, bool Is32BitImm, SMLoc IDLoc,
                      MCStreamer &Out, const MCSubtargetInfo *STI);
 
+  bool expandLoadImmReal(MCInst &Inst, bool IsSingle, bool IsGPR, bool Is64FPU,
+                         SMLoc IDLoc, MCStreamer &Out,
+                         const MCSubtargetInfo *STI);
+
   bool expandLoadAddress(unsigned DstReg, unsigned BaseReg,
                          const MCOperand &Offset, bool Is32BitAddress,
                          SMLoc IDLoc, MCStreamer &Out,
@@ -1011,6 +1016,16 @@
     Inst.addOperand(MCOperand::createReg(getAFGR64Reg()));
   }
 
+  void addStrictlyAFGR64AsmRegOperands(MCInst &Inst, unsigned N) const {
+    assert(N == 1 && "Invalid number of operands!");
+    Inst.addOperand(MCOperand::createReg(getAFGR64Reg()));
+  }
+
+  void addStrictlyFGR64AsmRegOperands(MCInst &Inst, unsigned N) const {
+    assert(N == 1 && "Invalid number of operands!");
+    Inst.addOperand(MCOperand::createReg(getFGR64Reg()));
+  }
+
   void addFGR64AsmRegOperands(MCInst &Inst, unsigned N) const {
     assert(N == 1 && "Invalid number of operands!");
     Inst.addOperand(MCOperand::createReg(getFGR64Reg()));
@@ -1027,6 +1042,15 @@
                     "registers");
   }
 
+  void addStrictlyFGR32AsmRegOperands(MCInst &Inst, unsigned N) const {
+    assert(N == 1 && "Invalid number of operands!");
+    Inst.addOperand(MCOperand::createReg(getFGR32Reg()));
+    // FIXME: We ought to do this for -integrated-as without -via-file-asm too.
+    if (!AsmParser.useOddSPReg() && RegIdx.Index & 1)
+      AsmParser.Error(StartLoc, "-mno-odd-spreg prohibits the use of odd FPU "
+                                "registers");
+  }
+
   void addFGRH32AsmRegOperands(MCInst &Inst, unsigned N) const {
     assert(N == 1 && "Invalid number of operands!");
     Inst.addOperand(MCOperand::createReg(getFGRH32Reg()));
@@ -1574,6 +1598,11 @@
     return isRegIdx() && RegIdx.Kind & RegKind_FGR && RegIdx.Index <= 31;
   }
 
+  bool isStrictlyFGRAsmReg() const {
+    // AFGR64 is $0-$15 but we handle this in getAFGR64()
+    return isRegIdx() && RegIdx.Kind == RegKind_FGR && RegIdx.Index <= 31;
+  }
+
   bool isHWRegsAsmReg() const {
     return isRegIdx() && RegIdx.Kind & RegKind_HWRegs && RegIdx.Index <= 31;
   }
@@ -2368,6 +2397,27 @@
   case Mips::PseudoTRUNC_W_D:
     return expandTrunc(Inst, true, true, IDLoc, Out, STI) ? MER_Fail
                                                           : MER_Success;
+
+  case Mips::LoadImmSingleGPR:
+    return expandLoadImmReal(Inst, true, true, false, IDLoc, Out, STI)
+               ? MER_Fail
+               : MER_Success;
+  case Mips::LoadImmSingleFGR:
+    return expandLoadImmReal(Inst, true, false, false, IDLoc, Out, STI)
+               ? MER_Fail
+               : MER_Success;
+  case Mips::LoadImmDoubleGPR:
+    return expandLoadImmReal(Inst, false, true, false, IDLoc, Out, STI)
+               ? MER_Fail
+               : MER_Success;
+  case Mips::LoadImmDoubleFGR:
+      return expandLoadImmReal(Inst, false, false, true, IDLoc, Out, STI)
+               ? MER_Fail
+               : MER_Success;
+  case Mips::LoadImmDoubleFGR_32:
+    return expandLoadImmReal(Inst, false, false, false, IDLoc, Out, STI)
+               ? MER_Fail
+               : MER_Success;
   case Mips::Ulh:
     return expandUlh(Inst, true, IDLoc, Out, STI) ? MER_Fail : MER_Success;
   case Mips::Ulhu:
@@ -2952,6 +3002,284 @@
   return false;
 }
 
+static unsigned nextReg(unsigned Reg) {
+  if (MipsMCRegisterClasses[Mips::FGR32RegClassID].contains(Reg))
+    return Reg == (unsigned)Mips::F31 ? (unsigned)Mips::F0 : Reg + 1;
+  switch (Reg) {
+  default: llvm_unreachable("Unknown register in assembly macro expansion!");
+  case Mips::ZERO: return Mips::AT;
+  case Mips::AT:   return Mips::V0;
+  case Mips::V0:   return Mips::V1;
+  case Mips::V1:   return Mips::A0;
+  case Mips::A0:   return Mips::A1;
+  case Mips::A1:   return Mips::A2;
+  case Mips::A2:   return Mips::A3;
+  case Mips::A3:   return Mips::T0;
+  case Mips::T0:   return Mips::T1;
+  case Mips::T1:   return Mips::T2;
+  case Mips::T2:   return Mips::T3;
+  case Mips::T3:   return Mips::T4;
+  case Mips::T4:   return Mips::T5;
+  case Mips::T5:   return Mips::T6;
+  case Mips::T6:   return Mips::T7;
+  case Mips::T7:   return Mips::S0;
+  case Mips::S0:   return Mips::S1;
+  case Mips::S1:   return Mips::S2;
+  case Mips::S2:   return Mips::S3;
+  case Mips::S3:   return Mips::S4;
+  case Mips::S4:   return Mips::S5;
+  case Mips::S5:   return Mips::S6;
+  case Mips::S6:   return Mips::S7;
+  case Mips::S7:   return Mips::T8;
+  case Mips::T8:   return Mips::T9;
+  case Mips::T9:   return Mips::K0;
+  case Mips::K0:   return Mips::K1;
+  case Mips::K1:   return Mips::GP;
+  case Mips::GP:   return Mips::SP;
+  case Mips::SP:   return Mips::FP;
+  case Mips::FP:   return Mips::RA;
+  case Mips::RA:   return Mips::ZERO;
+  case Mips::D0:   return Mips::F1;
+  case Mips::D1:   return Mips::F3;
+  case Mips::D2:   return Mips::F5;
+  case Mips::D3:   return Mips::F7;
+  case Mips::D4:   return Mips::F9;
+  case Mips::D5:   return Mips::F11;
+  case Mips::D6:   return Mips::F13;
+  case Mips::D7:   return Mips::F15;
+  case Mips::D8:   return Mips::F17;
+  case Mips::D9:   return Mips::F19;
+  case Mips::D10:   return Mips::F21;
+  case Mips::D11:   return Mips::F23;
+  case Mips::D12:   return Mips::F25;
+  case Mips::D13:   return Mips::F27;
+  case Mips::D14:   return Mips::F29;
+  case Mips::D15:   return Mips::F31;
+  }
+}
+
+static void emitPartialAddress(MipsAsmParser& Parser, MipsTargetStreamer &TOut,
+                               SMLoc IDLoc, const MCSubtargetInfo *STI,
+                               MCSymbol *Sym,  unsigned ATReg,
+                               bool IsPicEnabled) {
+  if(IsPicEnabled) {
+    const MCExpr *GotSym =
+        MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None,
+                                Parser.getContext());
+    const MipsMCExpr *GotExpr =
+        MipsMCExpr::create(MipsMCExpr::MEK_GOT, GotSym, Parser.getContext());
+
+    if(Parser.isABI_O32() || Parser.isABI_N32()) {
+      TOut.emitRRX(Mips::LW, ATReg, Mips::GP, MCOperand::createExpr(GotExpr),
+                   IDLoc, STI);
+    } else { //isABI_N64()
+      TOut.emitRRX(Mips::LD, ATReg, Mips::GP, MCOperand::createExpr(GotExpr),
+                   IDLoc, STI);
+    }
+  } else { //!IsPicEnabled
+    const MCExpr *HiSym =
+        MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None,
+                                Parser.getContext());
+    const MipsMCExpr *HiExpr =
+        MipsMCExpr::create(MipsMCExpr::MEK_HI, HiSym, Parser.getContext());
+
+    if(Parser.isABI_O32() || Parser.isABI_N32()) {
+      TOut.emitRX(Mips::LUi, ATReg, MCOperand::createExpr(HiExpr), IDLoc, STI);
+    } else { //isABI_N64()
+      const MCExpr *HighestSym =
+          MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None,
+                                  Parser.getContext());
+      const MipsMCExpr *HighestExpr =
+          MipsMCExpr::create(MipsMCExpr::MEK_HIGHEST, HighestSym,
+                             Parser.getContext());
+      const MCExpr *HigherSym =
+          MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None,
+                                  Parser.getContext());
+      const MipsMCExpr *HigherExpr =
+          MipsMCExpr::create(MipsMCExpr::MEK_HIGHER, HigherSym,
+                             Parser.getContext());
+
+      TOut.emitRX(Mips::LUi, ATReg, MCOperand::createExpr(HighestExpr), IDLoc,
+                  STI);
+      TOut.emitRRX(Mips::DADDiu, ATReg, ATReg,
+                   MCOperand::createExpr(HigherExpr), IDLoc, STI);
+      TOut.emitRRI(Mips::DSLL, ATReg, ATReg, 16, IDLoc, STI);
+      TOut.emitRRX(Mips::DADDiu, ATReg, ATReg,
+                   MCOperand::createExpr(HiExpr), IDLoc, STI);
+      TOut.emitRRI(Mips::DSLL, ATReg, ATReg, 16, IDLoc, STI);
+    }
+  }
+}
+
+bool MipsAsmParser::expandLoadImmReal(MCInst &Inst, bool IsSingle, bool IsGPR,
+                                      bool Is64FPU, SMLoc IDLoc,
+                                      MCStreamer &Out,
+                                      const MCSubtargetInfo *STI) {
+  MipsTargetStreamer &TOut = getTargetStreamer();
+  assert(Inst.getNumOperands() == 2 && "Invalid operand count");
+  assert(Inst.getOperand(0).isReg() && Inst.getOperand(1).isImm() &&
+         "Invalid instruction operand.");
+
+  unsigned FirstReg = Inst.getOperand(0).getReg();
+  uint64_t ImmOp64 = Inst.getOperand(1).getImm();
+
+  uint32_t HiImmOp64 = (ImmOp64 & 0xffffffff00000000) >> 32;
+  // If ImmOp64 is AsmToken::Integer type (all bits set to zero in the
+  // exponent field), convert it to double (e.g. 1 to 1.0)
+  if ((HiImmOp64 & 0x7ff00000) == 0) {
+    APFloat RealVal(APFloat::IEEEdouble(), ImmOp64);
+    ImmOp64 = RealVal.bitcastToAPInt().getZExtValue();
+  }
+
+  uint32_t LoImmOp64 = ImmOp64 & 0xffffffff;
+  HiImmOp64 = (ImmOp64 & 0xffffffff00000000) >> 32;
+
+  if (IsSingle) {
+    // Conversion of a double in an uint64_t to a float in a uint32_t,
+    // retaining the bit pattern of a float.
+    uint32_t ImmOp32;
+    double doubleImm = BitsToDouble(ImmOp64);
+    float tmp_float = static_cast<float>(doubleImm);
+    ImmOp32 = FloatToBits(tmp_float);
+
+    if (IsGPR) {
+      if (loadImmediate(ImmOp32, FirstReg, Mips::NoRegister, true, true, IDLoc,
+                        Out, STI))
+        return true;
+      return false;
+    } else {
+      unsigned ATReg = getATReg(IDLoc);
+      if (!ATReg)
+        return true;
+      if (LoImmOp64 == 0) {
+        if (loadImmediate(ImmOp32, ATReg, Mips::NoRegister, true, true, IDLoc,
+                          Out, STI))
+          return true;
+        TOut.emitRR(Mips::MTC1, FirstReg, ATReg, IDLoc, STI);
+        return false;
+      }
+
+      MCSection *CS = getStreamer().getCurrentSectionOnly();
+      // FIXME: Enhance this expansion to use the .lit4 & .lit8 sections
+      // where appropriate.
+      MCSection *ReadOnlySection = getContext().getELFSection(
+          ".rodata", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
+      getStreamer().SwitchSection(ReadOnlySection);
+      getStreamer().EmitIntValue(ImmOp32, 4);
+      getStreamer().SwitchSection(CS);
+
+      MCSymbol *Sym = getContext().getOrCreateSymbol(
+          (dyn_cast<MCSectionELF>(ReadOnlySection))->getSectionName());
+      const MCExpr *LoSym =
+          MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
+      const MipsMCExpr *LoExpr =
+          MipsMCExpr::create(MipsMCExpr::MEK_LO, LoSym, getContext());
+
+      emitPartialAddress(*this, TOut, IDLoc, STI, Sym, ATReg, IsPicEnabled);
+      TOut.emitRRX(Mips::LWC1, FirstReg, ATReg,
+                   MCOperand::createExpr(LoExpr), IDLoc, STI);
+    }
+    return false;
+  }
+
+  // if(!IsSingle)
+  unsigned ATReg = getATReg(IDLoc);
+  if (!ATReg)
+    return true;
+
+  if (IsGPR) {
+    if (LoImmOp64 == 0) {
+      if(isABI_N32() || isABI_N64()) {
+        if (loadImmediate(HiImmOp64, FirstReg, Mips::NoRegister, false, true,
+                          IDLoc, Out, STI))
+          return true;
+        return false;
+      } else {
+        if (loadImmediate(HiImmOp64, FirstReg, Mips::NoRegister, true, true,
+                        IDLoc, Out, STI))
+          return true;
+
+        if (loadImmediate(0, nextReg(FirstReg), Mips::NoRegister, true, true,
+                        IDLoc, Out, STI))
+          return true;
+        return false;
+      }
+    }
+
+    MCSection *CS = getStreamer().getCurrentSectionOnly();
+    MCSection *ReadOnlySection = getContext().getELFSection(
+        ".rodata", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
+    getStreamer().SwitchSection(ReadOnlySection);
+    getStreamer().EmitIntValue(HiImmOp64, 4);
+    getStreamer().EmitIntValue(LoImmOp64, 4);
+    getStreamer().SwitchSection(CS);
+
+    MCSymbol *Sym = getContext().getOrCreateSymbol(
+        (dyn_cast<MCSectionELF>(ReadOnlySection))->getSectionName());
+    const MCExpr *LoSym =
+        MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
+    const MipsMCExpr *LoExpr =
+        MipsMCExpr::create(MipsMCExpr::MEK_LO, LoSym, getContext());
+
+    emitPartialAddress(*this, TOut, IDLoc, STI, Sym, ATReg, IsPicEnabled);
+    if(isABI_N64())
+      TOut.emitRRX(Mips::DADDiu, ATReg, ATReg,
+                   MCOperand::createExpr(LoExpr), IDLoc, STI);
+    else
+      TOut.emitRRX(Mips::ADDiu, ATReg, ATReg,
+                   MCOperand::createExpr(LoExpr), IDLoc, STI);
+
+    if(isABI_N32() || isABI_N64())
+      TOut.emitRRI(Mips::LD, FirstReg, ATReg, 0, IDLoc, STI);
+    else {
+      TOut.emitRRI(Mips::LW, FirstReg, ATReg, 0, IDLoc, STI);
+      TOut.emitRRI(Mips::LW, nextReg(FirstReg), ATReg, 4, IDLoc, STI);
+    }
+    return false;
+  } else { // if(!IsGPR && !IsSingle)
+    if ((LoImmOp64 == 0) &&
+        !((HiImmOp64 & 0xffff0000) && (HiImmOp64 & 0x0000ffff))) {
+      // FIXME: In the case where the constant is zero, we can load the
+      // register directly from the zero register.
+      if (loadImmediate(HiImmOp64, ATReg, Mips::NoRegister, true, true, IDLoc,
+                        Out, STI))
+        return true;
+      if (isABI_N32() || isABI_N64())
+        TOut.emitRR(Mips::DMTC1, FirstReg, ATReg, IDLoc, STI);
+      else if (hasMips32r2()) {
+        TOut.emitRR(Mips::MTC1, FirstReg, Mips::ZERO, IDLoc, STI);
+        TOut.emitRRR(Mips::MTHC1_D32, FirstReg, FirstReg, ATReg, IDLoc, STI);
+      } else {
+        TOut.emitRR(Mips::MTC1, nextReg(FirstReg), ATReg, IDLoc, STI);
+        TOut.emitRR(Mips::MTC1, FirstReg, Mips::ZERO, IDLoc, STI);
+      }
+      return false;
+    }
+
+    MCSection *CS = getStreamer().getCurrentSectionOnly();
+    // FIXME: Enhance this expansion to use the .lit4 & .lit8 sections
+    // where appropriate.
+    MCSection *ReadOnlySection = getContext().getELFSection(
+        ".rodata", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
+    getStreamer().SwitchSection(ReadOnlySection);
+    getStreamer().EmitIntValue(HiImmOp64, 4);
+    getStreamer().EmitIntValue(LoImmOp64, 4);
+    getStreamer().SwitchSection(CS);
+
+    MCSymbol *Sym = getContext().getOrCreateSymbol(
+        (dyn_cast<MCSectionELF>(ReadOnlySection))->getSectionName());
+    const MCExpr *LoSym =
+        MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
+    const MipsMCExpr *LoExpr =
+        MipsMCExpr::create(MipsMCExpr::MEK_LO, LoSym, getContext());
+
+    emitPartialAddress(*this, TOut, IDLoc, STI, Sym, ATReg, IsPicEnabled);
+    TOut.emitRRX(Is64FPU ? Mips::LDC164 : Mips::LDC1, FirstReg, ATReg,
+                 MCOperand::createExpr(LoExpr), IDLoc, STI);
+  }
+  return false;
+}
+
 bool MipsAsmParser::expandUncondBranchMMPseudo(MCInst &Inst, SMLoc IDLoc,
                                                MCStreamer &Out,
                                                const MCSubtargetInfo *STI) {
@@ -4318,45 +4646,6 @@
   return false;
 }
 
-static unsigned nextReg(unsigned Reg) {
-  switch (Reg) {
-  case Mips::ZERO: return Mips::AT;
-  case Mips::AT:   return Mips::V0;
-  case Mips::V0:   return Mips::V1;
-  case Mips::V1:   return Mips::A0;
-  case Mips::A0:   return Mips::A1;
-  case Mips::A1:   return Mips::A2;
-  case Mips::A2:   return Mips::A3;
-  case Mips::A3:   return Mips::T0;
-  case Mips::T0:   return Mips::T1;
-  case Mips::T1:   return Mips::T2;
-  case Mips::T2:   return Mips::T3;
-  case Mips::T3:   return Mips::T4;
-  case Mips::T4:   return Mips::T5;
-  case Mips::T5:   return Mips::T6;
-  case Mips::T6:   return Mips::T7;
-  case Mips::T7:   return Mips::S0;
-  case Mips::S0:   return Mips::S1;
-  case Mips::S1:   return Mips::S2;
-  case Mips::S2:   return Mips::S3;
-  case Mips::S3:   return Mips::S4;
-  case Mips::S4:   return Mips::S5;
-  case Mips::S5:   return Mips::S6;
-  case Mips::S6:   return Mips::S7;
-  case Mips::S7:   return Mips::T8;
-  case Mips::T8:   return Mips::T9;
-  case Mips::T9:   return Mips::K0;
-  case Mips::K0:   return Mips::K1;
-  case Mips::K1:   return Mips::GP;
-  case Mips::GP:   return Mips::SP;
-  case Mips::SP:   return Mips::FP;
-  case Mips::FP:   return Mips::RA;
-  case Mips::RA:   return Mips::ZERO;
-  default:         return 0;
-  }
-
-}
-
 // Expand 'ld $<reg> offset($reg2)' to 'lw $<reg>, offset($reg2);
 //                                      lw $<reg+1>>, offset+4($reg2)'
 // or expand 'sd $<reg> offset($reg2)' to 'sw $<reg>, offset($reg2);
Index: lib/Target/Mips/MipsInstrFPU.td
===================================================================
--- lib/Target/Mips/MipsInstrFPU.td
+++ lib/Target/Mips/MipsInstrFPU.td
@@ -681,6 +681,29 @@
                                         "trunc.w.d\t$fd, $fs, $rs">,
                       FGR_64, HARDFLOAT;
 
+def LoadImmSingleGPR : MipsAsmPseudoInst<(outs GPR32Opnd:$rd),
+                                         (ins imm64:$fpimm),
+                                         "li.s\t$rd, $fpimm">;
+
+def LoadImmSingleFGR : MipsAsmPseudoInst<(outs StrictlyFGR32Opnd:$rd),
+                                         (ins imm64:$fpimm),
+                                         "li.s\t$rd, $fpimm">,
+                       HARDFLOAT;
+
+def LoadImmDoubleGPR : MipsAsmPseudoInst<(outs GPR32Opnd:$rd),
+                                         (ins imm64:$fpimm),
+                                         "li.d\t$rd, $fpimm">;
+
+def LoadImmDoubleFGR_32 : MipsAsmPseudoInst<(outs StrictlyAFGR64Opnd:$rd),
+                                            (ins imm64:$fpimm),
+                                            "li.d\t$rd, $fpimm">,
+                          FGR_32, HARDFLOAT;
+
+def LoadImmDoubleFGR : MipsAsmPseudoInst<(outs StrictlyFGR64Opnd:$rd),
+                                         (ins imm64:$fpimm),
+                                         "li.d\t$rd, $fpimm">,
+                       FGR_64, HARDFLOAT;
+
 //===----------------------------------------------------------------------===//
 // InstAliases.
 //===----------------------------------------------------------------------===//
Index: lib/Target/Mips/MipsRegisterInfo.td
===================================================================
--- lib/Target/Mips/MipsRegisterInfo.td
+++ lib/Target/Mips/MipsRegisterInfo.td
@@ -552,16 +552,31 @@
   let PredicateMethod = "isFGRAsmReg";
 }
 
+def StrictlyAFGR64AsmOperand : MipsAsmRegOperand {
+  let Name = "StrictlyAFGR64AsmReg";
+  let PredicateMethod = "isStrictlyFGRAsmReg";
+}
+
 def FGR64AsmOperand : MipsAsmRegOperand {
   let Name = "FGR64AsmReg";
   let PredicateMethod = "isFGRAsmReg";
 }
 
+def StrictlyFGR64AsmOperand : MipsAsmRegOperand {
+  let Name = "StrictlyFGR64AsmReg";
+  let PredicateMethod = "isStrictlyFGRAsmReg";
+}
+
 def FGR32AsmOperand : MipsAsmRegOperand {
   let Name = "FGR32AsmReg";
   let PredicateMethod = "isFGRAsmReg";
 }
 
+def StrictlyFGR32AsmOperand : MipsAsmRegOperand {
+  let Name = "StrictlyFGR32AsmReg";
+  let PredicateMethod = "isStrictlyFGRAsmReg";
+}
+
 def FGRH32AsmOperand : MipsAsmRegOperand {
   let Name = "FGRH32AsmReg";
   let PredicateMethod = "isFGRAsmReg";
@@ -639,14 +654,26 @@
   let ParserMatchClass = AFGR64AsmOperand;
 }
 
+def StrictlyAFGR64Opnd : RegisterOperand<AFGR64> {
+  let ParserMatchClass = StrictlyAFGR64AsmOperand;
+}
+
 def FGR64Opnd : RegisterOperand<FGR64> {
   let ParserMatchClass = FGR64AsmOperand;
 }
 
+def StrictlyFGR64Opnd : RegisterOperand<FGR64> {
+  let ParserMatchClass = StrictlyFGR64AsmOperand;
+}
+
 def FGR32Opnd : RegisterOperand<FGR32> {
   let ParserMatchClass = FGR32AsmOperand;
 }
 
+def StrictlyFGR32Opnd : RegisterOperand<FGR32> {
+  let ParserMatchClass = StrictlyFGR32AsmOperand;
+}
+
 def FGRCCOpnd : RegisterOperand<FGRCC> {
   // The assembler doesn't use register classes so we can re-use
   // FGR32AsmOperand.
Index: test/MC/Mips/macro-li.d.s
===================================================================
--- test/MC/Mips/macro-li.d.s
+++ test/MC/Mips/macro-li.d.s
@@ -0,0 +1,430 @@
+# RUN: llvm-mc  %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips32 -target-abi=o32  | FileCheck %s --check-prefixes=ALL,ON32-NO-PIC,O32
+# RUN: llvm-mc  %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips32r2 -target-abi=o32 | FileCheck %s --check-prefixes=ALL,CHECK-MIPS32r2
+# RUN: llvm-mc  %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips32 -target-abi=o32 -position-independent | FileCheck %s --check-prefixes=ALL,ON32-PIC,O32
+# RUN: llvm-mc  %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips64 -target-abi=n32 | FileCheck %s --check-prefixes=ALL,ON32-NO-PIC,N32-N64
+# RUN: llvm-mc  %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips64 -target-abi=n32 -position-independent | FileCheck %s --check-prefixes=ALL,ON32-PIC,N32-N64
+# RUN: llvm-mc  %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips64 -target-abi=n64 | FileCheck %s --check-prefixes=ALL,N64-NO-PIC,N32-N64
+# RUN: llvm-mc  %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips64 -target-abi=n64 -position-independent | FileCheck %s --check-prefixes=ALL,N64-PIC,N32-N64
+
+li.d	$4, 0
+# O32:     addiu   $4, $zero, 0                # encoding: [0x00,0x00,0x04,0x24]
+# O32:     addiu   $5, $zero, 0                # encoding: [0x00,0x00,0x05,0x24]
+# N32-N64: daddiu  $4, $zero, 0                # encoding: [0x00,0x00,0x04,0x64]
+
+li.d	$4, 0.0
+# O32:     addiu   $4, $zero, 0                # encoding: [0x00,0x00,0x04,0x24]
+# O32:     addiu   $5, $zero, 0                # encoding: [0x00,0x00,0x05,0x24]
+# N32-N64: daddiu  $4, $zero, 0                # encoding: [0x00,0x00,0x04,0x64]
+
+li.d	$4, 1.12345
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1072822694
+# ALL:	.4byte	3037400872
+# ALL:	.text
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# ON32-NO-PIC:  addiu   $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x24]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-PIC:     addiu   $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x24]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-PIC:      daddiu  $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# O32:          lw      $4, 0($1)                # encoding: [0x00,0x00,0x24,0x8c]
+# O32:          lw      $5, 4($1)                # encoding: [0x04,0x00,0x25,0x8c]
+# N32-N64:      ld      $4, 0($1)                # encoding: [0x00,0x00,0x24,0xdc]
+
+li.d	$4, 1
+# ALL:   lui     $4, 16368                   # encoding: [0xf0,0x3f,0x04,0x3c]
+# O32:   addiu   $5, $zero, 0                # encoding: [0x00,0x00,0x05,0x24]
+
+li.d	$4, 1.0
+# ALL:   lui     $4, 16368                   # encoding: [0xf0,0x3f,0x04,0x3c]
+# O32:   addiu   $5, $zero, 0                # encoding: [0x00,0x00,0x05,0x24]
+
+li.d	$4, 12345678910
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1107754720
+# ALL:	.4byte	3790602240
+# ALL:	.text
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# ON32-NO-PIC:  addiu   $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x24]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-PIC:     addiu   $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x24]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-PIC:      daddiu  $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# O32:          lw      $4, 0($1)                # encoding: [0x00,0x00,0x24,0x8c]
+# O32:          lw      $5, 4($1)                # encoding: [0x04,0x00,0x25,0x8c]
+# N32-N64:      ld      $4, 0($1)                # encoding: [0x00,0x00,0x24,0xdc]
+
+li.d	$4, 12345678910.0
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1107754720
+# ALL:	.4byte	3790602240
+# ALL:	.text
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# ON32-NO-PIC:  addiu   $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x24]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-PIC:     addiu   $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x24]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-PIC:      daddiu  $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# O32:          lw      $4, 0($1)                # encoding: [0x00,0x00,0x24,0x8c]
+# O32:          lw      $5, 4($1)                # encoding: [0x04,0x00,0x25,0x8c]
+# N32-N64:      ld      $4, 0($1)                # encoding: [0x00,0x00,0x24,0xdc]
+
+li.d	$4, 0.4
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1071225241
+# ALL:	.4byte	2576980378
+# ALL:	.text
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# ON32-NO-PIC:  addiu   $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x24]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-PIC:     addiu   $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x24]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-PIC:      daddiu  $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# O32:          lw      $4, 0($1)                # encoding: [0x00,0x00,0x24,0x8c]
+# O32:          lw      $5, 4($1)                # encoding: [0x04,0x00,0x25,0x8c]
+# N32-N64:      ld      $4, 0($1)                # encoding: [0x00,0x00,0x24,0xdc]
+
+li.d	$4, 1.5
+# ALL:	lui	$4, 16376               # encoding: [0xf8,0x3f,0x04,0x3c]
+# O32:	addiu	$5, $zero, 0            # encoding: [0x00,0x00,0x05,0x24]
+
+li.d	$4, 12345678910.12345678910
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1107754720
+# ALL:	.4byte	3790666967
+# ALL:	.text
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# ON32-NO-PIC:  addiu   $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x24]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-PIC:     addiu   $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x24]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-PIC:      daddiu  $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# O32:          lw      $4, 0($1)                # encoding: [0x00,0x00,0x24,0x8c]
+# O32:          lw      $5, 4($1)                # encoding: [0x04,0x00,0x25,0x8c]
+# N32-N64:      ld      $4, 0($1)                # encoding: [0x00,0x00,0x24,0xdc]
+
+
+li.d	$4, 12345678910123456789.12345678910
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1139108501
+# ALL:	.4byte	836738583
+# ALL:	.text
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# ON32-NO-PIC:  addiu   $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x24]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-PIC:     addiu   $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x24]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-PIC:      daddiu  $1, $1, %lo(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+# O32:          lw      $4, 0($1)                # encoding: [0x00,0x00,0x24,0x8c]
+# O32:          lw      $5, 4($1)                # encoding: [0x04,0x00,0x25,0x8c]
+# N32-N64:      ld      $4, 0($1)                # encoding: [0x00,0x00,0x24,0xdc]
+
+li.d	$f4, 0
+# O32:            addiu   $1, $zero, 0       # encoding: [0x00,0x00,0x01,0x24]
+# O32:            mtc1    $1, $f5            # encoding: [0x00,0x28,0x81,0x44]
+# O32:            mtc1    $zero, $f4         # encoding: [0x00,0x20,0x80,0x44]
+# CHECK-MIPS32r2: addiu   $1, $zero, 0       # encoding: [0x00,0x00,0x01,0x24]
+# CHECK-MIPS32r2: mtc1    $zero, $f4         # encoding: [0x00,0x20,0x80,0x44]
+# CHECK-MIPS32r2: mthc1   $1, $f4            # encoding: [0x00,0x20,0xe1,0x44]
+# N32-N64:        addiu   $1, $zero, 0       # encoding: [0x00,0x00,0x01,0x24]
+# N32-N64:        dmtc1   $1, $f4            # encoding: [0x00,0x20,0xa1,0x44]
+
+li.d	$f4, 0.0
+# O32:            addiu   $1, $zero, 0       # encoding: [0x00,0x00,0x01,0x24]
+# O32:            mtc1    $1, $f5            # encoding: [0x00,0x28,0x81,0x44]
+# O32:            mtc1    $zero, $f4         # encoding: [0x00,0x20,0x80,0x44]
+# CHECK-MIPS32r2: addiu   $1, $zero, 0       # encoding: [0x00,0x00,0x01,0x24]
+# CHECK-MIPS32r2: mtc1    $zero, $f4         # encoding: [0x00,0x20,0x80,0x44]
+# CHECK-MIPS32r2: mthc1   $1, $f4            # encoding: [0x00,0x20,0xe1,0x44]
+# N32-N64:        addiu   $1, $zero, 0       # encoding: [0x00,0x00,0x01,0x24]
+# N32-N64:        dmtc1   $1, $f4            # encoding: [0x00,0x20,0xa1,0x44]
+
+li.d	$f4, 1.12345
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1072822694
+# ALL:	.4byte	3037400872
+# ALL:	.text
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# ALL:          ldc1    $f4, %lo(.rodata)($1)    # encoding: [A,A,0x24,0xd4]
+# ALL:                                           #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+
+li.d	$f4, 1
+# O32:            lui     $1, 16368          # encoding: [0xf0,0x3f,0x01,0x3c]
+# O32:            mtc1    $1, $f5            # encoding: [0x00,0x28,0x81,0x44]
+# O32:            mtc1    $zero, $f4         # encoding: [0x00,0x20,0x80,0x44]
+# CHECK-MIPS32r2: lui     $1, 16368          # encoding: [0xf0,0x3f,0x01,0x3c]
+# CHECK-MIPS32r2: mtc1    $zero, $f4         # encoding: [0x00,0x20,0x80,0x44]
+# CHECK-MIPS32r2: mthc1   $1, $f4            # encoding: [0x00,0x20,0xe1,0x44]
+# N32-N64:        lui     $1, 16368          # encoding: [0xf0,0x3f,0x01,0x3c]
+# N32-N64:        dmtc1   $1, $f4            # encoding: [0x00,0x20,0xa1,0x44]
+
+li.d	$f4, 1.0
+# O32:            lui     $1, 16368          # encoding: [0xf0,0x3f,0x01,0x3c]
+# O32:            mtc1    $1, $f5            # encoding: [0x00,0x28,0x81,0x44]
+# O32:            mtc1    $zero, $f4         # encoding: [0x00,0x20,0x80,0x44]
+# CHECK-MIPS32r2: lui     $1, 16368          # encoding: [0xf0,0x3f,0x01,0x3c]
+# CHECK-MIPS32r2: mtc1    $zero, $f4         # encoding: [0x00,0x20,0x80,0x44]
+# CHECK-MIPS32r2: mthc1   $1, $f4            # encoding: [0x00,0x20,0xe1,0x44]
+# N32-N64:        lui     $1, 16368          # encoding: [0xf0,0x3f,0x01,0x3c]
+# N32-N64:        dmtc1   $1, $f4            # encoding: [0x00,0x20,0xa1,0x44]
+
+li.d	$f4, 12345678910
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1107754720
+# ALL:	.4byte	3790602240
+# ALL:	.text
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# ALL:          ldc1    $f4, %lo(.rodata)($1)    # encoding: [A,A,0x24,0xd4]
+# ALL:                                           #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+
+li.d	$f4, 12345678910.0
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1107754720
+# ALL:	.4byte	3790602240
+# ALL:	.text
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# ALL:          ldc1    $f4, %lo(.rodata)($1)    # encoding: [A,A,0x24,0xd4]
+# ALL:                                           #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+
+li.d	$f4, 0.4
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1071225241
+# ALL:	.4byte	2576980378
+# ALL:	.text
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# ALL:          ldc1    $f4, %lo(.rodata)($1)    # encoding: [A,A,0x24,0xd4]
+# ALL:                                           #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+
+li.d	$f4, 1.5 
+# O32:            lui     $1, 16376          # encoding: [0xf8,0x3f,0x01,0x3c]
+# O32:            mtc1    $1, $f5            # encoding: [0x00,0x28,0x81,0x44]
+# O32:            mtc1    $zero, $f4         # encoding: [0x00,0x20,0x80,0x44]
+# CHECK-MIPS32r2: lui     $1, 16376          # encoding: [0xf8,0x3f,0x01,0x3c]
+# CHECK-MIPS32r2: mtc1    $zero, $f4         # encoding: [0x00,0x20,0x80,0x44]
+# CHECK-MIPS32r2: mthc1   $1, $f4            # encoding: [0x00,0x20,0xe1,0x44]
+# N32-N64:        lui     $1, 16376          # encoding: [0xf8,0x3f,0x01,0x3c]
+# N32-N64:        dmtc1   $1, $f4            # encoding: [0x00,0x20,0xa1,0x44]
+
+li.d	$f4, 2.5
+# O32:            lui     $1, 16388          # encoding: [0x04,0x40,0x01,0x3c]
+# O32:            mtc1    $1, $f5            # encoding: [0x00,0x28,0x81,0x44]
+# O32:            mtc1    $zero, $f4         # encoding: [0x00,0x20,0x80,0x44]
+# CHECK-MIPS32r2: lui     $1, 16388          # encoding: [0x04,0x40,0x01,0x3c]
+# CHECK-MIPS32r2: mtc1    $zero, $f4         # encoding: [0x00,0x20,0x80,0x44]
+# CHECK-MIPS32r2: mthc1   $1, $f4            # encoding: [0x00,0x20,0xe1,0x44]
+# N32-N64:        lui     $1, 16388          # encoding: [0x04,0x40,0x01,0x3c]
+# N32-N64:        dmtc1   $1, $f4            # encoding: [0x00,0x20,0xa1,0x44]
+
+li.d	$f4, 2.515625
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1074012160
+# ALL:	.4byte	0
+# ALL:	.text
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# ALL:          ldc1    $f4, %lo(.rodata)($1)    # encoding: [A,A,0x24,0xd4]
+# ALL:                                           #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+
+li.d	$f4, 12345678910.12345678910
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1107754720
+# ALL:	.4byte	3790666967
+# ALL:	.text
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# ALL:          ldc1    $f4, %lo(.rodata)($1)    # encoding: [A,A,0x24,0xd4]
+# ALL:                                           #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+
+li.d	$f4, 12345678910123456789.12345678910
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1139108501
+# ALL:	.4byte	836738583
+# ALL:	.text
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# ALL:          ldc1    $f4, %lo(.rodata)($1)    # encoding: [A,A,0x24,0xd4]
+# ALL:                                           #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
Index: test/MC/Mips/macro-li.s.s
===================================================================
--- test/MC/Mips/macro-li.s.s
+++ test/MC/Mips/macro-li.s.s
@@ -0,0 +1,192 @@
+# RUN: llvm-mc  %s -triple=mipsel-unknown-linux -show-encoding -target-abi=o32 | FileCheck %s --check-prefixes=ALL,ON32-NO-PIC
+# RUN: llvm-mc  %s -triple=mipsel-unknown-linux -show-encoding -target-abi=o32 -position-independent | FileCheck %s --check-prefixes=ALL,ON32-PIC
+# RUN: llvm-mc  %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips64 -target-abi=n32 | FileCheck %s --check-prefixes=ALL,ON32-NO-PIC
+# RUN: llvm-mc  %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips64 -target-abi=n32 -position-independent | FileCheck %s --check-prefixes=ALL,ON32-PIC
+# RUN: llvm-mc  %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips64 -target-abi=n64 | FileCheck %s --check-prefixes=ALL,N64-NO-PIC
+# RUN: llvm-mc  %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips64 -target-abi=n64 -position-independent | FileCheck %s --check-prefixes=ALL,N64-PIC
+
+li.s	$4, 0
+# ALL:   addiu   $4, $zero, 0                # encoding: [0x00,0x00,0x04,0x24]
+
+li.s	$4, 0.0
+# ALL:   addiu   $4, $zero, 0                # encoding: [0x00,0x00,0x04,0x24]
+
+li.s	$4, 1.12345
+# ALL:   lui     $4, 16271                   # encoding: [0x8f,0x3f,0x04,0x3c]
+# ALL:   ori     $4, $4, 52534               # encoding: [0x36,0xcd,0x84,0x34]
+
+li.s	$4, 1
+# ALL:   lui     $4, 16256                   # encoding: [0x80,0x3f,0x04,0x3c]
+
+li.s	$4, 1.0
+# ALL:   lui     $4, 16256                   # encoding: [0x80,0x3f,0x04,0x3c]
+
+li.s	$4, 12345678910
+# ALL:   lui     $4, 20535                   # encoding: [0x37,0x50,0x04,0x3c]
+# ALL:   ori     $4, $4, 63239               # encoding: [0x07,0xf7,0x84,0x34]
+
+li.s	$4, 12345678910.0
+# ALL:   lui     $4, 20535                   # encoding: [0x37,0x50,0x04,0x3c]
+# ALL:   ori     $4, $4, 63239               # encoding: [0x07,0xf7,0x84,0x34]
+
+li.s	$4, 0.4
+# ALL:   lui     $4, 16076                   # encoding: [0xcc,0x3e,0x04,0x3c]
+# ALL:   ori     $4, $4, 52429               # encoding: [0xcd,0xcc,0x84,0x34]
+
+li.s	$4, 1.5
+# ALL:   lui     $4, 16320                   # encoding: [0xc0,0x3f,0x04,0x3c]
+
+li.s	$4, 12345678910.12345678910
+# ALL:   lui     $4, 20535                   # encoding: [0x37,0x50,0x04,0x3c]
+# ALL:   ori     $4, $4, 63239               # encoding: [0x07,0xf7,0x84,0x34]
+
+li.s	$4, 12345678910123456789.12345678910
+# ALL:   lui     $4, 24363                   # encoding: [0x2b,0x5f,0x04,0x3c]
+# ALL:   ori     $4, $4, 21674               # encoding: [0xaa,0x54,0x84,0x34]
+
+li.s	$f4, 0
+# ALL:   addiu   $1, $zero, 0                # encoding: [0x00,0x00,0x01,0x24]
+# ALL:   mtc1    $1, $f4                     # encoding: [0x00,0x20,0x81,0x44]
+
+li.s	$f4, 0.0
+# ALL:   addiu   $1, $zero, 0                # encoding: [0x00,0x00,0x01,0x24]
+# ALL:   mtc1    $1, $f4                     # encoding: [0x00,0x20,0x81,0x44]
+
+li.s	$f4, 1.12345
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1066388790
+# ALL:	.text
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# ALL:          lwc1    $f4, %lo(.rodata)($1)    # encoding: [A,A,0x24,0xc4]
+# ALL:                                           #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+
+li.s	$f4, 1
+# ALL:   lui     $1, 16256                   # encoding: [0x80,0x3f,0x01,0x3c]
+# ALL:   mtc1    $1, $f4                     # encoding: [0x00,0x20,0x81,0x44]
+
+li.s	$f4, 1.0
+# ALL:   lui     $1, 16256                   # encoding: [0x80,0x3f,0x01,0x3c]
+# ALL:   mtc1    $1, $f4                     # encoding: [0x00,0x20,0x81,0x44]
+
+li.s	$f4, 12345678910
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1345844999
+# ALL:	.text
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# ALL:          lwc1    $f4, %lo(.rodata)($1)    # encoding: [A,A,0x24,0xc4]
+# ALL:                                           #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+
+li.s	$f4, 12345678910.0
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1345844999
+# ALL:	.text
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# ALL:          lwc1    $f4, %lo(.rodata)($1)    # encoding: [A,A,0x24,0xc4]
+# ALL:                                           #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+
+
+li.s	$f4, 0.4
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1053609165
+# ALL:	.text
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# ALL:          lwc1    $f4, %lo(.rodata)($1)    # encoding: [A,A,0x24,0xc4]
+# ALL:                                           #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+
+li.s	$f4, 1.5
+# ALL:   lui     $1, 16320                   # encoding: [0xc0,0x3f,0x01,0x3c]
+# ALL:   mtc1    $1, $f4                     # encoding: [0x00,0x20,0x81,0x44]
+
+li.s	$f4, 12345678910.12345678910
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1345844999
+# ALL:	.text
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# ALL:          lwc1    $f4, %lo(.rodata)($1)    # encoding: [A,A,0x24,0xc4]
+# ALL:                                           #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16
+
+li.s	$f4, 12345678910123456789.12345678910
+# ALL:	.section	.rodata,"a",@progbits
+# ALL:	.4byte	1596675242
+# ALL:	.text
+# ON32-PIC:     lw      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0x8f]
+# ON32-PIC:                                      #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# ON32-NO-PIC:  lui     $1, %hi(.rodata)         # encoding: [A,A,0x01,0x3c]
+# ON32-NO-PIC:                                   #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-PIC:      ld      $1, %got(.rodata)($gp)   # encoding: [A,A,0x81,0xdf]
+# N64-PIC:                                       #   fixup A - offset: 0, value: %got(.rodata), kind: fixup_Mips_GOT
+# N64-NO-PIC:   lui     $1, %highest(.rodata)    # encoding: [A,A,0x01,0x3c]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %highest(.rodata), kind: fixup_Mips_HIGHEST
+# N64-NO-PIC:   daddiu  $1, $1, %higher(.rodata) # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %higher(.rodata), kind: fixup_Mips_HIGHER
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# N64-NO-PIC:   daddiu  $1, $1, %hi(.rodata)     # encoding: [A,A,0x21,0x64]
+# N64-NO-PIC:                                    #   fixup A - offset: 0, value: %hi(.rodata), kind: fixup_Mips_HI16
+# N64-NO-PIC:   dsll    $1, $1, 16               # encoding: [0x38,0x0c,0x01,0x00]
+# ALL:          lwc1    $f4, %lo(.rodata)($1)    # encoding: [A,A,0x24,0xc4]
+# ALL:                                           #   fixup A - offset: 0, value: %lo(.rodata), kind: fixup_Mips_LO16