[llvm] r215220 - Add support for SPE load/store from memory.
Joerg Sonnenberger
joerg at bec.de
Fri Aug 8 09:43:49 PDT 2014
Author: joerg
Date: Fri Aug 8 11:43:49 2014
New Revision: 215220
URL: http://llvm.org/viewvc/llvm-project?rev=215220&view=rev
Log:
Add support for SPE load/store from memory.
Modified:
llvm/trunk/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp
llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCMCCodeEmitter.cpp
llvm/trunk/lib/Target/PowerPC/PPCCodeEmitter.cpp
llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.td
llvm/trunk/lib/Target/PowerPC/PPCInstrSPE.td
llvm/trunk/test/MC/PowerPC/ppc64-encoding-spe.s
Modified: llvm/trunk/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp?rev=215220&r1=215219&r2=215220&view=diff
==============================================================================
--- llvm/trunk/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp (original)
+++ llvm/trunk/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp Fri Aug 8 11:43:49 2014
@@ -413,6 +413,15 @@ public:
bool isU5Imm() const { return Kind == Immediate && isUInt<5>(getImm()); }
bool isS5Imm() const { return Kind == Immediate && isInt<5>(getImm()); }
bool isU6Imm() const { return Kind == Immediate && isUInt<6>(getImm()); }
+ bool isU6ImmX2() const { return Kind == Immediate &&
+ isUInt<6>(getImm()) &&
+ (getImm() & 1) == 0; }
+ bool isU7ImmX4() const { return Kind == Immediate &&
+ isUInt<7>(getImm()) &&
+ (getImm() & 3) == 0; }
+ bool isU8ImmX8() const { return Kind == Immediate &&
+ isUInt<8>(getImm()) &&
+ (getImm() & 7) == 0; }
bool isU16Imm() const { return Kind == Expression ||
(Kind == Immediate && isUInt<16>(getImm())); }
bool isS16Imm() const { return Kind == Expression ||
Modified: llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCMCCodeEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCMCCodeEmitter.cpp?rev=215220&r1=215219&r2=215220&view=diff
==============================================================================
--- llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCMCCodeEmitter.cpp (original)
+++ llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCMCCodeEmitter.cpp Fri Aug 8 11:43:49 2014
@@ -66,6 +66,15 @@ public:
unsigned getMemRIXEncoding(const MCInst &MI, unsigned OpNo,
SmallVectorImpl<MCFixup> &Fixups,
const MCSubtargetInfo &STI) const;
+ unsigned getSPE8DisEncoding(const MCInst &MI, unsigned OpNo,
+ SmallVectorImpl<MCFixup> &Fixups,
+ const MCSubtargetInfo &STI) const;
+ unsigned getSPE4DisEncoding(const MCInst &MI, unsigned OpNo,
+ SmallVectorImpl<MCFixup> &Fixups,
+ const MCSubtargetInfo &STI) const;
+ unsigned getSPE2DisEncoding(const MCInst &MI, unsigned OpNo,
+ SmallVectorImpl<MCFixup> &Fixups,
+ const MCSubtargetInfo &STI) const;
unsigned getTLSRegEncoding(const MCInst &MI, unsigned OpNo,
SmallVectorImpl<MCFixup> &Fixups,
const MCSubtargetInfo &STI) const;
@@ -260,6 +269,54 @@ unsigned PPCMCCodeEmitter::getMemRIXEnco
}
+unsigned PPCMCCodeEmitter::getSPE8DisEncoding(const MCInst &MI, unsigned OpNo,
+ SmallVectorImpl<MCFixup> &Fixups,
+ const MCSubtargetInfo &STI)
+ const {
+ // Encode (imm, reg) as a spe8dis, which has the low 5-bits of (imm / 8)
+ // as the displacement and the next 5 bits as the register #.
+ assert(MI.getOperand(OpNo+1).isReg());
+ uint32_t RegBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), Fixups, STI) << 5;
+
+ const MCOperand &MO = MI.getOperand(OpNo);
+ assert(MO.isImm());
+ uint32_t Imm = getMachineOpValue(MI, MO, Fixups, STI) >> 3;
+ return reverseBits(Imm | RegBits) >> 22;
+}
+
+
+unsigned PPCMCCodeEmitter::getSPE4DisEncoding(const MCInst &MI, unsigned OpNo,
+ SmallVectorImpl<MCFixup> &Fixups,
+ const MCSubtargetInfo &STI)
+ const {
+ // Encode (imm, reg) as a spe4dis, which has the low 5-bits of (imm / 4)
+ // as the displacement and the next 5 bits as the register #.
+ assert(MI.getOperand(OpNo+1).isReg());
+ uint32_t RegBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), Fixups, STI) << 5;
+
+ const MCOperand &MO = MI.getOperand(OpNo);
+ assert(MO.isImm());
+ uint32_t Imm = getMachineOpValue(MI, MO, Fixups, STI) >> 2;
+ return reverseBits(Imm | RegBits) >> 22;
+}
+
+
+unsigned PPCMCCodeEmitter::getSPE2DisEncoding(const MCInst &MI, unsigned OpNo,
+ SmallVectorImpl<MCFixup> &Fixups,
+ const MCSubtargetInfo &STI)
+ const {
+ // Encode (imm, reg) as a spe2dis, which has the low 5-bits of (imm / 2)
+ // as the displacement and the next 5 bits as the register #.
+ assert(MI.getOperand(OpNo+1).isReg());
+ uint32_t RegBits = getMachineOpValue(MI, MI.getOperand(OpNo+1), Fixups, STI) << 5;
+
+ const MCOperand &MO = MI.getOperand(OpNo);
+ assert(MO.isImm());
+ uint32_t Imm = getMachineOpValue(MI, MO, Fixups, STI) >> 1;
+ return reverseBits(Imm | RegBits) >> 22;
+}
+
+
unsigned PPCMCCodeEmitter::getTLSRegEncoding(const MCInst &MI, unsigned OpNo,
SmallVectorImpl<MCFixup> &Fixups,
const MCSubtargetInfo &STI) const {
Modified: llvm/trunk/lib/Target/PowerPC/PPCCodeEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/PowerPC/PPCCodeEmitter.cpp?rev=215220&r1=215219&r2=215220&view=diff
==============================================================================
--- llvm/trunk/lib/Target/PowerPC/PPCCodeEmitter.cpp (original)
+++ llvm/trunk/lib/Target/PowerPC/PPCCodeEmitter.cpp Fri Aug 8 11:43:49 2014
@@ -70,6 +70,9 @@ namespace {
unsigned getImm16Encoding(const MachineInstr &MI, unsigned OpNo) const;
unsigned getMemRIEncoding(const MachineInstr &MI, unsigned OpNo) const;
unsigned getMemRIXEncoding(const MachineInstr &MI, unsigned OpNo) const;
+ unsigned getSPE8DisEncoding(const MachineInstr &MI, unsigned OpNo) const;
+ unsigned getSPE4DisEncoding(const MachineInstr &MI, unsigned OpNo) const;
+ unsigned getSPE2DisEncoding(const MachineInstr &MI, unsigned OpNo) const;
unsigned getTLSRegEncoding(const MachineInstr &MI, unsigned OpNo) const;
unsigned getTLSCallEncoding(const MachineInstr &MI, unsigned OpNo) const;
@@ -261,6 +264,43 @@ unsigned PPCCodeEmitter::getMemRIXEncodi
return RegBits;
}
+unsigned PPCCodeEmitter::getSPE8DisEncoding(const MachineInstr &MI, unsigned OpNo) const {
+ // Encode (imm, reg) as a spe8dis, which has the low 5-bits of (imm / 8)
+ // as the displacement and the next 5 bits as the register #.
+ assert(MI.getOperand(OpNo+1).isReg());
+ uint32_t RegBits = getMachineOpValue(MI, MI.getOperand(OpNo+1)) << 5;
+
+ const MachineOperand &MO = MI.getOperand(OpNo);
+ assert(MO.isImm());
+ uint32_t Imm = getMachineOpValue(MI, MO) >> 3;
+ return reverseBits(Imm | RegBits) >> 22;
+}
+
+
+unsigned PPCCodeEmitter::getSPE4DisEncoding(const MachineInstr &MI, unsigned OpNo) const {
+ // Encode (imm, reg) as a spe4dis, which has the low 5-bits of (imm / 4)
+ // as the displacement and the next 5 bits as the register #.
+ assert(MI.getOperand(OpNo+1).isReg());
+ uint32_t RegBits = getMachineOpValue(MI, MI.getOperand(OpNo+1)) << 5;
+
+ const MachineOperand &MO = MI.getOperand(OpNo);
+ assert(MO.isImm());
+ uint32_t Imm = getMachineOpValue(MI, MO) >> 2;
+ return reverseBits(Imm | RegBits) >> 22;
+}
+
+
+unsigned PPCCodeEmitter::getSPE2DisEncoding(const MachineInstr &MI, unsigned OpNo) const {
+ // Encode (imm, reg) as a spe2dis, which has the low 5-bits of (imm / 2)
+ // as the displacement and the next 5 bits as the register #.
+ assert(MI.getOperand(OpNo+1).isReg());
+ uint32_t RegBits = getMachineOpValue(MI, MI.getOperand(OpNo+1)) << 5;
+
+ const MachineOperand &MO = MI.getOperand(OpNo);
+ assert(MO.isImm());
+ uint32_t Imm = getMachineOpValue(MI, MO) >> 1;
+ return reverseBits(Imm | RegBits) >> 22;
+}
unsigned PPCCodeEmitter::getTLSRegEncoding(const MachineInstr &MI,
unsigned OpNo) const {
Modified: llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.td
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.td?rev=215220&r1=215219&r2=215220&view=diff
==============================================================================
--- llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.td (original)
+++ llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.td Fri Aug 8 11:43:49 2014
@@ -566,6 +566,27 @@ def PPCDispRIXOperand : AsmOperandClass
def dispRIX : Operand<iPTR> {
let ParserMatchClass = PPCDispRIXOperand;
}
+def PPCDispSPE8Operand : AsmOperandClass {
+ let Name = "DispSPE8"; let PredicateMethod = "isU8ImmX8";
+ let RenderMethod = "addImmOperands";
+}
+def dispSPE8 : Operand<iPTR> {
+ let ParserMatchClass = PPCDispSPE8Operand;
+}
+def PPCDispSPE4Operand : AsmOperandClass {
+ let Name = "DispSPE4"; let PredicateMethod = "isU7ImmX4";
+ let RenderMethod = "addImmOperands";
+}
+def dispSPE4 : Operand<iPTR> {
+ let ParserMatchClass = PPCDispSPE4Operand;
+}
+def PPCDispSPE2Operand : AsmOperandClass {
+ let Name = "DispSPE2"; let PredicateMethod = "isU6ImmX2";
+ let RenderMethod = "addImmOperands";
+}
+def dispSPE2 : Operand<iPTR> {
+ let ParserMatchClass = PPCDispSPE2Operand;
+}
def memri : Operand<iPTR> {
let PrintMethod = "printMemRegImm";
@@ -583,6 +604,21 @@ def memrix : Operand<iPTR> { // memri
let EncoderMethod = "getMemRIXEncoding";
let DecoderMethod = "decodeMemRIXOperands";
}
+def spe8dis : Operand<iPTR> { // SPE displacement where the imm is 8-aligned.
+ let PrintMethod = "printMemRegImm";
+ let MIOperandInfo = (ops dispSPE8:$imm, ptr_rc_nor0:$reg);
+ let EncoderMethod = "getSPE8DisEncoding";
+}
+def spe4dis : Operand<iPTR> { // SPE displacement where the imm is 4-aligned.
+ let PrintMethod = "printMemRegImm";
+ let MIOperandInfo = (ops dispSPE4:$imm, ptr_rc_nor0:$reg);
+ let EncoderMethod = "getSPE4DisEncoding";
+}
+def spe2dis : Operand<iPTR> { // SPE displacement where the imm is 2-aligned.
+ let PrintMethod = "printMemRegImm";
+ let MIOperandInfo = (ops dispSPE2:$imm, ptr_rc_nor0:$reg);
+ let EncoderMethod = "getSPE2DisEncoding";
+}
// A single-register address. This is used with the SjLj
// pseudo-instructions.
Modified: llvm/trunk/lib/Target/PowerPC/PPCInstrSPE.td
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/PowerPC/PPCInstrSPE.td?rev=215220&r1=215219&r2=215220&view=diff
==============================================================================
--- llvm/trunk/lib/Target/PowerPC/PPCInstrSPE.td (original)
+++ llvm/trunk/lib/Target/PowerPC/PPCInstrSPE.td Fri Aug 8 11:43:49 2014
@@ -46,8 +46,68 @@ class EVXForm_3<bits<11> xo, dag OOL, da
let Inst{21-31} = xo;
}
+class EVXForm_D<bits<11> xo, dag OOL, dag IOL, string asmstr,
+ InstrItinClass itin> : I<4, OOL, IOL, asmstr, itin> {
+ bits<5> RT;
+ bits<21> D;
+
+ let Pattern = [];
+
+ let Inst{6-10} = RT;
+ let Inst{20} = D{0};
+ let Inst{19} = D{1};
+ let Inst{18} = D{2};
+ let Inst{17} = D{3};
+ let Inst{16} = D{4};
+ let Inst{15} = D{5};
+ let Inst{14} = D{6};
+ let Inst{13} = D{7};
+ let Inst{12} = D{8};
+ let Inst{11} = D{9};
+ let Inst{11-20} = D{0-9};
+ let Inst{21-31} = xo;
+}
+
let Predicates = [HasSPE], isAsmParserOnly = 1 in {
+def EVLDD : EVXForm_D<769, (outs gprc:$RT), (ins spe8dis:$dst),
+ "evldd $RT, $dst", IIC_VecFP>;
+def EVLDW : EVXForm_D<771, (outs gprc:$RT), (ins spe8dis:$dst),
+ "evldw $RT, $dst", IIC_VecFP>;
+def EVLDH : EVXForm_D<773, (outs gprc:$RT), (ins spe8dis:$dst),
+ "evldh $RT, $dst", IIC_VecFP>;
+def EVLHHESPLAT : EVXForm_D<777, (outs gprc:$RT), (ins spe2dis:$dst),
+ "evlhhesplat $RT, $dst", IIC_VecFP>;
+def EVLHHOUSPLAT : EVXForm_D<781, (outs gprc:$RT), (ins spe2dis:$dst),
+ "evlhhousplat $RT, $dst", IIC_VecFP>;
+def EVLHHOSSPLAT : EVXForm_D<783, (outs gprc:$RT), (ins spe2dis:$dst),
+ "evlhhossplat $RT, $dst", IIC_VecFP>;
+def EVLWHE : EVXForm_D<785, (outs gprc:$RT), (ins spe4dis:$dst),
+ "evlwhe $RT, $dst", IIC_VecFP>;
+def EVLWHOU : EVXForm_D<789, (outs gprc:$RT), (ins spe4dis:$dst),
+ "evlwhou $RT, $dst", IIC_VecFP>;
+def EVLWHOS : EVXForm_D<791, (outs gprc:$RT), (ins spe4dis:$dst),
+ "evlwhos $RT, $dst", IIC_VecFP>;
+def EVLWWSPLAT : EVXForm_D<793, (outs gprc:$RT), (ins spe4dis:$dst),
+ "evlwwsplat $RT, $dst", IIC_VecFP>;
+def EVLWHSPLAT : EVXForm_D<797, (outs gprc:$RT), (ins spe4dis:$dst),
+ "evlwhsplat $RT, $dst", IIC_VecFP>;
+
+def EVSTDD : EVXForm_D<801, (outs), (ins gprc:$RT, spe8dis:$dst),
+ "evstdd $RT, $dst", IIC_VecFP>;
+def EVSTDH : EVXForm_D<805, (outs), (ins gprc:$RT, spe8dis:$dst),
+ "evstdh $RT, $dst", IIC_VecFP>;
+def EVSTDW : EVXForm_D<803, (outs), (ins gprc:$RT, spe8dis:$dst),
+ "evstdw $RT, $dst", IIC_VecFP>;
+def EVSTWHE : EVXForm_D<817, (outs), (ins gprc:$RT, spe4dis:$dst),
+ "evstwhe $RT, $dst", IIC_VecFP>;
+def EVSTWHO : EVXForm_D<821, (outs), (ins gprc:$RT, spe4dis:$dst),
+ "evstwho $RT, $dst", IIC_VecFP>;
+def EVSTWWE : EVXForm_D<825, (outs), (ins gprc:$RT, spe4dis:$dst),
+ "evstwwe $RT, $dst", IIC_VecFP>;
+def EVSTWWO : EVXForm_D<829, (outs), (ins gprc:$RT, spe4dis:$dst),
+ "evstwwo $RT, $dst", IIC_VecFP>;
+
def EVMRA : EVXForm_1<1220, (outs gprc:$RT), (ins gprc:$RA),
"evmra $RT, $RA", IIC_VecFP> {
let RB = 0;
Modified: llvm/trunk/test/MC/PowerPC/ppc64-encoding-spe.s
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/MC/PowerPC/ppc64-encoding-spe.s?rev=215220&r1=215219&r2=215220&view=diff
==============================================================================
--- llvm/trunk/test/MC/PowerPC/ppc64-encoding-spe.s (original)
+++ llvm/trunk/test/MC/PowerPC/ppc64-encoding-spe.s Fri Aug 8 11:43:49 2014
@@ -463,3 +463,160 @@
# CHECK-BE: evxor 14, 22, 19 # encoding: [0x11,0xd6,0x9a,0x16]
# CHECK-LE: evxor 14, 22, 19 # encoding: [0x16,0x9a,0xd6,0x11]
evxor %r14, %r22, %r19
+
+# CHECK-BE: evldd 14, 0(27) # encoding: [0x11,0xdb,0x03,0x01]
+# CHECK-LE: evldd 14, 0(27) # encoding: [0x01,0x03,0xdb,0x11]
+ evldd %r14, 0(%r27)
+# CHECK-BE: evldd 14, 248(27) # encoding: [0x11,0xdb,0xfb,0x01]
+# CHECK-LE: evldd 14, 248(27) # encoding: [0x01,0xfb,0xdb,0x11]
+ evldd %r14, 248(%r27)
+# CHECK-BE: evldd 14, 248(9) # encoding: [0x11,0xc9,0xfb,0x01]
+# CHECK-LE: evldd 14, 248(9) # encoding: [0x01,0xfb,0xc9,0x11]
+ evldd %r14, 248(%r9)
+# CHECK-BE: evldw 14, 0(27) # encoding: [0x11,0xdb,0x03,0x03]
+# CHECK-LE: evldw 14, 0(27) # encoding: [0x03,0x03,0xdb,0x11]
+ evldw %r14, 0(%r27)
+# CHECK-BE: evldw 14, 248(27) # encoding: [0x11,0xdb,0xfb,0x03]
+# CHECK-LE: evldw 14, 248(27) # encoding: [0x03,0xfb,0xdb,0x11]
+ evldw %r14, 248(%r27)
+# CHECK-BE: evldw 14, 248(9) # encoding: [0x11,0xc9,0xfb,0x03]
+# CHECK-LE: evldw 14, 248(9) # encoding: [0x03,0xfb,0xc9,0x11]
+ evldw %r14, 248(%r9)
+# CHECK-BE: evldh 14, 0(27) # encoding: [0x11,0xdb,0x03,0x05]
+# CHECK-LE: evldh 14, 0(27) # encoding: [0x05,0x03,0xdb,0x11]
+ evldh %r14, 0(%r27)
+# CHECK-BE: evldh 14, 248(27) # encoding: [0x11,0xdb,0xfb,0x05]
+# CHECK-LE: evldh 14, 248(27) # encoding: [0x05,0xfb,0xdb,0x11]
+ evldh %r14, 248(%r27)
+# CHECK-BE: evldh 14, 248(9) # encoding: [0x11,0xc9,0xfb,0x05]
+# CHECK-LE: evldh 14, 248(9) # encoding: [0x05,0xfb,0xc9,0x11]
+ evldh %r14, 248(%r9)
+# CHECK-BE: evlhhesplat 14, 0(27) # encoding: [0x11,0xdb,0x03,0x09]
+# CHECK-LE: evlhhesplat 14, 0(27) # encoding: [0x09,0x03,0xdb,0x11]
+ evlhhesplat %r14, 0(%r27)
+# CHECK-BE: evlhhousplat 14, 0(27) # encoding: [0x11,0xdb,0x03,0x0d]
+# CHECK-LE: evlhhousplat 14, 0(27) # encoding: [0x0d,0x03,0xdb,0x11]
+ evlhhousplat %r14, 0(%r27)
+# CHECK-BE: evlhhousplat 14, 62(27) # encoding: [0x11,0xdb,0xfb,0x0d]
+# CHECK-LE: evlhhousplat 14, 62(27) # encoding: [0x0d,0xfb,0xdb,0x11]
+ evlhhousplat %r14, 62(%r27)
+# CHECK-BE: evlhhousplat 14, 62(9) # encoding: [0x11,0xc9,0xfb,0x0d]
+# CHECK-LE: evlhhousplat 14, 62(9) # encoding: [0x0d,0xfb,0xc9,0x11]
+ evlhhousplat %r14, 62(%r9)
+# CHECK-BE: evlhhossplat 14, 0(27) # encoding: [0x11,0xdb,0x03,0x0f]
+# CHECK-LE: evlhhossplat 14, 0(27) # encoding: [0x0f,0x03,0xdb,0x11]
+ evlhhossplat %r14, 0(%r27)
+# CHECK-BE: evlhhossplat 14, 62(27) # encoding: [0x11,0xdb,0xfb,0x0f]
+# CHECK-LE: evlhhossplat 14, 62(27) # encoding: [0x0f,0xfb,0xdb,0x11]
+ evlhhossplat %r14, 62(%r27)
+# CHECK-BE: evlhhossplat 14, 62(9) # encoding: [0x11,0xc9,0xfb,0x0f]
+# CHECK-LE: evlhhossplat 14, 62(9) # encoding: [0x0f,0xfb,0xc9,0x11]
+ evlhhossplat %r14, 62(%r9)
+# CHECK-BE: evlwhe 14, 0(27) # encoding: [0x11,0xdb,0x03,0x11]
+# CHECK-LE: evlwhe 14, 0(27) # encoding: [0x11,0x03,0xdb,0x11]
+ evlwhe %r14, 0(%r27)
+# CHECK-BE: evlwhe 14, 124(27) # encoding: [0x11,0xdb,0xfb,0x11]
+# CHECK-LE: evlwhe 14, 124(27) # encoding: [0x11,0xfb,0xdb,0x11]
+ evlwhe %r14, 124(%r27)
+# CHECK-BE: evlwhe 14, 124(9) # encoding: [0x11,0xc9,0xfb,0x11]
+# CHECK-LE: evlwhe 14, 124(9) # encoding: [0x11,0xfb,0xc9,0x11]
+ evlwhe %r14, 124(%r9)
+# CHECK-BE: evlwhou 14, 0(27) # encoding: [0x11,0xdb,0x03,0x15]
+# CHECK-LE: evlwhou 14, 0(27) # encoding: [0x15,0x03,0xdb,0x11]
+ evlwhou %r14, 0(%r27)
+# CHECK-BE: evlwhou 14, 124(27) # encoding: [0x11,0xdb,0xfb,0x15]
+# CHECK-LE: evlwhou 14, 124(27) # encoding: [0x15,0xfb,0xdb,0x11]
+ evlwhou %r14, 124(%r27)
+# CHECK-BE: evlwhou 14, 124(9) # encoding: [0x11,0xc9,0xfb,0x15]
+# CHECK-LE: evlwhou 14, 124(9) # encoding: [0x15,0xfb,0xc9,0x11]
+ evlwhou %r14, 124(%r9)
+# CHECK-BE: evlwhos 14, 0(27) # encoding: [0x11,0xdb,0x03,0x17]
+# CHECK-LE: evlwhos 14, 0(27) # encoding: [0x17,0x03,0xdb,0x11]
+ evlwhos %r14, 0(%r27)
+# CHECK-BE: evlwhos 14, 124(27) # encoding: [0x11,0xdb,0xfb,0x17]
+# CHECK-LE: evlwhos 14, 124(27) # encoding: [0x17,0xfb,0xdb,0x11]
+ evlwhos %r14, 124(%r27)
+# CHECK-BE: evlwhos 14, 124(9) # encoding: [0x11,0xc9,0xfb,0x17]
+# CHECK-LE: evlwhos 14, 124(9) # encoding: [0x17,0xfb,0xc9,0x11]
+ evlwhos %r14, 124(%r9)
+# CHECK-BE: evlwwsplat 14, 0(27) # encoding: [0x11,0xdb,0x03,0x19]
+# CHECK-LE: evlwwsplat 14, 0(27) # encoding: [0x19,0x03,0xdb,0x11]
+ evlwwsplat %r14, 0(%r27)
+# CHECK-BE: evlwwsplat 14, 124(27) # encoding: [0x11,0xdb,0xfb,0x19]
+# CHECK-LE: evlwwsplat 14, 124(27) # encoding: [0x19,0xfb,0xdb,0x11]
+ evlwwsplat %r14, 124(%r27)
+# CHECK-BE: evlwwsplat 14, 124(9) # encoding: [0x11,0xc9,0xfb,0x19]
+# CHECK-LE: evlwwsplat 14, 124(9) # encoding: [0x19,0xfb,0xc9,0x11]
+ evlwwsplat %r14, 124(%r9)
+# CHECK-BE: evlwhsplat 14, 0(27) # encoding: [0x11,0xdb,0x03,0x1d]
+# CHECK-LE: evlwhsplat 14, 0(27) # encoding: [0x1d,0x03,0xdb,0x11]
+ evlwhsplat %r14, 0(%r27)
+# CHECK-BE: evlwhsplat 14, 124(27) # encoding: [0x11,0xdb,0xfb,0x1d]
+# CHECK-LE: evlwhsplat 14, 124(27) # encoding: [0x1d,0xfb,0xdb,0x11]
+ evlwhsplat %r14, 124(%r27)
+# CHECK-BE: evlwhsplat 14, 124(9) # encoding: [0x11,0xc9,0xfb,0x1d]
+# CHECK-LE: evlwhsplat 14, 124(9) # encoding: [0x1d,0xfb,0xc9,0x11]
+ evlwhsplat %r14, 124(%r9)
+# CHECK-BE: evstdd 14, 0(27) # encoding: [0x11,0xdb,0x03,0x21]
+# CHECK-LE: evstdd 14, 0(27) # encoding: [0x21,0x03,0xdb,0x11]
+ evstdd %r14, 0(%r27)
+# CHECK-BE: evstdd 14, 248(27) # encoding: [0x11,0xdb,0xfb,0x21]
+# CHECK-LE: evstdd 14, 248(27) # encoding: [0x21,0xfb,0xdb,0x11]
+ evstdd %r14, 248(%r27)
+# CHECK-BE: evstdd 14, 248(9) # encoding: [0x11,0xc9,0xfb,0x21]
+# CHECK-LE: evstdd 14, 248(9) # encoding: [0x21,0xfb,0xc9,0x11]
+ evstdd %r14, 248(%r9)
+# CHECK-BE: evstdh 14, 0(27) # encoding: [0x11,0xdb,0x03,0x25]
+# CHECK-LE: evstdh 14, 0(27) # encoding: [0x25,0x03,0xdb,0x11]
+ evstdh %r14, 0(%r27)
+# CHECK-BE: evstdh 14, 248(27) # encoding: [0x11,0xdb,0xfb,0x25]
+# CHECK-LE: evstdh 14, 248(27) # encoding: [0x25,0xfb,0xdb,0x11]
+ evstdh %r14, 248(%r27)
+# CHECK-BE: evstdh 14, 248(9) # encoding: [0x11,0xc9,0xfb,0x25]
+# CHECK-LE: evstdh 14, 248(9) # encoding: [0x25,0xfb,0xc9,0x11]
+ evstdh %r14, 248(%r9)
+# CHECK-BE: evstdw 14, 0(27) # encoding: [0x11,0xdb,0x03,0x23]
+# CHECK-LE: evstdw 14, 0(27) # encoding: [0x23,0x03,0xdb,0x11]
+ evstdw %r14, 0(%r27)
+# CHECK-BE: evstdw 14, 248(27) # encoding: [0x11,0xdb,0xfb,0x23]
+# CHECK-LE: evstdw 14, 248(27) # encoding: [0x23,0xfb,0xdb,0x11]
+ evstdw %r14, 248(%r27)
+# CHECK-BE: evstdw 14, 248(9) # encoding: [0x11,0xc9,0xfb,0x23]
+# CHECK-LE: evstdw 14, 248(9) # encoding: [0x23,0xfb,0xc9,0x11]
+ evstdw %r14, 248(%r9)
+# CHECK-BE: evstwhe 14, 0(27) # encoding: [0x11,0xdb,0x03,0x31]
+# CHECK-LE: evstwhe 14, 0(27) # encoding: [0x31,0x03,0xdb,0x11]
+ evstwhe %r14, 0(%r27)
+# CHECK-BE: evstwhe 14, 124(27) # encoding: [0x11,0xdb,0xfb,0x31]
+# CHECK-LE: evstwhe 14, 124(27) # encoding: [0x31,0xfb,0xdb,0x11]
+ evstwhe %r14, 124(%r27)
+# CHECK-BE: evstwhe 14, 124(9) # encoding: [0x11,0xc9,0xfb,0x31]
+# CHECK-LE: evstwhe 14, 124(9) # encoding: [0x31,0xfb,0xc9,0x11]
+ evstwhe %r14, 124(%r9)
+# CHECK-BE: evstwho 14, 0(27) # encoding: [0x11,0xdb,0x03,0x35]
+# CHECK-LE: evstwho 14, 0(27) # encoding: [0x35,0x03,0xdb,0x11]
+ evstwho %r14, 0(%r27)
+# CHECK-BE: evstwho 14, 124(27) # encoding: [0x11,0xdb,0xfb,0x35]
+# CHECK-LE: evstwho 14, 124(27) # encoding: [0x35,0xfb,0xdb,0x11]
+ evstwho %r14, 124(%r27)
+# CHECK-BE: evstwho 14, 124(9) # encoding: [0x11,0xc9,0xfb,0x35]
+# CHECK-LE: evstwho 14, 124(9) # encoding: [0x35,0xfb,0xc9,0x11]
+ evstwho %r14, 124(%r9)
+# CHECK-BE: evstwwe 14, 0(27) # encoding: [0x11,0xdb,0x03,0x39]
+# CHECK-LE: evstwwe 14, 0(27) # encoding: [0x39,0x03,0xdb,0x11]
+ evstwwe %r14, 0(%r27)
+# CHECK-BE: evstwwe 14, 124(27) # encoding: [0x11,0xdb,0xfb,0x39]
+# CHECK-LE: evstwwe 14, 124(27) # encoding: [0x39,0xfb,0xdb,0x11]
+ evstwwe %r14, 124(%r27)
+# CHECK-BE: evstwwe 14, 124(9) # encoding: [0x11,0xc9,0xfb,0x39]
+# CHECK-LE: evstwwe 14, 124(9) # encoding: [0x39,0xfb,0xc9,0x11]
+ evstwwe %r14, 124(%r9)
+# CHECK-BE: evstwwo 14, 0(27) # encoding: [0x11,0xdb,0x03,0x3d]
+# CHECK-LE: evstwwo 14, 0(27) # encoding: [0x3d,0x03,0xdb,0x11]
+ evstwwo %r14, 0(%r27)
+# CHECK-BE: evstwwo 14, 124(27) # encoding: [0x11,0xdb,0xfb,0x3d]
+# CHECK-LE: evstwwo 14, 124(27) # encoding: [0x3d,0xfb,0xdb,0x11]
+ evstwwo %r14, 124(%r27)
+# CHECK-BE: evstwwo 14, 124(9) # encoding: [0x11,0xc9,0xfb,0x3d]
+# CHECK-LE: evstwwo 14, 124(9) # encoding: [0x3d,0xfb,0xc9,0x11]
+ evstwwo %r14, 124(%r9)
More information about the llvm-commits
mailing list