This is an archive of the discontinued LLVM Phabricator instance.

Differential D42824

[X86] Remove checks for FeatureAVX512 from the X86 assembly parser. Remove mcpu/mattr from assembly test command lines.
ClosedPublic

Authored by craig.topper on Feb 1 2018, 3:41 PM.

Details

Reviewers
RKSimon
echristo
bkramer
Commits
rGe538fc74d4c0: [X86] Remove checks for FeatureAVX512 from the X86 assembly parser. Remove…
rL324106: [X86] Remove checks for FeatureAVX512 from the X86 assembly parser. Remove…
Summary

We should always be able to accept AVX512 registers and instructions in llvm-mc. The only subtarget mode that should be checked is 16-bit vs 32-bit vs 64-bit mode.

I've also removed all the mattr/mcpu lines from test RUN lines to be consistent with this. Most were due to AVX512, but a few were for other features.

Fixes PR36202

Diff Detail

Repository
rL LLVM

Event Timeline

craig.topper created this revision.Feb 1 2018, 3:41 PM
craig.topper added inline comments.
test/MC/X86/intel-syntax-x86-avx512dq_vl.s
50 ↗(On Diff #132491)

This test had a runline embedded part way into the file. I assume copy paste mistake

test/MC/X86/x86-64-avx512cd.s
362 ↗(On Diff #132491)

Another stray RUN line.

craig.topper edited the summary of this revision. (Show Details)Feb 1 2018, 3:42 PM
echristo accepted this revision.Feb 1 2018, 3:47 PM
This revision is now accepted and ready to land.Feb 1 2018, 3:47 PM
Closed by commit rL324106: [X86] Remove checks for FeatureAVX512 from the X86 assembly parser. Remove… (authored by ctopper). · Explain WhyFeb 2 2018, 9:07 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 132612

llvm/trunk/lib/Target/X86/AsmParser/X86AsmParser.cpp

Show First 20 Lines • Show All 1,049 Lines • ▼ Show 20 Lines if (!is64BitMode()) {
// REX prefix. // REX prefix.
if (RegNo == X86::RIZ || if (RegNo == X86::RIZ ||
X86MCRegisterClasses[X86::GR64RegClassID].contains(RegNo) || X86MCRegisterClasses[X86::GR64RegClassID].contains(RegNo) ||
X86II::isX86_64NonExtLowByteReg(RegNo) || X86II::isX86_64NonExtLowByteReg(RegNo) ||
X86II::isX86_64ExtendedReg(RegNo)) X86II::isX86_64ExtendedReg(RegNo))
return Error(StartLoc, "register %" return Error(StartLoc, "register %"
+ Tok.getString() + " is only available in 64-bit mode", + Tok.getString() + " is only available in 64-bit mode",
SMRange(StartLoc, EndLoc)); SMRange(StartLoc, EndLoc));
} else if (!getSTI().getFeatureBits()[X86::FeatureAVX512]) {
if (X86II::is32ExtendedReg(RegNo))
return Error(StartLoc, "register %"
+ Tok.getString() + " is only available with AVX512",
SMRange(StartLoc, EndLoc));
} }
// Parse "%st" as "%st(0)" and "%st(1)", which is multiple tokens. // Parse "%st" as "%st(0)" and "%st(1)", which is multiple tokens.
if (RegNo == 0 && (Tok.getString() == "st" || Tok.getString() == "ST")) { if (RegNo == 0 && (Tok.getString() == "st" || Tok.getString() == "ST")) {
RegNo = X86::ST0; RegNo = X86::ST0;
Parser.Lex(); // Eat 'st' Parser.Lex(); // Eat 'st'
// Check to see if we have '(4)' after %st. // Check to see if we have '(4)' after %st.
▲ Show 20 Lines • Show All 717 Lines • ▼ Show 20 Linesstd::unique_ptr<X86Operand> X86AsmParser::ParseIntelOperand() {
unsigned Size; unsigned Size;
if (ParseIntelMemoryOperandSize(Size)) if (ParseIntelMemoryOperandSize(Size))
return nullptr; return nullptr;
bool PtrInOperand = bool(Size); bool PtrInOperand = bool(Size);
Start = Tok.getLoc(); Start = Tok.getLoc();
// Rounding mode operand. // Rounding mode operand.
if (getSTI().getFeatureBits()[X86::FeatureAVX512] && if (getLexer().is(AsmToken::LCurly))
getLexer().is(AsmToken::LCurly))
return ParseRoundingModeOp(Start); return ParseRoundingModeOp(Start);
// Register operand. // Register operand.
unsigned RegNo = 0; unsigned RegNo = 0;
if (Tok.is(AsmToken::Identifier) && !ParseRegister(RegNo, Start, End)) { if (Tok.is(AsmToken::Identifier) && !ParseRegister(RegNo, Start, End)) {
if (RegNo == X86::RIP) if (RegNo == X86::RIP)
return ErrorOperand(Start, "rip can only be used as a base register"); return ErrorOperand(Start, "rip can only be used as a base register");
// A Register followed by ':' is considered a segment override // A Register followed by ':' is considered a segment override
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines case AsmToken::Dollar: {
Parser.Lex(); Parser.Lex();
const MCExpr *Val; const MCExpr *Val;
if (getParser().parseExpression(Val, End)) if (getParser().parseExpression(Val, End))
return nullptr; return nullptr;
return X86Operand::CreateImm(Val, Start, End); return X86Operand::CreateImm(Val, Start, End);
} }
case AsmToken::LCurly:{ case AsmToken::LCurly:{
SMLoc Start = Parser.getTok().getLoc(); SMLoc Start = Parser.getTok().getLoc();
if (getSTI().getFeatureBits()[X86::FeatureAVX512])
return ParseRoundingModeOp(Start); return ParseRoundingModeOp(Start);
return ErrorOperand(Start, "Unexpected '{' in expression");
} }
} }
} }
// true on failure, false otherwise // true on failure, false otherwise
// If no {z} mark was found - Parser doesn't advance // If no {z} mark was found - Parser doesn't advance
bool X86AsmParser::ParseZ(std::unique_ptr<X86Operand> &Z, bool X86AsmParser::ParseZ(std::unique_ptr<X86Operand> &Z,
const SMLoc &StartLoc) { const SMLoc &StartLoc) {
Show All 13 Linesbool X86AsmParser::ParseZ(std::unique_ptr<X86Operand> &Z,
Z = X86Operand::CreateToken("{z}", StartLoc); Z = X86Operand::CreateToken("{z}", StartLoc);
return false; return false;
} }
// true on failure, false otherwise // true on failure, false otherwise
bool X86AsmParser::HandleAVX512Operand(OperandVector &Operands, bool X86AsmParser::HandleAVX512Operand(OperandVector &Operands,
const MCParsedAsmOperand &Op) { const MCParsedAsmOperand &Op) {
MCAsmParser &Parser = getParser(); MCAsmParser &Parser = getParser();
if(getSTI().getFeatureBits()[X86::FeatureAVX512]) {
if (getLexer().is(AsmToken::LCurly)) { if (getLexer().is(AsmToken::LCurly)) {
// Eat "{" and mark the current place. // Eat "{" and mark the current place.
const SMLoc consumedToken = consumeToken(); const SMLoc consumedToken = consumeToken();
// Distinguish {1to<NUM>} from {%k<NUM>}. // Distinguish {1to<NUM>} from {%k<NUM>}.
if(getLexer().is(AsmToken::Integer)) { if(getLexer().is(AsmToken::Integer)) {
// Parse memory broadcasting ({1to<NUM>}). // Parse memory broadcasting ({1to<NUM>}).
if (getLexer().getTok().getIntVal() != 1) if (getLexer().getTok().getIntVal() != 1)
return TokError("Expected 1to<NUM> at this point"); return TokError("Expected 1to<NUM> at this point");
Parser.Lex(); // Eat "1" of 1to8 Parser.Lex(); // Eat "1" of 1to8
if (!getLexer().is(AsmToken::Identifier) || if (!getLexer().is(AsmToken::Identifier) ||
!getLexer().getTok().getIdentifier().startswith("to")) !getLexer().getTok().getIdentifier().startswith("to"))
return TokError("Expected 1to<NUM> at this point"); return TokError("Expected 1to<NUM> at this point");
// Recognize only reasonable suffixes. // Recognize only reasonable suffixes.
const char *BroadcastPrimitive = const char *BroadcastPrimitive =
StringSwitch<const char*>(getLexer().getTok().getIdentifier()) StringSwitch<const char*>(getLexer().getTok().getIdentifier())
.Case("to2", "{1to2}") .Case("to2", "{1to2}")
.Case("to4", "{1to4}") .Case("to4", "{1to4}")
.Case("to8", "{1to8}") .Case("to8", "{1to8}")
.Case("to16", "{1to16}") .Case("to16", "{1to16}")
.Default(nullptr); .Default(nullptr);
if (!BroadcastPrimitive) if (!BroadcastPrimitive)
return TokError("Invalid memory broadcast primitive."); return TokError("Invalid memory broadcast primitive.");
Parser.Lex(); // Eat "toN" of 1toN Parser.Lex(); // Eat "toN" of 1toN
if (!getLexer().is(AsmToken::RCurly)) if (!getLexer().is(AsmToken::RCurly))
return TokError("Expected } at this point"); return TokError("Expected } at this point");
Parser.Lex(); // Eat "}" Parser.Lex(); // Eat "}"
Operands.push_back(X86Operand::CreateToken(BroadcastPrimitive, Operands.push_back(X86Operand::CreateToken(BroadcastPrimitive,
consumedToken)); consumedToken));
// No AVX512 specific primitives can pass // No AVX512 specific primitives can pass
// after memory broadcasting, so return. // after memory broadcasting, so return.
return false; return false;
} else { } else {
// Parse either {k}{z}, {z}{k}, {k} or {z} // Parse either {k}{z}, {z}{k}, {k} or {z}
// last one have no meaning, but GCC accepts it // last one have no meaning, but GCC accepts it
// Currently, we're just pass a '{' mark // Currently, we're just pass a '{' mark
std::unique_ptr<X86Operand> Z; std::unique_ptr<X86Operand> Z;
if (ParseZ(Z, consumedToken)) if (ParseZ(Z, consumedToken))
return true; return true;
// Reaching here means that parsing of the allegadly '{z}' mark yielded // Reaching here means that parsing of the allegadly '{z}' mark yielded
// no errors. // no errors.
// Query for the need of further parsing for a {%k<NUM>} mark // Query for the need of further parsing for a {%k<NUM>} mark
if (!Z || getLexer().is(AsmToken::LCurly)) { if (!Z || getLexer().is(AsmToken::LCurly)) {
SMLoc StartLoc = Z ? consumeToken() : consumedToken; SMLoc StartLoc = Z ? consumeToken() : consumedToken;
// Parse an op-mask register mark ({%k<NUM>}), which is now to be // Parse an op-mask register mark ({%k<NUM>}), which is now to be
// expected // expected
unsigned RegNo; unsigned RegNo;
SMLoc RegLoc; SMLoc RegLoc;
if (!ParseRegister(RegNo, RegLoc, StartLoc) && if (!ParseRegister(RegNo, RegLoc, StartLoc) &&
X86MCRegisterClasses[X86::VK1RegClassID].contains(RegNo)) { X86MCRegisterClasses[X86::VK1RegClassID].contains(RegNo)) {
if (RegNo == X86::K0) if (RegNo == X86::K0)
return Error(RegLoc, "Register k0 can't be used as write mask"); return Error(RegLoc, "Register k0 can't be used as write mask");
if (!getLexer().is(AsmToken::RCurly)) if (!getLexer().is(AsmToken::RCurly))
return Error(getLexer().getLoc(), "Expected } at this point"); return Error(getLexer().getLoc(), "Expected } at this point");
Operands.push_back(X86Operand::CreateToken("{", StartLoc)); Operands.push_back(X86Operand::CreateToken("{", StartLoc));
Operands.push_back( Operands.push_back(
X86Operand::CreateReg(RegNo, StartLoc, StartLoc)); X86Operand::CreateReg(RegNo, StartLoc, StartLoc));
Operands.push_back(X86Operand::CreateToken("}", consumeToken())); Operands.push_back(X86Operand::CreateToken("}", consumeToken()));
} else } else
return Error(getLexer().getLoc(), return Error(getLexer().getLoc(),
"Expected an op-mask register at this point"); "Expected an op-mask register at this point");
// {%k<NUM>} mark is found, inquire for {z} // {%k<NUM>} mark is found, inquire for {z}
if (getLexer().is(AsmToken::LCurly) && !Z) { if (getLexer().is(AsmToken::LCurly) && !Z) {
// Have we've found a parsing error, or found no (expected) {z} mark // Have we've found a parsing error, or found no (expected) {z} mark
// - report an error // - report an error
if (ParseZ(Z, consumeToken()) || !Z) if (ParseZ(Z, consumeToken()) || !Z)
return Error(getLexer().getLoc(), return Error(getLexer().getLoc(),
"Expected a {z} mark at this point"); "Expected a {z} mark at this point");
} }
// '{z}' on its own is meaningless, hence should be ignored. // '{z}' on its own is meaningless, hence should be ignored.
// on the contrary - have it been accompanied by a K register, // on the contrary - have it been accompanied by a K register,
// allow it. // allow it.
if (Z) if (Z)
Operands.push_back(std::move(Z)); Operands.push_back(std::move(Z));
} }
} }
} }
}
return false; return false;
} }
/// ParseMemOperand: segment: disp(basereg, indexreg, scale). The '%ds:' prefix /// ParseMemOperand: segment: disp(basereg, indexreg, scale). The '%ds:' prefix
/// has already been parsed if present. /// has already been parsed if present.
std::unique_ptr<X86Operand> X86AsmParser::ParseMemOperand(unsigned SegReg, std::unique_ptr<X86Operand> X86AsmParser::ParseMemOperand(unsigned SegReg,
SMLoc MemStart) { SMLoc MemStart) {
▲ Show 20 Lines • Show All 1,353 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/AVX512F_512-32.s

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
// RUN: llvm-mc -triple i386-unknown-unknown -mcpu=skx --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vaddpd 4096(%edx,%eax), %zmm2, %zmm2 // CHECK: vaddpd 4096(%edx,%eax), %zmm2, %zmm2
// CHECK: encoding: [0x62,0xf1,0xed,0x48,0x58,0x54,0x02,0x40] // CHECK: encoding: [0x62,0xf1,0xed,0x48,0x58,0x54,0x02,0x40]
vaddpd 4096(%edx,%eax), %zmm2, %zmm2 vaddpd 4096(%edx,%eax), %zmm2, %zmm2
// CHECK: vaddpd 4096(%edx,%eax), %zmm2, %zmm2 {%k2} // CHECK: vaddpd 4096(%edx,%eax), %zmm2, %zmm2 {%k2}
// CHECK: encoding: [0x62,0xf1,0xed,0x4a,0x58,0x54,0x02,0x40] // CHECK: encoding: [0x62,0xf1,0xed,0x4a,0x58,0x54,0x02,0x40]
vaddpd 4096(%edx,%eax), %zmm2, %zmm2 {%k2} vaddpd 4096(%edx,%eax), %zmm2, %zmm2 {%k2}
▲ Show 20 Lines • Show All 34,741 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/AVX512F_512-64.s

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=skx --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vaddpd 4096(%rdx,%rax,4), %zmm19, %zmm19 // CHECK: vaddpd 4096(%rdx,%rax,4), %zmm19, %zmm19
// CHECK: encoding: [0x62,0xe1,0xe5,0x40,0x58,0x5c,0x82,0x40] // CHECK: encoding: [0x62,0xe1,0xe5,0x40,0x58,0x5c,0x82,0x40]
vaddpd 4096(%rdx,%rax,4), %zmm19, %zmm19 vaddpd 4096(%rdx,%rax,4), %zmm19, %zmm19
// CHECK: vaddpd -4096(%rdx,%rax,4), %zmm19, %zmm19 // CHECK: vaddpd -4096(%rdx,%rax,4), %zmm19, %zmm19
// CHECK: encoding: [0x62,0xe1,0xe5,0x40,0x58,0x5c,0x82,0xc0] // CHECK: encoding: [0x62,0xe1,0xe5,0x40,0x58,0x5c,0x82,0xc0]
vaddpd -4096(%rdx,%rax,4), %zmm19, %zmm19 vaddpd -4096(%rdx,%rax,4), %zmm19, %zmm19
▲ Show 20 Lines • Show All 35,705 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/X86_64-pku.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mattr=+pku --show-encoding < %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: rdpkru // CHECK: rdpkru
// CHECK: encoding: [0x0f,0x01,0xee] // CHECK: encoding: [0x0f,0x01,0xee]
rdpkru rdpkru
// CHECK: wrpkru // CHECK: wrpkru
// CHECK: encoding: [0x0f,0x01,0xef] // CHECK: encoding: [0x0f,0x01,0xef]
wrpkru wrpkru
No newline at end of file

llvm/trunk/test/MC/X86/avx512-encodings.s

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl --show-encoding < %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: vaddpd %zmm6, %zmm27, %zmm8 // CHECK: vaddpd %zmm6, %zmm27, %zmm8
// CHECK: encoding: [0x62,0x71,0xa5,0x40,0x58,0xc6] // CHECK: encoding: [0x62,0x71,0xa5,0x40,0x58,0xc6]
vaddpd %zmm6, %zmm27, %zmm8 vaddpd %zmm6, %zmm27, %zmm8
// CHECK: vaddpd %zmm6, %zmm27, %zmm8 {%k7} // CHECK: vaddpd %zmm6, %zmm27, %zmm8 {%k7}
// CHECK: encoding: [0x62,0x71,0xa5,0x47,0x58,0xc6] // CHECK: encoding: [0x62,0x71,0xa5,0x47,0x58,0xc6]
vaddpd %zmm6, %zmm27, %zmm8 {%k7} vaddpd %zmm6, %zmm27, %zmm8 {%k7}
▲ Show 20 Lines • Show All 19,742 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512-err.s

// RUN: not llvm-mc %s -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512dq -mattr=+avx512f --show-encoding -o /dev/null 2>&1 | FileCheck --check-prefix=ERR %s // RUN: not llvm-mc %s -triple x86_64-unknown-unknown --show-encoding -o /dev/null 2>&1 | FileCheck --check-prefix=ERR %s
// ERR: Register k0 can't be used as write mask // ERR: Register k0 can't be used as write mask
vpcmpd $1, %zmm24, %zmm7, %k5{%k0} vpcmpd $1, %zmm24, %zmm7, %k5{%k0}
// ERR: Expected a {z} mark at this point // ERR: Expected a {z} mark at this point
vfmsub213ps %zmm8, %zmm8, %zmm8{%k2} {rn-sae} vfmsub213ps %zmm8, %zmm8, %zmm8{%k2} {rn-sae}
// ERR: Expected an op-mask register at this point // ERR: Expected an op-mask register at this point
vfmsub213ps %zmm8, %zmm8, %zmm8 {rn-sae} vfmsub213ps %zmm8, %zmm8, %zmm8 {rn-sae}
// ERR: invalid operand for instruction // ERR: invalid operand for instruction
cvtsd2sil {rn-sae}, %xmm1, %eax cvtsd2sil {rn-sae}, %xmm1, %eax

llvm/trunk/test/MC/X86/avx512bitalg-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512bitalg --show-encoding < %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: vpopcntb %zmm23, %zmm21 // CHECK: vpopcntb %zmm23, %zmm21
// CHECK: encoding: [0x62,0xa2,0x7d,0x48,0x54,0xef] // CHECK: encoding: [0x62,0xa2,0x7d,0x48,0x54,0xef]
vpopcntb %zmm23, %zmm21 vpopcntb %zmm23, %zmm21
// CHECK: vpopcntw %zmm23, %zmm21 // CHECK: vpopcntw %zmm23, %zmm21
// CHECK: encoding: [0x62,0xa2,0xfd,0x48,0x54,0xef] // CHECK: encoding: [0x62,0xa2,0xfd,0x48,0x54,0xef]
vpopcntw %zmm23, %zmm21 vpopcntw %zmm23, %zmm21
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512bw-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=skx --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vpblendmb %zmm25, %zmm18, %zmm17 // CHECK: vpblendmb %zmm25, %zmm18, %zmm17
// CHECK: encoding: [0x62,0x82,0x6d,0x40,0x66,0xc9] // CHECK: encoding: [0x62,0x82,0x6d,0x40,0x66,0xc9]
vpblendmb %zmm25, %zmm18, %zmm17 vpblendmb %zmm25, %zmm18, %zmm17
// CHECK: vpblendmb %zmm25, %zmm18, %zmm17 {%k5} // CHECK: vpblendmb %zmm25, %zmm18, %zmm17 {%k5}
// CHECK: encoding: [0x62,0x82,0x6d,0x45,0x66,0xc9] // CHECK: encoding: [0x62,0x82,0x6d,0x45,0x66,0xc9]
vpblendmb %zmm25, %zmm18, %zmm17 {%k5} vpblendmb %zmm25, %zmm18, %zmm17 {%k5}
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512gfni-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mattr=+gfni,+avx512f,+avx512bw --show-encoding < %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: vgf2p8affineinvqb $7, %zmm2, %zmm20, %zmm1 // CHECK: vgf2p8affineinvqb $7, %zmm2, %zmm20, %zmm1
// CHECK: encoding: [0x62,0xf3,0xdd,0x40,0xcf,0xca,0x07] // CHECK: encoding: [0x62,0xf3,0xdd,0x40,0xcf,0xca,0x07]
vgf2p8affineinvqb $7, %zmm2, %zmm20, %zmm1 vgf2p8affineinvqb $7, %zmm2, %zmm20, %zmm1
// CHECK: vgf2p8affineqb $7, %zmm2, %zmm20, %zmm1 // CHECK: vgf2p8affineqb $7, %zmm2, %zmm20, %zmm1
// CHECK: encoding: [0x62,0xf3,0xdd,0x40,0xce,0xca,0x07] // CHECK: encoding: [0x62,0xf3,0xdd,0x40,0xce,0xca,0x07]
vgf2p8affineqb $7, %zmm2, %zmm20, %zmm1 vgf2p8affineqb $7, %zmm2, %zmm20, %zmm1
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512ifma-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512ifma --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
vpmadd52luq %zmm4, %zmm5, %zmm6 vpmadd52luq %zmm4, %zmm5, %zmm6
//CHECK: vpmadd52luq %zmm4, %zmm5, %zmm6 //CHECK: vpmadd52luq %zmm4, %zmm5, %zmm6
//CHECK: encoding: [0x62,0xf2,0xd5,0x48,0xb4,0xf4] //CHECK: encoding: [0x62,0xf2,0xd5,0x48,0xb4,0xf4]
vpmadd52luq %zmm4, %zmm5, %zmm6 {%k7} vpmadd52luq %zmm4, %zmm5, %zmm6 {%k7}
//CHECK: vpmadd52luq %zmm4, %zmm5, %zmm6 {%k7} //CHECK: vpmadd52luq %zmm4, %zmm5, %zmm6 {%k7}
//CHECK: encoding: [0x62,0xf2,0xd5,0x4f,0xb4,0xf4] //CHECK: encoding: [0x62,0xf2,0xd5,0x4f,0xb4,0xf4]
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512ifmavl-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512ifma -mattr=+avx512vl --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
vpmadd52luq %xmm4, %xmm5, %xmm6 {%k7} vpmadd52luq %xmm4, %xmm5, %xmm6 {%k7}
//CHECK: vpmadd52luq %xmm4, %xmm5, %xmm6 {%k7} //CHECK: vpmadd52luq %xmm4, %xmm5, %xmm6 {%k7}
//CHECK: encoding: [0x62,0xf2,0xd5,0x0f,0xb4,0xf4] //CHECK: encoding: [0x62,0xf2,0xd5,0x0f,0xb4,0xf4]
vpmadd52luq %xmm4, %xmm5, %xmm6 {%k7} {z} vpmadd52luq %xmm4, %xmm5, %xmm6 {%k7} {z}
//CHECK: vpmadd52luq %xmm4, %xmm5, %xmm6 {%k7} {z} //CHECK: vpmadd52luq %xmm4, %xmm5, %xmm6 {%k7} {z}
//CHECK: encoding: [0x62,0xf2,0xd5,0x8f,0xb4,0xf4] //CHECK: encoding: [0x62,0xf2,0xd5,0x8f,0xb4,0xf4]
▲ Show 20 Lines • Show All 265 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512vaes-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+vaes --show-encoding < %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: vaesenc %zmm3, %zmm2, %zmm21 // CHECK: vaesenc %zmm3, %zmm2, %zmm21
// CHECK: encoding: [0x62,0xe2,0x6d,0x48,0xdc,0xeb] // CHECK: encoding: [0x62,0xe2,0x6d,0x48,0xdc,0xeb]
vaesenc %zmm3, %zmm2, %zmm21 vaesenc %zmm3, %zmm2, %zmm21
// CHECK: vaesenclast %zmm3, %zmm2, %zmm21 // CHECK: vaesenclast %zmm3, %zmm2, %zmm21
// CHECK: encoding: [0x62,0xe2,0x6d,0x48,0xdd,0xeb] // CHECK: encoding: [0x62,0xe2,0x6d,0x48,0xdd,0xeb]
vaesenclast %zmm3, %zmm2, %zmm21 vaesenclast %zmm3, %zmm2, %zmm21
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512vbmi-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=skx -mattr=+avx512vl -mattr=+avx512vbmi --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
vpermb %xmm28, %xmm29, %xmm30 {%k7} vpermb %xmm28, %xmm29, %xmm30 {%k7}
//CHECK: vpermb %xmm28, %xmm29, %xmm30 {%k7} //CHECK: vpermb %xmm28, %xmm29, %xmm30 {%k7}
//CHECK: encoding: [0x62,0x02,0x15,0x07,0x8d,0xf4] //CHECK: encoding: [0x62,0x02,0x15,0x07,0x8d,0xf4]
vpermb %xmm28, %xmm29, %xmm30 {%k7} {z} vpermb %xmm28, %xmm29, %xmm30 {%k7} {z}
//CHECK: vpermb %xmm28, %xmm29, %xmm30 {%k7} {z} //CHECK: vpermb %xmm28, %xmm29, %xmm30 {%k7} {z}
//CHECK: encoding: [0x62,0x02,0x15,0x87,0x8d,0xf4] //CHECK: encoding: [0x62,0x02,0x15,0x87,0x8d,0xf4]
▲ Show 20 Lines • Show All 534 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512vbmi2-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512vbmi2 --show-encoding < %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: vpexpandb %zmm3, %zmm1 // CHECK: vpexpandb %zmm3, %zmm1
// CHECK: encoding: [0x62,0xf2,0x7d,0x48,0x62,0xcb] // CHECK: encoding: [0x62,0xf2,0x7d,0x48,0x62,0xcb]
vpexpandb %zmm3, %zmm1 vpexpandb %zmm3, %zmm1
// CHECK: vpexpandw %zmm3, %zmm1 // CHECK: vpexpandw %zmm3, %zmm1
// CHECK: encoding: [0x62,0xf2,0xfd,0x48,0x62,0xcb] // CHECK: encoding: [0x62,0xf2,0xfd,0x48,0x62,0xcb]
vpexpandw %zmm3, %zmm1 vpexpandw %zmm3, %zmm1
▲ Show 20 Lines • Show All 1,784 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512vbmi2vl-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512vbmi2 -mattr=+avx512vl --show-encoding < %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: vpexpandb %xmm3, %xmm1 // CHECK: vpexpandb %xmm3, %xmm1
// CHECK: encoding: [0x62,0xf2,0x7d,0x08,0x62,0xcb] // CHECK: encoding: [0x62,0xf2,0x7d,0x08,0x62,0xcb]
vpexpandb %xmm3, %xmm1 vpexpandb %xmm3, %xmm1
// CHECK: vpexpandw %xmm3, %xmm1 // CHECK: vpexpandw %xmm3, %xmm1
// CHECK: encoding: [0x62,0xf2,0xfd,0x08,0x62,0xcb] // CHECK: encoding: [0x62,0xf2,0xfd,0x08,0x62,0xcb]
vpexpandw %xmm3, %xmm1 vpexpandw %xmm3, %xmm1
▲ Show 20 Lines • Show All 3,576 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512vl-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=skx --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vblendmpd %xmm19, %xmm20, %xmm27 // CHECK: vblendmpd %xmm19, %xmm20, %xmm27
// CHECK: encoding: [0x62,0x22,0xdd,0x00,0x65,0xdb] // CHECK: encoding: [0x62,0x22,0xdd,0x00,0x65,0xdb]
vblendmpd %xmm19, %xmm20, %xmm27 vblendmpd %xmm19, %xmm20, %xmm27
// CHECK: vblendmpd %xmm19, %xmm20, %xmm27 {%k7} // CHECK: vblendmpd %xmm19, %xmm20, %xmm27 {%k7}
// CHECK: encoding: [0x62,0x22,0xdd,0x07,0x65,0xdb] // CHECK: encoding: [0x62,0x22,0xdd,0x07,0x65,0xdb]
vblendmpd %xmm19, %xmm20, %xmm27 {%k7} vblendmpd %xmm19, %xmm20, %xmm27 {%k7}
▲ Show 20 Lines • Show All 2,101 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512vl_bitalg-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512vl,+avx512bitalg --show-encoding < %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: vpopcntb %xmm23, %xmm21 // CHECK: vpopcntb %xmm23, %xmm21
// CHECK: encoding: [0x62,0xa2,0x7d,0x08,0x54,0xef] // CHECK: encoding: [0x62,0xa2,0x7d,0x08,0x54,0xef]
vpopcntb %xmm23, %xmm21 vpopcntb %xmm23, %xmm21
// CHECK: vpopcntw %xmm23, %xmm21 // CHECK: vpopcntw %xmm23, %xmm21
// CHECK: encoding: [0x62,0xa2,0xfd,0x08,0x54,0xef] // CHECK: encoding: [0x62,0xa2,0xfd,0x08,0x54,0xef]
vpopcntw %xmm23, %xmm21 vpopcntw %xmm23, %xmm21
▲ Show 20 Lines • Show All 329 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512vl_gfni-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mattr=+gfni,+avx512vl,+avx512bw --show-encoding < %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: vgf2p8affineinvqb $7, %xmm2, %xmm20, %xmm1 // CHECK: vgf2p8affineinvqb $7, %xmm2, %xmm20, %xmm1
// CHECK: encoding: [0x62,0xf3,0xdd,0x00,0xcf,0xca,0x07] // CHECK: encoding: [0x62,0xf3,0xdd,0x00,0xcf,0xca,0x07]
vgf2p8affineinvqb $7, %xmm2, %xmm20, %xmm1 vgf2p8affineinvqb $7, %xmm2, %xmm20, %xmm1
// CHECK: vgf2p8affineqb $7, %xmm2, %xmm20, %xmm1 // CHECK: vgf2p8affineqb $7, %xmm2, %xmm20, %xmm1
// CHECK: encoding: [0x62,0xf3,0xdd,0x00,0xce,0xca,0x07] // CHECK: encoding: [0x62,0xf3,0xdd,0x00,0xce,0xca,0x07]
vgf2p8affineqb $7, %xmm2, %xmm20, %xmm1 vgf2p8affineqb $7, %xmm2, %xmm20, %xmm1
▲ Show 20 Lines • Show All 345 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512vl_vaes-encoding.s

//RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=skx -mattr=+vaes --show-encoding < %s | FileCheck %s //RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: vaesenc %xmm3, %xmm2, %xmm21 // CHECK: vaesenc %xmm3, %xmm2, %xmm21
// CHECK: encoding: [0x62,0xe2,0x6d,0x08,0xdc,0xeb] // CHECK: encoding: [0x62,0xe2,0x6d,0x08,0xdc,0xeb]
vaesenc %xmm3, %xmm2, %xmm21 vaesenc %xmm3, %xmm2, %xmm21
// CHECK: vaesenclast %xmm3, %xmm2, %xmm21 // CHECK: vaesenclast %xmm3, %xmm2, %xmm21
// CHECK: encoding: [0x62,0xe2,0x6d,0x08,0xdd,0xeb] // CHECK: encoding: [0x62,0xe2,0x6d,0x08,0xdd,0xeb]
vaesenclast %xmm3, %xmm2, %xmm21 vaesenclast %xmm3, %xmm2, %xmm21
▲ Show 20 Lines • Show All 217 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512vl_vnni-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512vnni,+avx512vl --show-encoding < %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: vpdpbusd %xmm3, %xmm2, %xmm1 // CHECK: vpdpbusd %xmm3, %xmm2, %xmm1
// CHECK: encoding: [0x62,0xf2,0x6d,0x08,0x50,0xcb] // CHECK: encoding: [0x62,0xf2,0x6d,0x08,0x50,0xcb]
vpdpbusd %xmm3, %xmm2, %xmm1 vpdpbusd %xmm3, %xmm2, %xmm1
// CHECK: vpdpbusds %xmm3, %xmm2, %xmm1 // CHECK: vpdpbusds %xmm3, %xmm2, %xmm1
// CHECK: encoding: [0x62,0xf2,0x6d,0x08,0x51,0xcb] // CHECK: encoding: [0x62,0xf2,0x6d,0x08,0x51,0xcb]
vpdpbusds %xmm3, %xmm2, %xmm1 vpdpbusds %xmm3, %xmm2, %xmm1
▲ Show 20 Lines • Show All 889 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512vlvpclmul.s

//RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=skx -mattr=+vpclmulqdq --show-encoding < %s | FileCheck %s //RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: vpclmulqdq $1, %xmm3, %xmm22, %xmm1 // CHECK: vpclmulqdq $1, %xmm3, %xmm22, %xmm1
// CHECK: encoding: [0x62,0xf3,0x4d,0x00,0x44,0xcb,0x01] // CHECK: encoding: [0x62,0xf3,0x4d,0x00,0x44,0xcb,0x01]
vpclmulqdq $1, %xmm3, %xmm22, %xmm1 vpclmulqdq $1, %xmm3, %xmm22, %xmm1
// CHECK: vpclmulqdq $1, (%rcx), %xmm22, %xmm1 // CHECK: vpclmulqdq $1, (%rcx), %xmm22, %xmm1
// CHECK: encoding: [0x62,0xf3,0x4d,0x00,0x44,0x09,0x01] // CHECK: encoding: [0x62,0xf3,0x4d,0x00,0x44,0x09,0x01]
vpclmulqdq $1, (%rcx), %xmm22, %xmm1 vpclmulqdq $1, (%rcx), %xmm22, %xmm1
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512vnni-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512vnni --show-encoding < %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: vpdpbusd %zmm3, %zmm2, %zmm1 // CHECK: vpdpbusd %zmm3, %zmm2, %zmm1
// CHECK: encoding: [0x62,0xf2,0x6d,0x48,0x50,0xcb] // CHECK: encoding: [0x62,0xf2,0x6d,0x48,0x50,0xcb]
vpdpbusd %zmm3, %zmm2, %zmm1 vpdpbusd %zmm3, %zmm2, %zmm1
// CHECK: vpdpbusds %zmm3, %zmm2, %zmm1 // CHECK: vpdpbusds %zmm3, %zmm2, %zmm1
// CHECK: encoding: [0x62,0xf2,0x6d,0x48,0x51,0xcb] // CHECK: encoding: [0x62,0xf2,0x6d,0x48,0x51,0xcb]
vpdpbusds %zmm3, %zmm2, %zmm1 vpdpbusds %zmm3, %zmm2, %zmm1
▲ Show 20 Lines • Show All 441 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/avx512vpclmul.s

//RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+vpclmulqdq --show-encoding < %s | FileCheck %s //RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: vpclmulqdq $1, %zmm3, %zmm22, %zmm1 // CHECK: vpclmulqdq $1, %zmm3, %zmm22, %zmm1
// CHECK: encoding: [0x62,0xf3,0x4d,0x40,0x44,0xcb,0x01] // CHECK: encoding: [0x62,0xf3,0x4d,0x40,0x44,0xcb,0x01]
vpclmulqdq $1, %zmm3, %zmm22, %zmm1 vpclmulqdq $1, %zmm3, %zmm22, %zmm1
// CHECK: vpclmulqdq $1, (%rcx), %zmm22, %zmm1 // CHECK: vpclmulqdq $1, (%rcx), %zmm22, %zmm1
// CHECK: encoding: [0x62,0xf3,0x4d,0x40,0x44,0x09,0x01] // CHECK: encoding: [0x62,0xf3,0x4d,0x40,0x44,0x09,0x01]
vpclmulqdq $1, (%rcx), %zmm22, %zmm1 vpclmulqdq $1, (%rcx), %zmm22, %zmm1
Show All 20 Lines

llvm/trunk/test/MC/X86/avx_vaes-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mattr=vaes --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vaesenc %ymm3, %ymm2, %ymm1 // CHECK: vaesenc %ymm3, %ymm2, %ymm1
// CHECK: encoding: [0xc4,0xe2,0x6d,0xdc,0xcb] // CHECK: encoding: [0xc4,0xe2,0x6d,0xdc,0xcb]
vaesenc %ymm3, %ymm2, %ymm1 vaesenc %ymm3, %ymm2, %ymm1
// CHECK: vaesenclast %ymm3, %ymm2, %ymm1 // CHECK: vaesenclast %ymm3, %ymm2, %ymm1
// CHECK: encoding: [0xc4,0xe2,0x6d,0xdd,0xcb] // CHECK: encoding: [0xc4,0xe2,0x6d,0xdd,0xcb]
vaesenclast %ymm3, %ymm2, %ymm1 vaesenclast %ymm3, %ymm2, %ymm1
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/cet-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mattr=+shstk -mattr=+ibt --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: incsspd %r13d // CHECK: incsspd %r13d
// CHECK: # encoding: [0xf3,0x41,0x0f,0xae,0xed] // CHECK: # encoding: [0xf3,0x41,0x0f,0xae,0xed]
incsspd %r13d incsspd %r13d
// CHECK: incsspq %r15 // CHECK: incsspq %r15
// CHECK: # encoding: [0xf3,0x49,0x0f,0xae,0xef] // CHECK: # encoding: [0xf3,0x49,0x0f,0xae,0xef]
incsspq %r15 incsspq %r15
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/gather.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mattr=avx512f -show-encoding %s > %t 2> %t.err // RUN: llvm-mc -triple x86_64-unknown-unknown -show-encoding %s > %t 2> %t.err
// RUN: FileCheck < %t %s // RUN: FileCheck < %t %s
// RUN: FileCheck --check-prefix=CHECK-STDERR < %t.err %s // RUN: FileCheck --check-prefix=CHECK-STDERR < %t.err %s
// CHECK: vgatherdps %xmm2, (%rdi,%xmm2,2), %xmm2 // CHECK: vgatherdps %xmm2, (%rdi,%xmm2,2), %xmm2
// CHECK-STDERR: warning: mask, index, and destination registers should be distinct // CHECK-STDERR: warning: mask, index, and destination registers should be distinct
vgatherdps %xmm2, (%rdi,%xmm2,2), %xmm2 vgatherdps %xmm2, (%rdi,%xmm2,2), %xmm2
// CHECK: vpgatherdd (%r14,%zmm11,8), %zmm11 {%k1} // CHECK: vpgatherdd (%r14,%zmm11,8), %zmm11 {%k1}
Show All 10 Lines

llvm/trunk/test/MC/X86/gfni-encoding.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mattr=+gfni --show-encoding < %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding < %s | FileCheck %s
// CHECK: gf2p8affineinvqb $7, %xmm2, %xmm1 // CHECK: gf2p8affineinvqb $7, %xmm2, %xmm1
// CHECK: encoding: [0x66,0x0f,0x3a,0xcf,0xca,0x07] // CHECK: encoding: [0x66,0x0f,0x3a,0xcf,0xca,0x07]
gf2p8affineinvqb $7, %xmm2, %xmm1 gf2p8affineinvqb $7, %xmm2, %xmm1
// CHECK: gf2p8affineqb $7, %xmm2, %xmm1 // CHECK: gf2p8affineqb $7, %xmm2, %xmm1
// CHECK: encoding: [0x66,0x0f,0x3a,0xce,0xca,0x07] // CHECK: encoding: [0x66,0x0f,0x3a,0xce,0xca,0x07]
gf2p8affineqb $7, %xmm2, %xmm1 gf2p8affineqb $7, %xmm2, %xmm1
▲ Show 20 Lines • Show All 245 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/intel-syntax-avx512-error.s

// RUN: not llvm-mc %s -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512f -x86-asm-syntax=intel -output-asm-variant=1 -o /dev/null 2>&1 | FileCheck %s // RUN: not llvm-mc %s -triple x86_64-unknown-unknown -x86-asm-syntax=intel -output-asm-variant=1 -o /dev/null 2>&1 | FileCheck %s
// Validate that only OpMask/Zero mark may immediately follow destination // Validate that only OpMask/Zero mark may immediately follow destination
vfmsub213ps zmm8{rn-sae} {k2}, zmm8, zmm8 vfmsub213ps zmm8{rn-sae} {k2}, zmm8, zmm8
// CHECK: error: Expected an op-mask register at this point // CHECK: error: Expected an op-mask register at this point
vfmsub213ps zmm8{k2} {rn-sae}, zmm8, zmm8 vfmsub213ps zmm8{k2} {rn-sae}, zmm8, zmm8
// CHECK: error: Expected a {z} mark at this point // CHECK: error: Expected a {z} mark at this point
vfmsub213ps zmm8{rn-sae}, zmm8, zmm8 vfmsub213ps zmm8{rn-sae}, zmm8, zmm8
// CHECK: error: Expected an op-mask register at this point // CHECK: error: Expected an op-mask register at this point
vpcmpltd k5{k0}, zmm7, zmm24 vpcmpltd k5{k0}, zmm7, zmm24
// CHECK: error: Register k0 can't be used as write mask // CHECK: error: Register k0 can't be used as write mask

llvm/trunk/test/MC/X86/intel-syntax-avx512.s

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
// RUN: llvm-mc -triple x86_64-unknown-unknown -x86-asm-syntax=intel -output-asm-variant=1 -mcpu=knl --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown -x86-asm-syntax=intel -output-asm-variant=1 --show-encoding %s | FileCheck %s
// CHECK: vaddps zmm1, zmm1, zmmword ptr [rax] // CHECK: vaddps zmm1, zmm1, zmmword ptr [rax]
// CHECK: encoding: [0x62,0xf1,0x74,0x48,0x58,0x08] // CHECK: encoding: [0x62,0xf1,0x74,0x48,0x58,0x08]
vaddps zmm1, zmm1, zmmword ptr [rax] vaddps zmm1, zmm1, zmmword ptr [rax]
// CHECK: vaddpd zmm1, zmm1, zmm2 // CHECK: vaddpd zmm1, zmm1, zmm2
// CHECK: encoding: [0x62,0xf1,0xf5,0x48,0x58,0xca] // CHECK: encoding: [0x62,0xf1,0xf5,0x48,0x58,0xca]
vaddpd zmm1, zmm1, zmm2 vaddpd zmm1, zmm1, zmm2
▲ Show 20 Lines • Show All 38,340 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/intel-syntax-unsized-memory.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -x86-asm-syntax=intel -mcpu=knl %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown -x86-asm-syntax=intel %s | FileCheck %s
// Check that we deduce unsized memory operands in the general, unambiguous, case. // Check that we deduce unsized memory operands in the general, unambiguous, case.
// We can't deduce xword memory operands, because there is no instruction // We can't deduce xword memory operands, because there is no instruction
// unambiguously accessing 80-bit memory. // unambiguously accessing 80-bit memory.
// CHECK: movb %al, (%rax) // CHECK: movb %al, (%rax)
mov [rax], al mov [rax], al
Show All 20 Lines

llvm/trunk/test/MC/X86/intel-syntax-x86-64-avx512f_vl.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512vl,+avx512dq -x86-asm-syntax=intel -output-asm-variant=1 --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown -x86-asm-syntax=intel -output-asm-variant=1 --show-encoding %s | FileCheck %s
// CHECK: vcmppd k3, xmm27, xmm23, 171 // CHECK: vcmppd k3, xmm27, xmm23, 171
// CHECK: encoding: [0x62,0xb1,0xa5,0x00,0xc2,0xdf,0xab] // CHECK: encoding: [0x62,0xb1,0xa5,0x00,0xc2,0xdf,0xab]
vcmppd k3,xmm27,xmm23,0xab vcmppd k3,xmm27,xmm23,0xab
// CHECK: vcmppd k3 {k5}, xmm27, xmm23, 171 // CHECK: vcmppd k3 {k5}, xmm27, xmm23, 171
// CHECK: encoding: [0x62,0xb1,0xa5,0x05,0xc2,0xdf,0xab] // CHECK: encoding: [0x62,0xb1,0xa5,0x05,0xc2,0xdf,0xab]
vcmppd k3{k5},xmm27,xmm23,0xab vcmppd k3{k5},xmm27,xmm23,0xab
▲ Show 20 Lines • Show All 1,365 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/intel-syntax-x86-avx512dq_vl.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512vl -mattr=+avx512dq -x86-asm-syntax=intel -output-asm-variant=1 --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown -x86-asm-syntax=intel -output-asm-variant=1 --show-encoding %s | FileCheck %s
// CHECK: vcvtps2qq xmm2 {k2} {z}, qword ptr [rcx + 128] // CHECK: vcvtps2qq xmm2 {k2} {z}, qword ptr [rcx + 128]
// CHECK: encoding: [0x62,0xf1,0x7d,0x8a,0x7b,0x51,0x10] // CHECK: encoding: [0x62,0xf1,0x7d,0x8a,0x7b,0x51,0x10]
vcvtps2qq xmm2 {k2} {z}, qword ptr [rcx + 0x80] vcvtps2qq xmm2 {k2} {z}, qword ptr [rcx + 0x80]
// CHECK: vcvtps2qq xmm2 {k2}, qword ptr [rcx + 128] // CHECK: vcvtps2qq xmm2 {k2}, qword ptr [rcx + 128]
// CHECK: encoding: [0x62,0xf1,0x7d,0x0a,0x7b,0x51,0x10] // CHECK: encoding: [0x62,0xf1,0x7d,0x0a,0x7b,0x51,0x10]
vcvtps2qq xmm2 {k2}, qword ptr [rcx + 0x80] vcvtps2qq xmm2 {k2}, qword ptr [rcx + 0x80]
Show All 32 Lines
// CHECK: vcvttps2uqq xmm1 {k2}, qword ptr [rcx + 128] // CHECK: vcvttps2uqq xmm1 {k2}, qword ptr [rcx + 128]
// CHECK: encoding: [0x62,0xf1,0x7d,0x0a,0x78,0x49,0x10] // CHECK: encoding: [0x62,0xf1,0x7d,0x0a,0x78,0x49,0x10]
vcvttps2uqq xmm1 {k2}, qword ptr [rcx + 128] vcvttps2uqq xmm1 {k2}, qword ptr [rcx + 128]
// CHECK: vcvttps2uqq xmm1, qword ptr [rcx + 128] // CHECK: vcvttps2uqq xmm1, qword ptr [rcx + 128]
// CHECK: encoding: [0x62,0xf1,0x7d,0x08,0x78,0x49,0x10] // CHECK: encoding: [0x62,0xf1,0x7d,0x08,0x78,0x49,0x10]
vcvttps2uqq xmm1, qword ptr [rcx + 128] vcvttps2uqq xmm1, qword ptr [rcx + 128]
// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512vl -mattr=+avx512dq -x86-asm-syntax=intel -output-asm-variant=1 --show-encoding %s | FileCheck %s
// CHECK: vcvtps2qq xmm2 {k2} {z}, qword ptr [rcx + 128] // CHECK: vcvtps2qq xmm2 {k2} {z}, qword ptr [rcx + 128]
// CHECK: encoding: [0x62,0xf1,0x7d,0x8a,0x7b,0x51,0x10] // CHECK: encoding: [0x62,0xf1,0x7d,0x8a,0x7b,0x51,0x10]
vcvtps2qq xmm2 {k2} {z}, qword ptr [rcx + 0x80] vcvtps2qq xmm2 {k2} {z}, qword ptr [rcx + 0x80]
// CHECK: vcvtps2qq xmm2 {k2}, qword ptr [rcx + 128] // CHECK: vcvtps2qq xmm2 {k2}, qword ptr [rcx + 128]
// CHECK: encoding: [0x62,0xf1,0x7d,0x0a,0x7b,0x51,0x10] // CHECK: encoding: [0x62,0xf1,0x7d,0x0a,0x7b,0x51,0x10]
vcvtps2qq xmm2 {k2}, qword ptr [rcx + 0x80] vcvtps2qq xmm2 {k2}, qword ptr [rcx + 0x80]
Show All 40 Lines

llvm/trunk/test/MC/X86/intel-syntax-x86-avx512vbmi_vl.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512vl,+avx512vbmi -x86-asm-syntax=intel -output-asm-variant=1 --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown -x86-asm-syntax=intel -output-asm-variant=1 --show-encoding %s | FileCheck %s
// CHECK: vpmultishiftqb xmm1, xmm2, qword ptr [rcx]{1to2} // CHECK: vpmultishiftqb xmm1, xmm2, qword ptr [rcx]{1to2}
// CHECK: encoding: [0x62,0xf2,0xed,0x18,0x83,0x09] // CHECK: encoding: [0x62,0xf2,0xed,0x18,0x83,0x09]
vpmultishiftqb xmm1, xmm2, qword ptr [rcx]{1to2} vpmultishiftqb xmm1, xmm2, qword ptr [rcx]{1to2}
// CHECK: vpmultishiftqb xmm1 {k1}, xmm2, qword ptr [rcx]{1to2} // CHECK: vpmultishiftqb xmm1 {k1}, xmm2, qword ptr [rcx]{1to2}
// CHECK: encoding: [0x62,0xf2,0xed,0x19,0x83,0x09] // CHECK: encoding: [0x62,0xf2,0xed,0x19,0x83,0x09]
vpmultishiftqb xmm1 {k1}, xmm2, qword ptr [rcx]{1to2} vpmultishiftqb xmm1 {k1}, xmm2, qword ptr [rcx]{1to2}
Show All 28 Lines

llvm/trunk/test/MC/X86/mpx-encodings.s

// RUN: llvm-mc -triple x86_64-- -mattr=+mpx --show-encoding %s |\ // RUN: llvm-mc -triple x86_64-- --show-encoding %s |\
// RUN: FileCheck %s --check-prefixes=CHECK,ENCODING // RUN: FileCheck %s --check-prefixes=CHECK,ENCODING
// RUN: llvm-mc -triple x86_64-- -mattr=+mpx -filetype=obj %s |\ // RUN: llvm-mc -triple x86_64-- -filetype=obj %s |\
// RUN: llvm-objdump -d - -mattr=+mpx | FileCheck %s // RUN: llvm-objdump -d - | FileCheck %s
// CHECK: bndmk (%rax), %bnd0 // CHECK: bndmk (%rax), %bnd0
// ENCODING: encoding: [0xf3,0x48,0x0f,0x1b,0x00] // ENCODING: encoding: [0xf3,0x48,0x0f,0x1b,0x00]
bndmk (%rax), %bnd0 bndmk (%rax), %bnd0
// CHECK: bndmk 1024(%rax), %bnd1 // CHECK: bndmk 1024(%rax), %bnd1
// ENCODING: encoding: [0xf3,0x48,0x0f,0x1b,0x88,0x00,0x04,0x00,0x00] // ENCODING: encoding: [0xf3,0x48,0x0f,0x1b,0x88,0x00,0x04,0x00,0x00]
bndmk 1024(%rax), %bnd1 bndmk 1024(%rax), %bnd1
Show All 28 Lines

llvm/trunk/test/MC/X86/vpclmulqdq.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mattr=+vpclmulqdq --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vpclmulqdq $17, %ymm3, %ymm2, %ymm1 // CHECK: vpclmulqdq $17, %ymm3, %ymm2, %ymm1
// CHECK: encoding: [0xc4,0xe3,0x6d,0x44,0xcb,0x11] // CHECK: encoding: [0xc4,0xe3,0x6d,0x44,0xcb,0x11]
vpclmulqdq $17, %ymm3, %ymm2, %ymm1 vpclmulqdq $17, %ymm3, %ymm2, %ymm1
// CHECK: vpclmulqdq $1, (%rcx), %ymm2, %ymm1 // CHECK: vpclmulqdq $1, (%rcx), %ymm2, %ymm1
// CHECK: encoding: [0xc4,0xe3,0x6d,0x44,0x09,0x01] // CHECK: encoding: [0xc4,0xe3,0x6d,0x44,0x09,0x01]
vpclmulqdq $1, (%rcx), %ymm2, %ymm1 vpclmulqdq $1, (%rcx), %ymm2, %ymm1
Show All 21 Lines

llvm/trunk/test/MC/X86/x86-64-avx512bw.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512bw --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vpaddb %zmm23, %zmm24, %zmm19 // CHECK: vpaddb %zmm23, %zmm24, %zmm19
// CHECK: encoding: [0x62,0xa1,0x3d,0x40,0xfc,0xdf] // CHECK: encoding: [0x62,0xa1,0x3d,0x40,0xfc,0xdf]
vpaddb %zmm23, %zmm24, %zmm19 vpaddb %zmm23, %zmm24, %zmm19
// CHECK: vpaddb %zmm23, %zmm24, %zmm19 {%k3} // CHECK: vpaddb %zmm23, %zmm24, %zmm19 {%k3}
// CHECK: encoding: [0x62,0xa1,0x3d,0x43,0xfc,0xdf] // CHECK: encoding: [0x62,0xa1,0x3d,0x43,0xfc,0xdf]
vpaddb %zmm23, %zmm24, %zmm19 {%k3} vpaddb %zmm23, %zmm24, %zmm19 {%k3}
▲ Show 20 Lines • Show All 4,828 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/x86-64-avx512bw_vl.s

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512bw -mattr=+avx512vl --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vpaddb %xmm22, %xmm17, %xmm26 // CHECK: vpaddb %xmm22, %xmm17, %xmm26
// CHECK: encoding: [0x62,0x21,0x75,0x00,0xfc,0xd6] // CHECK: encoding: [0x62,0x21,0x75,0x00,0xfc,0xd6]
vpaddb %xmm22, %xmm17, %xmm26 vpaddb %xmm22, %xmm17, %xmm26
// CHECK: vpaddb %xmm22, %xmm17, %xmm26 {%k5} // CHECK: vpaddb %xmm22, %xmm17, %xmm26 {%k5}
// CHECK: encoding: [0x62,0x21,0x75,0x05,0xfc,0xd6] // CHECK: encoding: [0x62,0x21,0x75,0x05,0xfc,0xd6]
vpaddb %xmm22, %xmm17, %xmm26 {%k5} vpaddb %xmm22, %xmm17, %xmm26 {%k5}
▲ Show 20 Lines • Show All 9,816 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/x86-64-avx512cd.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512cd --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vplzcntq %zmm22, %zmm21 // CHECK: vplzcntq %zmm22, %zmm21
// CHECK: encoding: [0x62,0xa2,0xfd,0x48,0x44,0xee] // CHECK: encoding: [0x62,0xa2,0xfd,0x48,0x44,0xee]
vplzcntq %zmm22, %zmm21 vplzcntq %zmm22, %zmm21
// CHECK: vplzcntq %zmm22, %zmm21 {%k7} // CHECK: vplzcntq %zmm22, %zmm21 {%k7}
// CHECK: encoding: [0x62,0xa2,0xfd,0x4f,0x44,0xee] // CHECK: encoding: [0x62,0xa2,0xfd,0x4f,0x44,0xee]
vplzcntq %zmm22, %zmm21 {%k7} vplzcntq %zmm22, %zmm21 {%k7}
▲ Show 20 Lines • Show All 344 Lines • ▼ Show 20 Lines
// CHECK: vpconflictd 291(%rax,%r14,8), %zmm25 // CHECK: vpconflictd 291(%rax,%r14,8), %zmm25
// CHECK: encoding: [0x62,0x22,0x7d,0x48,0xc4,0x8c,0xf0,0x23,0x01,0x00,0x00] // CHECK: encoding: [0x62,0x22,0x7d,0x48,0xc4,0x8c,0xf0,0x23,0x01,0x00,0x00]
vpconflictd 291(%rax,%r14,8), %zmm25 vpconflictd 291(%rax,%r14,8), %zmm25
// CHECK: vpconflictd (%rcx){1to16}, %zmm25 // CHECK: vpconflictd (%rcx){1to16}, %zmm25
// CHECK: encoding: [0x62,0x62,0x7d,0x58,0xc4,0x09] // CHECK: encoding: [0x62,0x62,0x7d,0x58,0xc4,0x09]
vpconflictd (%rcx){1to16}, %zmm25 vpconflictd (%rcx){1to16}, %zmm25
// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512cd --show-encoding %s | FileCheck %s
// CHECK: vpconflictd 4064(%rdx), %zmm25 // CHECK: vpconflictd 4064(%rdx), %zmm25
// CHECK: encoding: [0x62,0x62,0x7d,0x48,0xc4,0x8a,0xe0,0x0f,0x00,0x00] // CHECK: encoding: [0x62,0x62,0x7d,0x48,0xc4,0x8a,0xe0,0x0f,0x00,0x00]
vpconflictd 4064(%rdx), %zmm25 vpconflictd 4064(%rdx), %zmm25
// CHECK: vpconflictd 4096(%rdx), %zmm25 // CHECK: vpconflictd 4096(%rdx), %zmm25
// CHECK: encoding: [0x62,0x62,0x7d,0x48,0xc4,0x4a,0x40] // CHECK: encoding: [0x62,0x62,0x7d,0x48,0xc4,0x4a,0x40]
vpconflictd 4096(%rdx), %zmm25 vpconflictd 4096(%rdx), %zmm25
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/x86-64-avx512cd_vl.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512cd -mattr=+avx512vl --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vplzcntq %xmm20, %xmm18 // CHECK: vplzcntq %xmm20, %xmm18
// CHECK: encoding: [0x62,0xa2,0xfd,0x08,0x44,0xd4] // CHECK: encoding: [0x62,0xa2,0xfd,0x08,0x44,0xd4]
vplzcntq %xmm20, %xmm18 vplzcntq %xmm20, %xmm18
// CHECK: vplzcntq %xmm20, %xmm18 {%k1} // CHECK: vplzcntq %xmm20, %xmm18 {%k1}
// CHECK: encoding: [0x62,0xa2,0xfd,0x09,0x44,0xd4] // CHECK: encoding: [0x62,0xa2,0xfd,0x09,0x44,0xd4]
vplzcntq %xmm20, %xmm18 {%k1} vplzcntq %xmm20, %xmm18 {%k1}
▲ Show 20 Lines • Show All 904 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/x86-64-avx512dq.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512dq --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vpmullq %zmm18, %zmm24, %zmm18 // CHECK: vpmullq %zmm18, %zmm24, %zmm18
// CHECK: encoding: [0x62,0xa2,0xbd,0x40,0x40,0xd2] // CHECK: encoding: [0x62,0xa2,0xbd,0x40,0x40,0xd2]
vpmullq %zmm18, %zmm24, %zmm18 vpmullq %zmm18, %zmm24, %zmm18
// CHECK: vpmullq %zmm18, %zmm24, %zmm18 {%k2} // CHECK: vpmullq %zmm18, %zmm24, %zmm18 {%k2}
// CHECK: encoding: [0x62,0xa2,0xbd,0x42,0x40,0xd2] // CHECK: encoding: [0x62,0xa2,0xbd,0x42,0x40,0xd2]
vpmullq %zmm18, %zmm24, %zmm18 {%k2} vpmullq %zmm18, %zmm24, %zmm18 {%k2}
▲ Show 20 Lines • Show All 4,129 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/x86-64-avx512dq_vl.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512dq -mattr=+avx512vl --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vpmullq %xmm22, %xmm17, %xmm26 // CHECK: vpmullq %xmm22, %xmm17, %xmm26
// CHECK: encoding: [0x62,0x22,0xf5,0x00,0x40,0xd6] // CHECK: encoding: [0x62,0x22,0xf5,0x00,0x40,0xd6]
vpmullq %xmm22, %xmm17, %xmm26 vpmullq %xmm22, %xmm17, %xmm26
// CHECK: vpmullq %xmm22, %xmm17, %xmm26 {%k6} // CHECK: vpmullq %xmm22, %xmm17, %xmm26 {%k6}
// CHECK: encoding: [0x62,0x22,0xf5,0x06,0x40,0xd6] // CHECK: encoding: [0x62,0x22,0xf5,0x06,0x40,0xd6]
vpmullq %xmm22, %xmm17, %xmm26 {%k6} vpmullq %xmm22, %xmm17, %xmm26 {%k6}
▲ Show 20 Lines • Show All 4,817 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/x86-64-avx512f_vl.s

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
// RUN: llvm-mc -triple x86_64-unknown-unknown -mcpu=knl -mattr=+avx512vl --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vaddpd %xmm19, %xmm29, %xmm20 // CHECK: vaddpd %xmm19, %xmm29, %xmm20
// CHECK: encoding: [0x62,0xa1,0x95,0x00,0x58,0xe3] // CHECK: encoding: [0x62,0xa1,0x95,0x00,0x58,0xe3]
vaddpd %xmm19, %xmm29, %xmm20 vaddpd %xmm19, %xmm29, %xmm20
// CHECK: vaddpd %xmm19, %xmm29, %xmm20 {%k7} // CHECK: vaddpd %xmm19, %xmm29, %xmm20 {%k7}
// CHECK: encoding: [0x62,0xa1,0x95,0x07,0x58,0xe3] // CHECK: encoding: [0x62,0xa1,0x95,0x07,0x58,0xe3]
vaddpd %xmm19, %xmm29, %xmm20 {%k7} vaddpd %xmm19, %xmm29, %xmm20 {%k7}
▲ Show 20 Lines • Show All 22,956 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/x86-64-avx512vpopcntdq.s

// RUN: llvm-mc -triple x86_64-unknown-unknown -mattr=+avx512vpopcntdq --show-encoding %s | FileCheck %s // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vpopcntq %zmm25, %zmm20 // CHECK: vpopcntq %zmm25, %zmm20
// CHECK: encoding: [0x62,0x82,0xfd,0x48,0x55,0xe1] // CHECK: encoding: [0x62,0x82,0xfd,0x48,0x55,0xe1]
vpopcntq %zmm25, %zmm20 vpopcntq %zmm25, %zmm20
// CHECK: vpopcntq %zmm25, %zmm20 {%k6} // CHECK: vpopcntq %zmm25, %zmm20 {%k6}
// CHECK: encoding: [0x62,0x82,0xfd,0x4e,0x55,0xe1] // CHECK: encoding: [0x62,0x82,0xfd,0x4e,0x55,0xe1]
vpopcntq %zmm25, %zmm20 {%k6} vpopcntq %zmm25, %zmm20 {%k6}
▲ Show 20 Lines • Show All 216 Lines • Show Last 20 Lines

llvm/trunk/test/MC/X86/x86_errors.s

// RUN: not llvm-mc -triple x86_64-unknown-unknown %s 2> %t.err // RUN: not llvm-mc -triple x86_64-unknown-unknown %s 2> %t.err
// RUN: FileCheck --check-prefix=64 < %t.err %s // RUN: FileCheck --check-prefix=64 < %t.err %s
// RUN: not llvm-mc -triple i386-unknown-unknown %s 2> %t.err // RUN: not llvm-mc -triple i386-unknown-unknown %s 2> %t.err
// RUN: FileCheck --check-prefix=32 < %t.err %s // RUN: FileCheck --check-prefix=32 < %t.err %s
// rdar://8204588 // rdar://8204588
// 64: error: ambiguous instructions require an explicit suffix (could be 'cmpb', 'cmpw', 'cmpl', or 'cmpq') // 64: error: ambiguous instructions require an explicit suffix (could be 'cmpb', 'cmpw', 'cmpl', or 'cmpq')
cmp $0, 0(%eax) cmp $0, 0(%eax)
// 32: error: register %rax is only available in 64-bit mode // 32: error: register %rax is only available in 64-bit mode
addl $0, 0(%rax) addl $0, 0(%rax)
// 32: error: register %xmm16 is only available in 64-bit mode
// 64: error: register %xmm16 is only available with AVX512
vaddps %xmm16, %xmm0, %xmm0
// 32: test.s:8:2: error: invalid instruction mnemonic 'movi' // 32: test.s:8:2: error: invalid instruction mnemonic 'movi'
# 8 "test.s" # 8 "test.s"
movi $8,%eax movi $8,%eax
movl 0(%rax), 0(%edx) // error: invalid operand for instruction movl 0(%rax), 0(%edx) // error: invalid operand for instruction
// 32: error: instruction requires: 64-bit mode // 32: error: instruction requires: 64-bit mode
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines