mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-01-10 22:00:58 +00:00
[mips] Expansion of LI.S and LI.D
Author: smaksimovic Reviewers: dsanders sdardis Introduces LI.S and LI.D pseudo instructions with floating point operands. Differential Revision: https://reviews.llvm.org/D14390 llvm-svn: 304198
This commit is contained in:
Zoran Jovanovic
parent
1166792bbb
commit
4b4c818646
@ -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"
|
||||
@ -216,9 +217,15 @@ class MipsAsmParser : public MCTargetAsmParser {
|
||||
unsigned SrcReg, bool Is32BitSym, SMLoc IDLoc,
|
||||
MCStreamer &Out, const MCSubtargetInfo *STI);
|
||||
|
||||
bool emitPartialAddress(MipsTargetStreamer &TOut, SMLoc IDLoc, MCSymbol *Sym);
|
||||
|
||||
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 +1018,16 @@ public:
|
||||
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 +1044,15 @@ public:
|
||||
"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 +1600,11 @@ public:
|
||||
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 +2399,27 @@ MipsAsmParser::tryExpandInstruction(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
|
||||
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 +3004,302 @@ bool MipsAsmParser::loadAndAddSymbolAddress(const MCExpr *SymExpr,
|
||||
return false;
|
||||
}
|
||||
|
||||
// Each double-precision register DO-D15 overlaps with two of the single
|
||||
// precision registers F0-F31. As an example, all of the following hold true:
|
||||
// D0 + 1 == F1, F1 + 1 == D1, F1 + 1 == F2, depending on the context.
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
// FIXME: This method is too general. In principle we should compute the number
|
||||
// of instructions required to synthesize the immediate inline compared to
|
||||
// synthesizing the address inline and relying on non .text sections.
|
||||
// For static O32 and N32 this may yield a small benefit, for static N64 this is
|
||||
// likely to yield a much larger benefit as we have to synthesize a 64bit
|
||||
// address to load a 64 bit value.
|
||||
bool MipsAsmParser::emitPartialAddress(MipsTargetStreamer &TOut, SMLoc IDLoc,
|
||||
MCSymbol *Sym) {
|
||||
unsigned ATReg = getATReg(IDLoc);
|
||||
if (!ATReg)
|
||||
return true;
|
||||
|
||||
if(IsPicEnabled) {
|
||||
const MCExpr *GotSym =
|
||||
MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
|
||||
const MipsMCExpr *GotExpr =
|
||||
MipsMCExpr::create(MipsMCExpr::MEK_GOT, GotSym, getContext());
|
||||
|
||||
if(isABI_O32() || 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, getContext());
|
||||
const MipsMCExpr *HiExpr =
|
||||
MipsMCExpr::create(MipsMCExpr::MEK_HI, HiSym, getContext());
|
||||
|
||||
// FIXME: This is technically correct but gives a different result to gas,
|
||||
// but gas is incomplete there (it has a fixme noting it doesn't work with
|
||||
// 64-bit addresses).
|
||||
// FIXME: With -msym32 option, the address expansion for N64 should probably
|
||||
// use the O32 / N32 case. It's safe to use the 64 address expansion as the
|
||||
// symbol's value is considered sign extended.
|
||||
if(isABI_O32() || isABI_N32()) {
|
||||
TOut.emitRX(Mips::LUi, ATReg, MCOperand::createExpr(HiExpr), IDLoc, STI);
|
||||
} else { //isABI_N64()
|
||||
const MCExpr *HighestSym =
|
||||
MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
|
||||
const MipsMCExpr *HighestExpr =
|
||||
MipsMCExpr::create(MipsMCExpr::MEK_HIGHEST, HighestSym, getContext());
|
||||
const MCExpr *HigherSym =
|
||||
MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
|
||||
const MipsMCExpr *HigherExpr =
|
||||
MipsMCExpr::create(MipsMCExpr::MEK_HIGHER, HigherSym, 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);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
MCSymbol *Sym = getContext().createTempSymbol();
|
||||
const MCExpr *LoSym =
|
||||
MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
|
||||
const MipsMCExpr *LoExpr =
|
||||
MipsMCExpr::create(MipsMCExpr::MEK_LO, LoSym, getContext());
|
||||
|
||||
getStreamer().SwitchSection(ReadOnlySection);
|
||||
getStreamer().EmitLabel(Sym, IDLoc);
|
||||
getStreamer().EmitIntValue(ImmOp32, 4);
|
||||
getStreamer().SwitchSection(CS);
|
||||
|
||||
if(emitPartialAddress(TOut, IDLoc, Sym))
|
||||
return true;
|
||||
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);
|
||||
|
||||
MCSymbol *Sym = getContext().createTempSymbol();
|
||||
const MCExpr *LoSym =
|
||||
MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
|
||||
const MipsMCExpr *LoExpr =
|
||||
MipsMCExpr::create(MipsMCExpr::MEK_LO, LoSym, getContext());
|
||||
|
||||
getStreamer().SwitchSection(ReadOnlySection);
|
||||
getStreamer().EmitLabel(Sym, IDLoc);
|
||||
getStreamer().EmitIntValue(HiImmOp64, 4);
|
||||
getStreamer().EmitIntValue(LoImmOp64, 4);
|
||||
getStreamer().SwitchSection(CS);
|
||||
|
||||
if(emitPartialAddress(TOut, IDLoc, Sym))
|
||||
return true;
|
||||
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);
|
||||
|
||||
MCSymbol *Sym = getContext().createTempSymbol();
|
||||
const MCExpr *LoSym =
|
||||
MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
|
||||
const MipsMCExpr *LoExpr =
|
||||
MipsMCExpr::create(MipsMCExpr::MEK_LO, LoSym, getContext());
|
||||
|
||||
getStreamer().SwitchSection(ReadOnlySection);
|
||||
getStreamer().EmitLabel(Sym, IDLoc);
|
||||
getStreamer().EmitIntValue(HiImmOp64, 4);
|
||||
getStreamer().EmitIntValue(LoImmOp64, 4);
|
||||
getStreamer().SwitchSection(CS);
|
||||
|
||||
if(emitPartialAddress(TOut, IDLoc, Sym))
|
||||
return true;
|
||||
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 +4666,6 @@ bool MipsAsmParser::expandDMULMacro(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
|
||||
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);
|
||||
|
||||
@ -681,6 +681,29 @@ def PseudoTRUNC_W_D : MipsAsmPseudoInst<(outs FGR32Opnd:$fd),
|
||||
"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.
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@ -552,16 +552,31 @@ def AFGR64AsmOperand : MipsAsmRegOperand {
|
||||
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 @@ def AFGR64Opnd : RegisterOperand<AFGR64> {
|
||||
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.
|
||||
|
||||
443
test/MC/Mips/macro-li.d.s
Normal file
443
test/MC/Mips/macro-li.d.s
Normal file
@ -0,0 +1,443 @@
|
||||
# RUN: llvm-mc %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips32 -target-abi=o32 | FileCheck %s --check-prefixes=ALL,O32-N32-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,O32-N32-PIC,O32
|
||||
# RUN: llvm-mc %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips64 -target-abi=n32 | FileCheck %s --check-prefixes=ALL,O32-N32-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,O32-N32-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: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1072822694
|
||||
# ALL: .4byte 3037400872
|
||||
# ALL: .text
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# O32-N32-NO-PIC: addiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x24]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-PIC: addiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x24]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-PIC: daddiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), 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: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1107754720
|
||||
# ALL: .4byte 3790602240
|
||||
# ALL: .text
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# O32-N32-NO-PIC: addiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x24]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-PIC: addiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x24]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-PIC: daddiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), 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: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1107754720
|
||||
# ALL: .4byte 3790602240
|
||||
# ALL: .text
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# O32-N32-NO-PIC: addiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x24]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-PIC: addiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x24]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-PIC: daddiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), 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: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1071225241
|
||||
# ALL: .4byte 2576980378
|
||||
# ALL: .text
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# O32-N32-NO-PIC: addiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x24]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-PIC: addiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x24]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-PIC: daddiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), 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: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1107754720
|
||||
# ALL: .4byte 3790666967
|
||||
# ALL: .text
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# O32-N32-NO-PIC: addiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x24]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-PIC: addiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x24]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-PIC: daddiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), 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: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1139108501
|
||||
# ALL: .4byte 836738583
|
||||
# ALL: .text
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# O32-N32-NO-PIC: addiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x24]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-PIC: addiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x24]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-PIC: daddiu $1, $1, %lo([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %lo([[LABEL]]), 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: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1072822694
|
||||
# ALL: .4byte 3037400872
|
||||
# ALL: .text
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# ALL: ldc1 $f4, %lo([[LABEL]])($1) # encoding: [A,A,0x24,0xd4]
|
||||
# ALL: # fixup A - offset: 0, value: %lo([[LABEL]]), 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: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1107754720
|
||||
# ALL: .4byte 3790602240
|
||||
# ALL: .text
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# ALL: ldc1 $f4, %lo([[LABEL]])($1) # encoding: [A,A,0x24,0xd4]
|
||||
# ALL: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
|
||||
li.d $f4, 12345678910.0
|
||||
# ALL: .section .rodata,"a",@progbits
|
||||
# ALL: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1107754720
|
||||
# ALL: .4byte 3790602240
|
||||
# ALL: .text
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# ALL: ldc1 $f4, %lo([[LABEL]])($1) # encoding: [A,A,0x24,0xd4]
|
||||
# ALL: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
|
||||
li.d $f4, 0.4
|
||||
# ALL: .section .rodata,"a",@progbits
|
||||
# ALL: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1071225241
|
||||
# ALL: .4byte 2576980378
|
||||
# ALL: .text
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# ALL: ldc1 $f4, %lo([[LABEL]])($1) # encoding: [A,A,0x24,0xd4]
|
||||
# ALL: # fixup A - offset: 0, value: %lo([[LABEL]]), 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: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1074012160
|
||||
# ALL: .4byte 0
|
||||
# ALL: .text
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# ALL: ldc1 $f4, %lo([[LABEL]])($1) # encoding: [A,A,0x24,0xd4]
|
||||
# ALL: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
|
||||
li.d $f4, 12345678910.12345678910
|
||||
# ALL: .section .rodata,"a",@progbits
|
||||
# ALL: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1107754720
|
||||
# ALL: .4byte 3790666967
|
||||
# ALL: .text
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# ALL: ldc1 $f4, %lo([[LABEL]])($1) # encoding: [A,A,0x24,0xd4]
|
||||
# ALL: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
|
||||
li.d $f4, 12345678910123456789.12345678910
|
||||
# ALL: .section .rodata,"a",@progbits
|
||||
# ALL: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1139108501
|
||||
# ALL: .4byte 836738583
|
||||
# ALL: .text
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# ALL: ldc1 $f4, %lo([[LABEL]])($1) # encoding: [A,A,0x24,0xd4]
|
||||
# ALL: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
198
test/MC/Mips/macro-li.s.s
Normal file
198
test/MC/Mips/macro-li.s.s
Normal file
@ -0,0 +1,198 @@
|
||||
# RUN: llvm-mc %s -triple=mipsel-unknown-linux -show-encoding -target-abi=o32 | FileCheck %s --check-prefixes=ALL,O32-N32-NO-PIC
|
||||
# RUN: llvm-mc %s -triple=mipsel-unknown-linux -show-encoding -target-abi=o32 -position-independent | FileCheck %s --check-prefixes=ALL,O32-N32-PIC
|
||||
# RUN: llvm-mc %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips64 -target-abi=n32 | FileCheck %s --check-prefixes=ALL,O32-N32-NO-PIC
|
||||
# RUN: llvm-mc %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips64 -target-abi=n32 -position-independent | FileCheck %s --check-prefixes=ALL,O32-N32-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: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1066388790
|
||||
# ALL: .text
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# ALL: lwc1 $f4, %lo([[LABEL]])($1) # encoding: [A,A,0x24,0xc4]
|
||||
# ALL: # fixup A - offset: 0, value: %lo([[LABEL]]), 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: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1345844999
|
||||
# ALL: .text
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# ALL: lwc1 $f4, %lo([[LABEL]])($1) # encoding: [A,A,0x24,0xc4]
|
||||
# ALL: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
|
||||
li.s $f4, 12345678910.0
|
||||
# ALL: .section .rodata,"a",@progbits
|
||||
# ALL: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1345844999
|
||||
# ALL: .text
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# ALL: lwc1 $f4, %lo([[LABEL]])($1) # encoding: [A,A,0x24,0xc4]
|
||||
# ALL: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
|
||||
|
||||
li.s $f4, 0.4
|
||||
# ALL: .section .rodata,"a",@progbits
|
||||
# ALL: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1053609165
|
||||
# ALL: .text
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# ALL: lwc1 $f4, %lo([[LABEL]])($1) # encoding: [A,A,0x24,0xc4]
|
||||
# ALL: # fixup A - offset: 0, value: %lo([[LABEL]]), 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: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1345844999
|
||||
# ALL: .text
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# ALL: lwc1 $f4, %lo([[LABEL]])($1) # encoding: [A,A,0x24,0xc4]
|
||||
# ALL: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
|
||||
li.s $f4, 12345678910123456789.12345678910
|
||||
# ALL: .section .rodata,"a",@progbits
|
||||
# ALL: [[LABEL:\$tmp[0-9]+]]:
|
||||
# ALL: .4byte 1596675242
|
||||
# ALL: .text
|
||||
# O32-N32-PIC: lw $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0x8f]
|
||||
# O32-N32-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# O32-N32-NO-PIC: lui $1, %hi([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# O32-N32-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-PIC: ld $1, %got([[LABEL]])($gp) # encoding: [A,A,0x81,0xdf]
|
||||
# N64-PIC: # fixup A - offset: 0, value: %got([[LABEL]]), kind: fixup_Mips_GOT
|
||||
# N64-NO-PIC: lui $1, %highest([[LABEL]]) # encoding: [A,A,0x01,0x3c]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %highest([[LABEL]]), kind: fixup_Mips_HIGHEST
|
||||
# N64-NO-PIC: daddiu $1, $1, %higher([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %higher([[LABEL]]), kind: fixup_Mips_HIGHER
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# N64-NO-PIC: daddiu $1, $1, %hi([[LABEL]]) # encoding: [A,A,0x21,0x64]
|
||||
# N64-NO-PIC: # fixup A - offset: 0, value: %hi([[LABEL]]), kind: fixup_Mips_HI16
|
||||
# N64-NO-PIC: dsll $1, $1, 16 # encoding: [0x38,0x0c,0x01,0x00]
|
||||
# ALL: lwc1 $f4, %lo([[LABEL]])($1) # encoding: [A,A,0x24,0xc4]
|
||||
# ALL: # fixup A - offset: 0, value: %lo([[LABEL]]), kind: fixup_Mips_LO16
|
||||
Loading…
x
Reference in New Issue
Block a user