This is an archive of the discontinued LLVM Phabricator instance.

Differential D91793

[AMDGPU][MC] Improved diagnostics for invalid literals
ClosedPublic

Authored by dp on Nov 19 2020, 6:03 AM.

Details

Reviewers
rampitec
Commits
rGe4effef33059: [AMDGPU][MC] Improved diagnostic messages for invalid literals
Summary

Corrected error positions (bug 47518) and improved diagnostic messages for invalid literals.

Diff Detail

Event Timeline

dp created this revision.Nov 19 2020, 6:03 AM
Herald added a project: Restricted Project. · View Herald TranscriptNov 19 2020, 6:03 AM
Herald added subscribers: llvm-commits, kerbowa, hiraditya and 8 others. · View Herald Transcript
dp requested review of this revision.Nov 19 2020, 6:03 AM
Herald added a subscriber: wdng. · View Herald TranscriptNov 19 2020, 6:03 AM
dp added a child revision: D91794: [AMDGPU][MC] Improved diagnostic messages.Nov 19 2020, 6:30 AM
rampitec accepted this revision.Nov 19 2020, 9:37 AM
This revision is now accepted and ready to land.Nov 19 2020, 9:37 AM
Closed by commit rGe4effef33059: [AMDGPU][MC] Improved diagnostic messages for invalid literals (authored by dp). · Explain WhyNov 23 2020, 4:48 AM
This revision was automatically updated to reflect the committed changes.
dp added a commit: rGe4effef33059: [AMDGPU][MC] Improved diagnostic messages for invalid literals.

Revision Contents

PathSize
llvm/
lib/
Target/
AMDGPU/
AsmParser/
92 lines
test/
MC/
AMDGPU/
6 lines
2 lines
60 lines
6 lines
376 lines
20 lines
8 lines
580 lines
23 lines
20 lines
32 lines
48 lines
320 lines
6 lines
2 lines
16 lines
182 lines
4 lines

Diff 306389

llvm/lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp

Show First 20 Lines • Show All 182 Lines • ▼ Show 20 Lines enum ImmTy {
ImmTyGprIdxMode, ImmTyGprIdxMode,
ImmTyHigh, ImmTyHigh,
ImmTyBLGP, ImmTyBLGP,
ImmTyCBSZ, ImmTyCBSZ,
ImmTyABID, ImmTyABID,
ImmTyEndpgm, ImmTyEndpgm,
}; };
enum ImmKindTy {
ImmKindTyNone,
ImmKindTyLiteral,
ImmKindTyConst,
};
private: private:
struct TokOp { struct TokOp {
const char *Data; const char *Data;
unsigned Length; unsigned Length;
}; };
struct ImmOp { struct ImmOp {
int64_t Val; int64_t Val;
ImmTy Type; ImmTy Type;
bool IsFPImm; bool IsFPImm;
mutable ImmKindTy Kind;
Modifiers Mods; Modifiers Mods;
}; };
struct RegOp { struct RegOp {
unsigned RegNo; unsigned RegNo;
Modifiers Mods; Modifiers Mods;
}; };
Show All 19 Linespublic:
bool isSymbolRefExpr() const { bool isSymbolRefExpr() const {
return isExpr() && Expr && isa<MCSymbolRefExpr>(Expr); return isExpr() && Expr && isa<MCSymbolRefExpr>(Expr);
} }
bool isImm() const override { bool isImm() const override {
return Kind == Immediate; return Kind == Immediate;
} }
void setImmKindNone() const {
assert(isImm());
Imm.Kind = ImmKindTyNone;
}
void setImmKindLiteral() const {
assert(isImm());
Imm.Kind = ImmKindTyLiteral;
}
void setImmKindConst() const {
assert(isImm());
Imm.Kind = ImmKindTyConst;
}
bool IsImmKindLiteral() const {
return isImm() && Imm.Kind == ImmKindTyLiteral;
}
bool isImmKindConst() const {
return isImm() && Imm.Kind == ImmKindTyConst;
}
bool isInlinableImm(MVT type) const; bool isInlinableImm(MVT type) const;
bool isLiteralImm(MVT type) const; bool isLiteralImm(MVT type) const;
bool isRegKind() const { bool isRegKind() const {
return Kind == Register; return Kind == Register;
} }
bool isReg() const override { bool isReg() const override {
▲ Show 20 Lines • Show All 662 Lines • ▼ Show 20 Linespublic:
static AMDGPUOperand::Ptr CreateImm(const AMDGPUAsmParser *AsmParser, static AMDGPUOperand::Ptr CreateImm(const AMDGPUAsmParser *AsmParser,
int64_t Val, SMLoc Loc, int64_t Val, SMLoc Loc,
ImmTy Type = ImmTyNone, ImmTy Type = ImmTyNone,
bool IsFPImm = false) { bool IsFPImm = false) {
auto Op = std::make_unique<AMDGPUOperand>(Immediate, AsmParser); auto Op = std::make_unique<AMDGPUOperand>(Immediate, AsmParser);
Op->Imm.Val = Val; Op->Imm.Val = Val;
Op->Imm.IsFPImm = IsFPImm; Op->Imm.IsFPImm = IsFPImm;
Op->Imm.Kind = ImmKindTyNone;
Op->Imm.Type = Type; Op->Imm.Type = Type;
Op->Imm.Mods = Modifiers(); Op->Imm.Mods = Modifiers();
Op->StartLoc = Loc; Op->StartLoc = Loc;
Op->EndLoc = Loc; Op->EndLoc = Loc;
return Op; return Op;
} }
static AMDGPUOperand::Ptr CreateToken(const AMDGPUAsmParser *AsmParser, static AMDGPUOperand::Ptr CreateToken(const AMDGPUAsmParser *AsmParser,
▲ Show 20 Lines • Show All 431 Lines • ▼ Show 20 Linesprivate:
OperandMatchResultTy parseExpTgtImpl(StringRef Str, uint8_t &Val); OperandMatchResultTy parseExpTgtImpl(StringRef Str, uint8_t &Val);
SMLoc getFlatOffsetLoc(const OperandVector &Operands) const; SMLoc getFlatOffsetLoc(const OperandVector &Operands) const;
SMLoc getSMEMOffsetLoc(const OperandVector &Operands) const; SMLoc getSMEMOffsetLoc(const OperandVector &Operands) const;
SMLoc getOperandLoc(std::function<bool(const AMDGPUOperand&)> Test, SMLoc getOperandLoc(std::function<bool(const AMDGPUOperand&)> Test,
const OperandVector &Operands) const; const OperandVector &Operands) const;
SMLoc getImmLoc(AMDGPUOperand::ImmTy Type, const OperandVector &Operands) const; SMLoc getImmLoc(AMDGPUOperand::ImmTy Type, const OperandVector &Operands) const;
SMLoc getRegLoc(unsigned Reg, const OperandVector &Operands) const; SMLoc getRegLoc(unsigned Reg, const OperandVector &Operands) const;
SMLoc getLitLoc(const OperandVector &Operands) const;
SMLoc getConstLoc(const OperandVector &Operands) const;
bool validateInstruction(const MCInst &Inst, const SMLoc &IDLoc, const OperandVector &Operands); bool validateInstruction(const MCInst &Inst, const SMLoc &IDLoc, const OperandVector &Operands);
bool validateFlatOffset(const MCInst &Inst, const OperandVector &Operands); bool validateFlatOffset(const MCInst &Inst, const OperandVector &Operands);
bool validateSMEMOffset(const MCInst &Inst, const OperandVector &Operands); bool validateSMEMOffset(const MCInst &Inst, const OperandVector &Operands);
bool validateSOPLiteral(const MCInst &Inst) const; bool validateSOPLiteral(const MCInst &Inst) const;
bool validateConstantBusLimitations(const MCInst &Inst); bool validateConstantBusLimitations(const MCInst &Inst);
bool validateEarlyClobberLimitations(const MCInst &Inst); bool validateEarlyClobberLimitations(const MCInst &Inst);
bool validateIntClampSupported(const MCInst &Inst); bool validateIntClampSupported(const MCInst &Inst);
bool validateMIMGAtomicDMask(const MCInst &Inst); bool validateMIMGAtomicDMask(const MCInst &Inst);
bool validateMIMGGatherDMask(const MCInst &Inst); bool validateMIMGGatherDMask(const MCInst &Inst);
bool validateMovrels(const MCInst &Inst); bool validateMovrels(const MCInst &Inst);
bool validateMIMGDataSize(const MCInst &Inst); bool validateMIMGDataSize(const MCInst &Inst);
bool validateMIMGAddrSize(const MCInst &Inst); bool validateMIMGAddrSize(const MCInst &Inst);
bool validateMIMGD16(const MCInst &Inst); bool validateMIMGD16(const MCInst &Inst);
bool validateMIMGDim(const MCInst &Inst); bool validateMIMGDim(const MCInst &Inst);
bool validateLdsDirect(const MCInst &Inst); bool validateLdsDirect(const MCInst &Inst);
bool validateOpSel(const MCInst &Inst); bool validateOpSel(const MCInst &Inst);
bool validateVccOperand(unsigned Reg) const; bool validateVccOperand(unsigned Reg) const;
bool validateVOP3Literal(const MCInst &Inst) const; bool validateVOP3Literal(const MCInst &Inst, const OperandVector &Operands);
bool validateMAIAccWrite(const MCInst &Inst); bool validateMAIAccWrite(const MCInst &Inst);
bool validateDivScale(const MCInst &Inst); bool validateDivScale(const MCInst &Inst);
bool validateCoherencyBits(const MCInst &Inst, const OperandVector &Operands, bool validateCoherencyBits(const MCInst &Inst, const OperandVector &Operands,
const SMLoc &IDLoc); const SMLoc &IDLoc);
unsigned getConstantBusLimit(unsigned Opcode) const; unsigned getConstantBusLimit(unsigned Opcode) const;
bool usesConstantBus(const MCInst &Inst, unsigned OpIdx); bool usesConstantBus(const MCInst &Inst, unsigned OpIdx);
bool isInlineConstant(const MCInst &Inst, unsigned OpIdx) const; bool isInlineConstant(const MCInst &Inst, unsigned OpIdx) const;
unsigned findImplicitSGPRReadInVOP(const MCInst &Inst) const; unsigned findImplicitSGPRReadInVOP(const MCInst &Inst) const;
▲ Show 20 Lines • Show All 379 Lines • ▼ Show 20 Linesvoid AMDGPUOperand::addImmOperands(MCInst &Inst, unsigned N, bool ApplyModifiers) const {
if (AMDGPU::isSISrcOperand(AsmParser->getMII()->get(Inst.getOpcode()), if (AMDGPU::isSISrcOperand(AsmParser->getMII()->get(Inst.getOpcode()),
Inst.getNumOperands())) { Inst.getNumOperands())) {
addLiteralImmOperand(Inst, Imm.Val, addLiteralImmOperand(Inst, Imm.Val,
ApplyModifiers & ApplyModifiers &
isImmTy(ImmTyNone) && Imm.Mods.hasFPModifiers()); isImmTy(ImmTyNone) && Imm.Mods.hasFPModifiers());
} else { } else {
assert(!isImmTy(ImmTyNone) || !hasModifiers()); assert(!isImmTy(ImmTyNone) || !hasModifiers());
Inst.addOperand(MCOperand::createImm(Imm.Val)); Inst.addOperand(MCOperand::createImm(Imm.Val));
setImmKindNone();
} }
} }
void AMDGPUOperand::addLiteralImmOperand(MCInst &Inst, int64_t Val, bool ApplyModifiers) const { void AMDGPUOperand::addLiteralImmOperand(MCInst &Inst, int64_t Val, bool ApplyModifiers) const {
const auto& InstDesc = AsmParser->getMII()->get(Inst.getOpcode()); const auto& InstDesc = AsmParser->getMII()->get(Inst.getOpcode());
auto OpNum = Inst.getNumOperands(); auto OpNum = Inst.getNumOperands();
// Check that this operand accepts literals // Check that this operand accepts literals
assert(AMDGPU::isSISrcOperand(InstDesc, OpNum)); assert(AMDGPU::isSISrcOperand(InstDesc, OpNum));
Show All 11 Lines if (Imm.IsFPImm) { // We got fp literal token
switch (OpTy) { switch (OpTy) {
case AMDGPU::OPERAND_REG_IMM_INT64: case AMDGPU::OPERAND_REG_IMM_INT64:
case AMDGPU::OPERAND_REG_IMM_FP64: case AMDGPU::OPERAND_REG_IMM_FP64:
case AMDGPU::OPERAND_REG_INLINE_C_INT64: case AMDGPU::OPERAND_REG_INLINE_C_INT64:
case AMDGPU::OPERAND_REG_INLINE_C_FP64: case AMDGPU::OPERAND_REG_INLINE_C_FP64:
if (AMDGPU::isInlinableLiteral64(Literal.getZExtValue(), if (AMDGPU::isInlinableLiteral64(Literal.getZExtValue(),
AsmParser->hasInv2PiInlineImm())) { AsmParser->hasInv2PiInlineImm())) {
Inst.addOperand(MCOperand::createImm(Literal.getZExtValue())); Inst.addOperand(MCOperand::createImm(Literal.getZExtValue()));
setImmKindConst();
return; return;
} }
// Non-inlineable // Non-inlineable
if (AMDGPU::isSISrcFPOperand(InstDesc, OpNum)) { // Expected 64-bit fp operand if (AMDGPU::isSISrcFPOperand(InstDesc, OpNum)) { // Expected 64-bit fp operand
// For fp operands we check if low 32 bits are zeros // For fp operands we check if low 32 bits are zeros
if (Literal.getLoBits(32) != 0) { if (Literal.getLoBits(32) != 0) {
const_cast<AMDGPUAsmParser *>(AsmParser)->Warning(Inst.getLoc(), const_cast<AMDGPUAsmParser *>(AsmParser)->Warning(Inst.getLoc(),
"Can't encode literal as exact 64-bit floating-point operand. " "Can't encode literal as exact 64-bit floating-point operand. "
"Low 32-bits will be set to zero"); "Low 32-bits will be set to zero");
} }
Inst.addOperand(MCOperand::createImm(Literal.lshr(32).getZExtValue())); Inst.addOperand(MCOperand::createImm(Literal.lshr(32).getZExtValue()));
setImmKindLiteral();
return; return;
} }
// We don't allow fp literals in 64-bit integer instructions. It is // We don't allow fp literals in 64-bit integer instructions. It is
// unclear how we should encode them. This case should be checked earlier // unclear how we should encode them. This case should be checked earlier
// in predicate methods (isLiteralImm()) // in predicate methods (isLiteralImm())
llvm_unreachable("fp literal in 64-bit integer instruction."); llvm_unreachable("fp literal in 64-bit integer instruction.");
Show All 20 Lines case AMDGPU::OPERAND_REG_IMM_V2FP16: {
// Convert literal to single precision // Convert literal to single precision
FPLiteral.convert(*getOpFltSemantics(OpTy), FPLiteral.convert(*getOpFltSemantics(OpTy),
APFloat::rmNearestTiesToEven, &lost); APFloat::rmNearestTiesToEven, &lost);
// We allow precision lost but not overflow or underflow. This should be // We allow precision lost but not overflow or underflow. This should be
// checked earlier in isLiteralImm() // checked earlier in isLiteralImm()
uint64_t ImmVal = FPLiteral.bitcastToAPInt().getZExtValue(); uint64_t ImmVal = FPLiteral.bitcastToAPInt().getZExtValue();
Inst.addOperand(MCOperand::createImm(ImmVal)); Inst.addOperand(MCOperand::createImm(ImmVal));
setImmKindLiteral();
return; return;
} }
default: default:
llvm_unreachable("invalid operand size"); llvm_unreachable("invalid operand size");
} }
return; return;
} }
// We got int literal token. // We got int literal token.
// Only sign extend inline immediates. // Only sign extend inline immediates.
switch (OpTy) { switch (OpTy) {
case AMDGPU::OPERAND_REG_IMM_INT32: case AMDGPU::OPERAND_REG_IMM_INT32:
case AMDGPU::OPERAND_REG_IMM_FP32: case AMDGPU::OPERAND_REG_IMM_FP32:
case AMDGPU::OPERAND_REG_INLINE_C_INT32: case AMDGPU::OPERAND_REG_INLINE_C_INT32:
case AMDGPU::OPERAND_REG_INLINE_C_FP32: case AMDGPU::OPERAND_REG_INLINE_C_FP32:
case AMDGPU::OPERAND_REG_INLINE_AC_INT32: case AMDGPU::OPERAND_REG_INLINE_AC_INT32:
case AMDGPU::OPERAND_REG_INLINE_AC_FP32: case AMDGPU::OPERAND_REG_INLINE_AC_FP32:
case AMDGPU::OPERAND_REG_IMM_V2INT16: case AMDGPU::OPERAND_REG_IMM_V2INT16:
case AMDGPU::OPERAND_REG_IMM_V2FP16: case AMDGPU::OPERAND_REG_IMM_V2FP16:
if (isSafeTruncation(Val, 32) && if (isSafeTruncation(Val, 32) &&
AMDGPU::isInlinableLiteral32(static_cast<int32_t>(Val), AMDGPU::isInlinableLiteral32(static_cast<int32_t>(Val),
AsmParser->hasInv2PiInlineImm())) { AsmParser->hasInv2PiInlineImm())) {
Inst.addOperand(MCOperand::createImm(Val)); Inst.addOperand(MCOperand::createImm(Val));
setImmKindConst();
return; return;
} }
Inst.addOperand(MCOperand::createImm(Val & 0xffffffff)); Inst.addOperand(MCOperand::createImm(Val & 0xffffffff));
setImmKindLiteral();
return; return;
case AMDGPU::OPERAND_REG_IMM_INT64: case AMDGPU::OPERAND_REG_IMM_INT64:
case AMDGPU::OPERAND_REG_IMM_FP64: case AMDGPU::OPERAND_REG_IMM_FP64:
case AMDGPU::OPERAND_REG_INLINE_C_INT64: case AMDGPU::OPERAND_REG_INLINE_C_INT64:
case AMDGPU::OPERAND_REG_INLINE_C_FP64: case AMDGPU::OPERAND_REG_INLINE_C_FP64:
if (AMDGPU::isInlinableLiteral64(Val, AsmParser->hasInv2PiInlineImm())) { if (AMDGPU::isInlinableLiteral64(Val, AsmParser->hasInv2PiInlineImm())) {
Inst.addOperand(MCOperand::createImm(Val)); Inst.addOperand(MCOperand::createImm(Val));
setImmKindConst();
return; return;
} }
Inst.addOperand(MCOperand::createImm(Lo_32(Val))); Inst.addOperand(MCOperand::createImm(Lo_32(Val)));
setImmKindLiteral();
return; return;
case AMDGPU::OPERAND_REG_IMM_INT16: case AMDGPU::OPERAND_REG_IMM_INT16:
case AMDGPU::OPERAND_REG_IMM_FP16: case AMDGPU::OPERAND_REG_IMM_FP16:
case AMDGPU::OPERAND_REG_INLINE_C_INT16: case AMDGPU::OPERAND_REG_INLINE_C_INT16:
case AMDGPU::OPERAND_REG_INLINE_C_FP16: case AMDGPU::OPERAND_REG_INLINE_C_FP16:
case AMDGPU::OPERAND_REG_INLINE_AC_INT16: case AMDGPU::OPERAND_REG_INLINE_AC_INT16:
case AMDGPU::OPERAND_REG_INLINE_AC_FP16: case AMDGPU::OPERAND_REG_INLINE_AC_FP16:
if (isSafeTruncation(Val, 16) && if (isSafeTruncation(Val, 16) &&
AMDGPU::isInlinableLiteral16(static_cast<int16_t>(Val), AMDGPU::isInlinableLiteral16(static_cast<int16_t>(Val),
AsmParser->hasInv2PiInlineImm())) { AsmParser->hasInv2PiInlineImm())) {
Inst.addOperand(MCOperand::createImm(Val)); Inst.addOperand(MCOperand::createImm(Val));
setImmKindConst();
return; return;
} }
Inst.addOperand(MCOperand::createImm(Val & 0xffff)); Inst.addOperand(MCOperand::createImm(Val & 0xffff));
setImmKindLiteral();
return; return;
case AMDGPU::OPERAND_REG_INLINE_C_V2INT16: case AMDGPU::OPERAND_REG_INLINE_C_V2INT16:
case AMDGPU::OPERAND_REG_INLINE_C_V2FP16: case AMDGPU::OPERAND_REG_INLINE_C_V2FP16:
case AMDGPU::OPERAND_REG_INLINE_AC_V2INT16: case AMDGPU::OPERAND_REG_INLINE_AC_V2INT16:
case AMDGPU::OPERAND_REG_INLINE_AC_V2FP16: { case AMDGPU::OPERAND_REG_INLINE_AC_V2FP16: {
assert(isSafeTruncation(Val, 16)); assert(isSafeTruncation(Val, 16));
assert(AMDGPU::isInlinableLiteral16(static_cast<int16_t>(Val), assert(AMDGPU::isInlinableLiteral16(static_cast<int16_t>(Val),
AsmParser->hasInv2PiInlineImm())); AsmParser->hasInv2PiInlineImm()));
Inst.addOperand(MCOperand::createImm(Val)); Inst.addOperand(MCOperand::createImm(Val));
return; return;
} }
default: default:
llvm_unreachable("invalid operand size"); llvm_unreachable("invalid operand size");
} }
} }
template <unsigned Bitwidth> template <unsigned Bitwidth>
void AMDGPUOperand::addKImmFPOperands(MCInst &Inst, unsigned N) const { void AMDGPUOperand::addKImmFPOperands(MCInst &Inst, unsigned N) const {
APInt Literal(64, Imm.Val); APInt Literal(64, Imm.Val);
setImmKindNone();
if (!Imm.IsFPImm) { if (!Imm.IsFPImm) {
// We got int literal token. // We got int literal token.
Inst.addOperand(MCOperand::createImm(Literal.getLoBits(Bitwidth).getZExtValue())); Inst.addOperand(MCOperand::createImm(Literal.getLoBits(Bitwidth).getZExtValue()));
return; return;
} }
bool Lost; bool Lost;
▲ Show 20 Lines • Show All 1,758 Lines • ▼ Show 20 Lines
// Check if VCC register matches wavefront size // Check if VCC register matches wavefront size
bool AMDGPUAsmParser::validateVccOperand(unsigned Reg) const { bool AMDGPUAsmParser::validateVccOperand(unsigned Reg) const {
auto FB = getFeatureBits(); auto FB = getFeatureBits();
return (FB[AMDGPU::FeatureWavefrontSize64] && Reg == AMDGPU::VCC) || return (FB[AMDGPU::FeatureWavefrontSize64] && Reg == AMDGPU::VCC) ||
(FB[AMDGPU::FeatureWavefrontSize32] && Reg == AMDGPU::VCC_LO); (FB[AMDGPU::FeatureWavefrontSize32] && Reg == AMDGPU::VCC_LO);
} }
// VOP3 literal is only allowed in GFX10+ and only one can be used // VOP3 literal is only allowed in GFX10+ and only one can be used
bool AMDGPUAsmParser::validateVOP3Literal(const MCInst &Inst) const { bool AMDGPUAsmParser::validateVOP3Literal(const MCInst &Inst,
const OperandVector &Operands) {
unsigned Opcode = Inst.getOpcode(); unsigned Opcode = Inst.getOpcode();
const MCInstrDesc &Desc = MII.get(Opcode); const MCInstrDesc &Desc = MII.get(Opcode);
if (!(Desc.TSFlags & (SIInstrFlags::VOP3 | SIInstrFlags::VOP3P))) if (!(Desc.TSFlags & (SIInstrFlags::VOP3 | SIInstrFlags::VOP3P)))
return true; return true;
const int Src0Idx = AMDGPU::getNamedOperandIdx(Opcode, AMDGPU::OpName::src0); const int Src0Idx = AMDGPU::getNamedOperandIdx(Opcode, AMDGPU::OpName::src0);
const int Src1Idx = AMDGPU::getNamedOperandIdx(Opcode, AMDGPU::OpName::src1); const int Src1Idx = AMDGPU::getNamedOperandIdx(Opcode, AMDGPU::OpName::src1);
const int Src2Idx = AMDGPU::getNamedOperandIdx(Opcode, AMDGPU::OpName::src2); const int Src2Idx = AMDGPU::getNamedOperandIdx(Opcode, AMDGPU::OpName::src2);
Show All 9 Lines for (int OpIdx : OpIndices) {
const MCOperand &MO = Inst.getOperand(OpIdx); const MCOperand &MO = Inst.getOperand(OpIdx);
if (!MO.isImm() && !MO.isExpr()) if (!MO.isImm() && !MO.isExpr())
continue; continue;
if (!AMDGPU::isSISrcOperand(Desc, OpIdx)) if (!AMDGPU::isSISrcOperand(Desc, OpIdx))
continue; continue;
if (OpIdx == Src2Idx && (Desc.TSFlags & SIInstrFlags::IsMAI) && if (OpIdx == Src2Idx && (Desc.TSFlags & SIInstrFlags::IsMAI) &&
getFeatureBits()[AMDGPU::FeatureMFMAInlineLiteralBug]) getFeatureBits()[AMDGPU::FeatureMFMAInlineLiteralBug]) {
Error(getConstLoc(Operands),
"inline constants are not allowed for this operand");
return false; return false;
}
if (MO.isImm() && !isInlineConstant(Inst, OpIdx)) { if (MO.isImm() && !isInlineConstant(Inst, OpIdx)) {
uint32_t Value = static_cast<uint32_t>(MO.getImm()); uint32_t Value = static_cast<uint32_t>(MO.getImm());
if (NumLiterals == 0 || LiteralValue != Value) { if (NumLiterals == 0 || LiteralValue != Value) {
LiteralValue = Value; LiteralValue = Value;
++NumLiterals; ++NumLiterals;
} }
} else if (MO.isExpr()) { } else if (MO.isExpr()) {
++NumExprs; ++NumExprs;
} }
} }
NumLiterals += NumExprs; NumLiterals += NumExprs;
return !NumLiterals || if (!NumLiterals)
(NumLiterals == 1 && getFeatureBits()[AMDGPU::FeatureVOP3Literal]); return true;
if (!getFeatureBits()[AMDGPU::FeatureVOP3Literal]) {
Error(getLitLoc(Operands), "literal operands are not supported");
return false;
}
if (NumLiterals > 1) {
Error(getLitLoc(Operands), "only one literal operand is allowed");
return false;
}
return true;
} }
bool AMDGPUAsmParser::validateCoherencyBits(const MCInst &Inst, bool AMDGPUAsmParser::validateCoherencyBits(const MCInst &Inst,
const OperandVector &Operands, const OperandVector &Operands,
const SMLoc &IDLoc) { const SMLoc &IDLoc) {
int GLCPos = AMDGPU::getNamedOperandIdx(Inst.getOpcode(), int GLCPos = AMDGPU::getNamedOperandIdx(Inst.getOpcode(),
AMDGPU::OpName::glc1); AMDGPU::OpName::glc1);
if (GLCPos != -1) { if (GLCPos != -1) {
Show All 12 Linesbool AMDGPUAsmParser::validateInstruction(const MCInst &Inst,
const SMLoc &IDLoc, const SMLoc &IDLoc,
const OperandVector &Operands) { const OperandVector &Operands) {
if (!validateLdsDirect(Inst)) { if (!validateLdsDirect(Inst)) {
Error(getRegLoc(AMDGPU::LDS_DIRECT, Operands), Error(getRegLoc(AMDGPU::LDS_DIRECT, Operands),
"invalid use of lds_direct"); "invalid use of lds_direct");
return false; return false;
} }
if (!validateSOPLiteral(Inst)) { if (!validateSOPLiteral(Inst)) {
Error(IDLoc, Error(getLitLoc(Operands),
"only one literal operand is allowed"); "only one literal operand is allowed");
return false; return false;
} }
if (!validateVOP3Literal(Inst)) { if (!validateVOP3Literal(Inst, Operands)) {
Error(IDLoc,
"invalid literal operand");
return false; return false;
} }
if (!validateConstantBusLimitations(Inst)) { if (!validateConstantBusLimitations(Inst)) {
Error(IDLoc, Error(IDLoc,
"invalid operand (violates constant bus restrictions)"); "invalid operand (violates constant bus restrictions)");
return false; return false;
} }
if (!validateEarlyClobberLimitations(Inst)) { if (!validateEarlyClobberLimitations(Inst)) {
▲ Show 20 Lines • Show All 2,319 Lines • ▼ Show 20 Lines
AMDGPUAsmParser::getRegLoc(unsigned Reg, AMDGPUAsmParser::getRegLoc(unsigned Reg,
const OperandVector &Operands) const { const OperandVector &Operands) const {
auto Test = [=](const AMDGPUOperand& Op) { auto Test = [=](const AMDGPUOperand& Op) {
return Op.isRegKind() && Op.getReg() == Reg; return Op.isRegKind() && Op.getReg() == Reg;
}; };
return getOperandLoc(Test, Operands); return getOperandLoc(Test, Operands);
} }
SMLoc
AMDGPUAsmParser::getLitLoc(const OperandVector &Operands) const {
auto Test = [](const AMDGPUOperand& Op) {
return Op.IsImmKindLiteral() || Op.isExpr();
};
return getOperandLoc(Test, Operands);
}
SMLoc
AMDGPUAsmParser::getConstLoc(const OperandVector &Operands) const {
auto Test = [](const AMDGPUOperand& Op) {
return Op.isImmKindConst();
};
return getOperandLoc(Test, Operands);
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// swizzle // swizzle
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
LLVM_READNONE LLVM_READNONE
static unsigned static unsigned
encodeBitmaskPerm(const unsigned AndMask, encodeBitmaskPerm(const unsigned AndMask,
const unsigned OrMask, const unsigned OrMask,
▲ Show 20 Lines • Show All 1,654 Lines • Show Last 20 Lines

llvm/test/MC/AMDGPU/expressions-gfx10.s

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
s_sub_u32 s0, u, u s_sub_u32 s0, u, u
// NOGFX10: error: only one literal operand is allowed // NOGFX10: error: only one literal operand is allowed
s_sub_u32 s0, u, u1 s_sub_u32 s0, u, u1
// NOGFX10: error: only one literal operand is allowed // NOGFX10: error: only one literal operand is allowed
v_bfe_u32 v0, v2, 123, u v_bfe_u32 v0, v2, 123, u
// NOGFX10: error: invalid literal operand // NOGFX10: error: only one literal operand is allowed
v_bfe_u32 v0, v2, u, u v_bfe_u32 v0, v2, u, u
// NOGFX10: error: invalid literal operand // NOGFX10: error: only one literal operand is allowed
v_bfe_u32 v0, v2, u, u1 v_bfe_u32 v0, v2, u, u1
// NOGFX10: error: invalid literal operand // NOGFX10: error: only one literal operand is allowed

llvm/test/MC/AMDGPU/expressions-gfx9.s

Show All 17 Lines
s_sub_u32 s0, u, u s_sub_u32 s0, u, u
// NOGFX9: error: only one literal operand is allowed // NOGFX9: error: only one literal operand is allowed
s_sub_u32 s0, u, u1 s_sub_u32 s0, u, u1
// NOGFX9: error: only one literal operand is allowed // NOGFX9: error: only one literal operand is allowed
v_bfe_u32 v0, v2, v3, u v_bfe_u32 v0, v2, v3, u
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Constant expressions may be used with 'sext' modifier // Constant expressions may be used with 'sext' modifier
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
i1=1 i1=1
v_mov_b32_sdwa v1, sext(i1-2) v_mov_b32_sdwa v1, sext(i1-2)
Show All 14 Lines

llvm/test/MC/AMDGPU/gfx10_err_pos.s

Show First 20 Lines • Show All 540 Lines • ▼ Show 20 Lines
// invalid instruction // invalid instruction
v_dot_f32_f16 v0, v1, v2 v_dot_f32_f16 v0, v1, v2
// CHECK: error: invalid instruction // CHECK: error: invalid instruction
// CHECK-NEXT:{{^}}v_dot_f32_f16 v0, v1, v2 // CHECK-NEXT:{{^}}v_dot_f32_f16 v0, v1, v2
// CHECK-NEXT:{{^}}^ // CHECK-NEXT:{{^}}^
//============================================================================== //==============================================================================
// invalid literal operand
v_add_f64 v[0:1], 1.23456, -abs(1.2345)
// CHECK: error: invalid literal operand
// CHECK-NEXT:{{^}}v_add_f64 v[0:1], 1.23456, -abs(1.2345)
// CHECK-NEXT:{{^}}^
v_min3_i16 v5, 0x5678, 0x5678, 0x5679
// CHECK: error: invalid literal operand
// CHECK-NEXT:{{^}}v_min3_i16 v5, 0x5678, 0x5678, 0x5679
// CHECK-NEXT:{{^}}^
v_pk_add_f16 v1, 25.0, 25.1
// CHECK: error: invalid literal operand
// CHECK-NEXT:{{^}}v_pk_add_f16 v1, 25.0, 25.1
// CHECK-NEXT:{{^}}^
//==============================================================================
// invalid mask // invalid mask
ds_swizzle_b32 v8, v2 offset:swizzle(BITMASK_PERM, "pppi2") ds_swizzle_b32 v8, v2 offset:swizzle(BITMASK_PERM, "pppi2")
// CHECK: error: invalid mask // CHECK: error: invalid mask
// CHECK-NEXT:{{^}}ds_swizzle_b32 v8, v2 offset:swizzle(BITMASK_PERM, "pppi2") // CHECK-NEXT:{{^}}ds_swizzle_b32 v8, v2 offset:swizzle(BITMASK_PERM, "pppi2")
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
//============================================================================== //==============================================================================
▲ Show 20 Lines • Show All 197 Lines • ▼ Show 20 Lines
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
//============================================================================== //==============================================================================
// only one literal operand is allowed // only one literal operand is allowed
s_and_b32 s2, 0x12345678, 0x12345679 s_and_b32 s2, 0x12345678, 0x12345679
// CHECK: error: only one literal operand is allowed // CHECK: error: only one literal operand is allowed
// CHECK-NEXT:{{^}}s_and_b32 s2, 0x12345678, 0x12345679 // CHECK-NEXT:{{^}}s_and_b32 s2, 0x12345678, 0x12345679
// CHECK-NEXT:{{^}}^ // CHECK-NEXT:{{^}} ^
v_add_f64 v[0:1], 1.23456, -abs(1.2345)
// CHECK: error: only one literal operand is allowed
// CHECK-NEXT:{{^}}v_add_f64 v[0:1], 1.23456, -abs(1.2345)
// CHECK-NEXT:{{^}} ^
v_min3_i16 v5, 0x5678, 0x5678, 0x5679
// CHECK: error: only one literal operand is allowed
// CHECK-NEXT:{{^}}v_min3_i16 v5, 0x5678, 0x5678, 0x5679
// CHECK-NEXT:{{^}} ^
v_pk_add_f16 v1, 25.0, 25.1
// CHECK: error: only one literal operand is allowed
// CHECK-NEXT:{{^}}v_pk_add_f16 v1, 25.0, 25.1
// CHECK-NEXT:{{^}} ^
v_fma_mix_f32 v5, 0x7c, 0x7b, 1
// CHECK: error: only one literal operand is allowed
// CHECK-NEXT:{{^}}v_fma_mix_f32 v5, 0x7c, 0x7b, 1
// CHECK-NEXT:{{^}} ^
v_pk_add_i16 v5, 0x7c, 0x4000
// CHECK: error: only one literal operand is allowed
// CHECK-NEXT:{{^}}v_pk_add_i16 v5, 0x7c, 0x4000
// CHECK-NEXT:{{^}} ^
v_pk_add_i16 v5, 0x4400, 0x4000
// CHECK: error: only one literal operand is allowed
// CHECK-NEXT:{{^}}v_pk_add_i16 v5, 0x4400, 0x4000
// CHECK-NEXT:{{^}} ^
v_bfe_u32 v0, v2, 123, undef
// CHECK: error: only one literal operand is allowed
// CHECK-NEXT:{{^}}v_bfe_u32 v0, v2, 123, undef
// CHECK-NEXT:{{^}} ^
v_bfe_u32 v0, v2, undef, 123
// CHECK: error: only one literal operand is allowed
// CHECK-NEXT:{{^}}v_bfe_u32 v0, v2, undef, 123
// CHECK-NEXT:{{^}} ^
//============================================================================== //==============================================================================
// out of bounds attr // out of bounds attr
v_interp_p1_f32 v0, v1, attr64.w v_interp_p1_f32 v0, v1, attr64.w
// CHECK: error: out of bounds attr // CHECK: error: out of bounds attr
// CHECK-NEXT:{{^}}v_interp_p1_f32 v0, v1, attr64.w // CHECK-NEXT:{{^}}v_interp_p1_f32 v0, v1, attr64.w
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
▲ Show 20 Lines • Show All 265 Lines • Show Last 20 Lines

llvm/test/MC/AMDGPU/gfx7_err_pos.s

Show All 11 Lines
// integer clamping is not supported on this GPU // integer clamping is not supported on this GPU
v_add_co_u32 v84, s[4:5], v13, v31 clamp v_add_co_u32 v84, s[4:5], v13, v31 clamp
// CHECK: error: integer clamping is not supported on this GPU // CHECK: error: integer clamping is not supported on this GPU
// CHECK-NEXT:{{^}}v_add_co_u32 v84, s[4:5], v13, v31 clamp // CHECK-NEXT:{{^}}v_add_co_u32 v84, s[4:5], v13, v31 clamp
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
//============================================================================== //==============================================================================
// invalid literal operand // literal operands are not supported
v_and_b32_e64 v0, 0.159154943091895317852646485335, v1 v_and_b32_e64 v0, 0.159154943091895317852646485335, v1
// CHECK: error: invalid literal operand // CHECK: error: literal operands are not supported
// CHECK-NEXT:{{^}}v_and_b32_e64 v0, 0.159154943091895317852646485335, v1 // CHECK-NEXT:{{^}}v_and_b32_e64 v0, 0.159154943091895317852646485335, v1
// CHECK-NEXT:{{^}}^ // CHECK-NEXT:{{^}} ^

llvm/test/MC/AMDGPU/gfx8_asm_all.s

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 31,640 Lines • ▼ Show 20 Lines
v_cvt_f16_u16_e64 v5, 0 v_cvt_f16_u16_e64 v5, 0
// CHECK: [0x05,0x00,0x79,0xd1,0x80,0x00,0x00,0x00] // CHECK: [0x05,0x00,0x79,0xd1,0x80,0x00,0x00,0x00]
v_cvt_f16_u16_e64 v5, -1 v_cvt_f16_u16_e64 v5, -1
// CHECK: [0x05,0x00,0x79,0xd1,0xc1,0x00,0x00,0x00] // CHECK: [0x05,0x00,0x79,0xd1,0xc1,0x00,0x00,0x00]
v_cvt_f16_u16_e64 v5, 0.5 v_cvt_f16_u16_e64 v5, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cvt_f16_u16_e64 v5, -4.0 v_cvt_f16_u16_e64 v5, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cvt_f16_u16_e64 v5, v1 clamp v_cvt_f16_u16_e64 v5, v1 clamp
// CHECK: [0x05,0x80,0x79,0xd1,0x01,0x01,0x00,0x00] // CHECK: [0x05,0x80,0x79,0xd1,0x01,0x01,0x00,0x00]
v_cvt_f16_i16 v5, v1 v_cvt_f16_i16 v5, v1
// CHECK: [0x01,0x75,0x0a,0x7e] // CHECK: [0x01,0x75,0x0a,0x7e]
v_cvt_f16_i16 v255, v1 v_cvt_f16_i16 v255, v1
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
v_cvt_f16_i16_e64 v5, 0 v_cvt_f16_i16_e64 v5, 0
// CHECK: [0x05,0x00,0x7a,0xd1,0x80,0x00,0x00,0x00] // CHECK: [0x05,0x00,0x7a,0xd1,0x80,0x00,0x00,0x00]
v_cvt_f16_i16_e64 v5, -1 v_cvt_f16_i16_e64 v5, -1
// CHECK: [0x05,0x00,0x7a,0xd1,0xc1,0x00,0x00,0x00] // CHECK: [0x05,0x00,0x7a,0xd1,0xc1,0x00,0x00,0x00]
v_cvt_f16_i16_e64 v5, 0.5 v_cvt_f16_i16_e64 v5, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cvt_f16_i16_e64 v5, -4.0 v_cvt_f16_i16_e64 v5, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cvt_f16_i16_e64 v5, v1 clamp v_cvt_f16_i16_e64 v5, v1 clamp
// CHECK: [0x05,0x80,0x7a,0xd1,0x01,0x01,0x00,0x00] // CHECK: [0x05,0x80,0x7a,0xd1,0x01,0x01,0x00,0x00]
v_cvt_u16_f16 v5, v1 v_cvt_u16_f16 v5, v1
// CHECK: [0x01,0x77,0x0a,0x7e] // CHECK: [0x01,0x77,0x0a,0x7e]
v_cvt_u16_f16 v255, v1 v_cvt_u16_f16 v255, v1
▲ Show 20 Lines • Show All 9,328 Lines • ▼ Show 20 Lines
v_add_u16_e64 v5, 0, v2 v_add_u16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x26,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x26,0xd1,0x80,0x04,0x02,0x00]
v_add_u16_e64 v5, -1, v2 v_add_u16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x26,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x26,0xd1,0xc1,0x04,0x02,0x00]
v_add_u16_e64 v5, 0.5, v2 v_add_u16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_add_u16_e64 v5, -4.0, v2 v_add_u16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_add_u16_e64 v5, v1, v255 v_add_u16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x26,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x26,0xd1,0x01,0xff,0x03,0x00]
v_add_u16_e64 v5, v1, s2 v_add_u16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x26,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x26,0xd1,0x01,0x05,0x00,0x00]
v_add_u16_e64 v5, v1, s101 v_add_u16_e64 v5, v1, s101
Show All 37 Lines
v_add_u16_e64 v5, v1, 0 v_add_u16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x26,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x26,0xd1,0x01,0x01,0x01,0x00]
v_add_u16_e64 v5, v1, -1 v_add_u16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x26,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x26,0xd1,0x01,0x83,0x01,0x00]
v_add_u16_e64 v5, v1, 0.5 v_add_u16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_add_u16_e64 v5, v1, -4.0 v_add_u16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_sub_u16 v5, v1, v2 v_sub_u16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x4e] // CHECK: [0x01,0x05,0x0a,0x4e]
v_sub_u16 v255, v1, v2 v_sub_u16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x4f] // CHECK: [0x01,0x05,0xfe,0x4f]
v_sub_u16 v5, v255, v2 v_sub_u16 v5, v255, v2
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
v_sub_u16_e64 v5, 0, v2 v_sub_u16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x27,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x27,0xd1,0x80,0x04,0x02,0x00]
v_sub_u16_e64 v5, -1, v2 v_sub_u16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x27,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x27,0xd1,0xc1,0x04,0x02,0x00]
v_sub_u16_e64 v5, 0.5, v2 v_sub_u16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_sub_u16_e64 v5, -4.0, v2 v_sub_u16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_sub_u16_e64 v5, v1, v255 v_sub_u16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x27,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x27,0xd1,0x01,0xff,0x03,0x00]
v_sub_u16_e64 v5, v1, s2 v_sub_u16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x27,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x27,0xd1,0x01,0x05,0x00,0x00]
v_sub_u16_e64 v5, v1, s101 v_sub_u16_e64 v5, v1, s101
Show All 37 Lines
v_sub_u16_e64 v5, v1, 0 v_sub_u16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x27,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x27,0xd1,0x01,0x01,0x01,0x00]
v_sub_u16_e64 v5, v1, -1 v_sub_u16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x27,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x27,0xd1,0x01,0x83,0x01,0x00]
v_sub_u16_e64 v5, v1, 0.5 v_sub_u16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_sub_u16_e64 v5, v1, -4.0 v_sub_u16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_subrev_u16 v5, v1, v2 v_subrev_u16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x50] // CHECK: [0x01,0x05,0x0a,0x50]
v_subrev_u16 v255, v1, v2 v_subrev_u16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x51] // CHECK: [0x01,0x05,0xfe,0x51]
v_subrev_u16 v5, v255, v2 v_subrev_u16 v5, v255, v2
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
v_subrev_u16_e64 v5, 0, v2 v_subrev_u16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x28,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x28,0xd1,0x80,0x04,0x02,0x00]
v_subrev_u16_e64 v5, -1, v2 v_subrev_u16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x28,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x28,0xd1,0xc1,0x04,0x02,0x00]
v_subrev_u16_e64 v5, 0.5, v2 v_subrev_u16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_subrev_u16_e64 v5, -4.0, v2 v_subrev_u16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_subrev_u16_e64 v5, v1, v255 v_subrev_u16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x28,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x28,0xd1,0x01,0xff,0x03,0x00]
v_subrev_u16_e64 v5, v1, s2 v_subrev_u16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x28,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x28,0xd1,0x01,0x05,0x00,0x00]
v_subrev_u16_e64 v5, v1, s101 v_subrev_u16_e64 v5, v1, s101
Show All 37 Lines
v_subrev_u16_e64 v5, v1, 0 v_subrev_u16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x28,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x28,0xd1,0x01,0x01,0x01,0x00]
v_subrev_u16_e64 v5, v1, -1 v_subrev_u16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x28,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x28,0xd1,0x01,0x83,0x01,0x00]
v_subrev_u16_e64 v5, v1, 0.5 v_subrev_u16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_subrev_u16_e64 v5, v1, -4.0 v_subrev_u16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mul_lo_u16 v5, v1, v2 v_mul_lo_u16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x52] // CHECK: [0x01,0x05,0x0a,0x52]
v_mul_lo_u16 v255, v1, v2 v_mul_lo_u16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x53] // CHECK: [0x01,0x05,0xfe,0x53]
v_mul_lo_u16 v5, v255, v2 v_mul_lo_u16 v5, v255, v2
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
v_mul_lo_u16_e64 v5, 0, v2 v_mul_lo_u16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x29,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x29,0xd1,0x80,0x04,0x02,0x00]
v_mul_lo_u16_e64 v5, -1, v2 v_mul_lo_u16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x29,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x29,0xd1,0xc1,0x04,0x02,0x00]
v_mul_lo_u16_e64 v5, 0.5, v2 v_mul_lo_u16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mul_lo_u16_e64 v5, -4.0, v2 v_mul_lo_u16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mul_lo_u16_e64 v5, v1, v255 v_mul_lo_u16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x29,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x29,0xd1,0x01,0xff,0x03,0x00]
v_mul_lo_u16_e64 v5, v1, s2 v_mul_lo_u16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x29,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x29,0xd1,0x01,0x05,0x00,0x00]
v_mul_lo_u16_e64 v5, v1, s101 v_mul_lo_u16_e64 v5, v1, s101
Show All 37 Lines
v_mul_lo_u16_e64 v5, v1, 0 v_mul_lo_u16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x29,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x29,0xd1,0x01,0x01,0x01,0x00]
v_mul_lo_u16_e64 v5, v1, -1 v_mul_lo_u16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x29,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x29,0xd1,0x01,0x83,0x01,0x00]
v_mul_lo_u16_e64 v5, v1, 0.5 v_mul_lo_u16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mul_lo_u16_e64 v5, v1, -4.0 v_mul_lo_u16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshlrev_b16 v5, v1, v2 v_lshlrev_b16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x54] // CHECK: [0x01,0x05,0x0a,0x54]
v_lshlrev_b16 v255, v1, v2 v_lshlrev_b16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x55] // CHECK: [0x01,0x05,0xfe,0x55]
v_lshlrev_b16 v5, v255, v2 v_lshlrev_b16 v5, v255, v2
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
v_lshlrev_b16_e64 v5, 0, v2 v_lshlrev_b16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x2a,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2a,0xd1,0x80,0x04,0x02,0x00]
v_lshlrev_b16_e64 v5, -1, v2 v_lshlrev_b16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x2a,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2a,0xd1,0xc1,0x04,0x02,0x00]
v_lshlrev_b16_e64 v5, 0.5, v2 v_lshlrev_b16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshlrev_b16_e64 v5, -4.0, v2 v_lshlrev_b16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshlrev_b16_e64 v5, v1, v255 v_lshlrev_b16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x2a,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0xff,0x03,0x00]
v_lshlrev_b16_e64 v5, v1, s2 v_lshlrev_b16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x05,0x00,0x00]
v_lshlrev_b16_e64 v5, v1, s101 v_lshlrev_b16_e64 v5, v1, s101
Show All 37 Lines
v_lshlrev_b16_e64 v5, v1, 0 v_lshlrev_b16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x01,0x01,0x00]
v_lshlrev_b16_e64 v5, v1, -1 v_lshlrev_b16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x83,0x01,0x00]
v_lshlrev_b16_e64 v5, v1, 0.5 v_lshlrev_b16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshlrev_b16_e64 v5, v1, -4.0 v_lshlrev_b16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshrrev_b16 v5, v1, v2 v_lshrrev_b16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x56] // CHECK: [0x01,0x05,0x0a,0x56]
v_lshrrev_b16 v255, v1, v2 v_lshrrev_b16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x57] // CHECK: [0x01,0x05,0xfe,0x57]
v_lshrrev_b16 v5, v255, v2 v_lshrrev_b16 v5, v255, v2
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
v_lshrrev_b16_e64 v5, 0, v2 v_lshrrev_b16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x2b,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2b,0xd1,0x80,0x04,0x02,0x00]
v_lshrrev_b16_e64 v5, -1, v2 v_lshrrev_b16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x2b,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2b,0xd1,0xc1,0x04,0x02,0x00]
v_lshrrev_b16_e64 v5, 0.5, v2 v_lshrrev_b16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshrrev_b16_e64 v5, -4.0, v2 v_lshrrev_b16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshrrev_b16_e64 v5, v1, v255 v_lshrrev_b16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x2b,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0xff,0x03,0x00]
v_lshrrev_b16_e64 v5, v1, s2 v_lshrrev_b16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x05,0x00,0x00]
v_lshrrev_b16_e64 v5, v1, s101 v_lshrrev_b16_e64 v5, v1, s101
Show All 37 Lines
v_lshrrev_b16_e64 v5, v1, 0 v_lshrrev_b16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x01,0x01,0x00]
v_lshrrev_b16_e64 v5, v1, -1 v_lshrrev_b16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x83,0x01,0x00]
v_lshrrev_b16_e64 v5, v1, 0.5 v_lshrrev_b16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshrrev_b16_e64 v5, v1, -4.0 v_lshrrev_b16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_ashrrev_i16 v5, v1, v2 v_ashrrev_i16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x58] // CHECK: [0x01,0x05,0x0a,0x58]
v_ashrrev_i16 v255, v1, v2 v_ashrrev_i16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x59] // CHECK: [0x01,0x05,0xfe,0x59]
v_ashrrev_i16 v5, v255, v2 v_ashrrev_i16 v5, v255, v2
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
v_ashrrev_i16_e64 v5, 0, v2 v_ashrrev_i16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x2c,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2c,0xd1,0x80,0x04,0x02,0x00]
v_ashrrev_i16_e64 v5, -1, v2 v_ashrrev_i16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x2c,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2c,0xd1,0xc1,0x04,0x02,0x00]
v_ashrrev_i16_e64 v5, 0.5, v2 v_ashrrev_i16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_ashrrev_i16_e64 v5, -4.0, v2 v_ashrrev_i16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_ashrrev_i16_e64 v5, v1, v255 v_ashrrev_i16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x2c,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0xff,0x03,0x00]
v_ashrrev_i16_e64 v5, v1, s2 v_ashrrev_i16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x05,0x00,0x00]
v_ashrrev_i16_e64 v5, v1, s101 v_ashrrev_i16_e64 v5, v1, s101
Show All 37 Lines
v_ashrrev_i16_e64 v5, v1, 0 v_ashrrev_i16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x01,0x01,0x00]
v_ashrrev_i16_e64 v5, v1, -1 v_ashrrev_i16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x83,0x01,0x00]
v_ashrrev_i16_e64 v5, v1, 0.5 v_ashrrev_i16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_ashrrev_i16_e64 v5, v1, -4.0 v_ashrrev_i16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_f16 v5, v1, v2 v_max_f16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x5a] // CHECK: [0x01,0x05,0x0a,0x5a]
v_max_f16 v255, v1, v2 v_max_f16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x5b] // CHECK: [0x01,0x05,0xfe,0x5b]
v_max_f16 v5, v255, v2 v_max_f16 v5, v255, v2
▲ Show 20 Lines • Show All 541 Lines • ▼ Show 20 Lines
v_max_u16_e64 v5, 0, v2 v_max_u16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x2f,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2f,0xd1,0x80,0x04,0x02,0x00]
v_max_u16_e64 v5, -1, v2 v_max_u16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x2f,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2f,0xd1,0xc1,0x04,0x02,0x00]
v_max_u16_e64 v5, 0.5, v2 v_max_u16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_u16_e64 v5, -4.0, v2 v_max_u16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_u16_e64 v5, v1, v255 v_max_u16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x2f,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0xff,0x03,0x00]
v_max_u16_e64 v5, v1, s2 v_max_u16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x05,0x00,0x00]
v_max_u16_e64 v5, v1, s101 v_max_u16_e64 v5, v1, s101
Show All 37 Lines
v_max_u16_e64 v5, v1, 0 v_max_u16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x01,0x01,0x00]
v_max_u16_e64 v5, v1, -1 v_max_u16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x83,0x01,0x00]
v_max_u16_e64 v5, v1, 0.5 v_max_u16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_u16_e64 v5, v1, -4.0 v_max_u16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_i16 v5, v1, v2 v_max_i16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x60] // CHECK: [0x01,0x05,0x0a,0x60]
v_max_i16 v255, v1, v2 v_max_i16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x61] // CHECK: [0x01,0x05,0xfe,0x61]
v_max_i16 v5, v255, v2 v_max_i16 v5, v255, v2
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
v_max_i16_e64 v5, 0, v2 v_max_i16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x30,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x30,0xd1,0x80,0x04,0x02,0x00]
v_max_i16_e64 v5, -1, v2 v_max_i16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x30,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x30,0xd1,0xc1,0x04,0x02,0x00]
v_max_i16_e64 v5, 0.5, v2 v_max_i16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_i16_e64 v5, -4.0, v2 v_max_i16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_i16_e64 v5, v1, v255 v_max_i16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x30,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x30,0xd1,0x01,0xff,0x03,0x00]
v_max_i16_e64 v5, v1, s2 v_max_i16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x30,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x30,0xd1,0x01,0x05,0x00,0x00]
v_max_i16_e64 v5, v1, s101 v_max_i16_e64 v5, v1, s101
Show All 37 Lines
v_max_i16_e64 v5, v1, 0 v_max_i16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x30,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x30,0xd1,0x01,0x01,0x01,0x00]
v_max_i16_e64 v5, v1, -1 v_max_i16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x30,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x30,0xd1,0x01,0x83,0x01,0x00]
v_max_i16_e64 v5, v1, 0.5 v_max_i16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_i16_e64 v5, v1, -4.0 v_max_i16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_u16 v5, v1, v2 v_min_u16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x62] // CHECK: [0x01,0x05,0x0a,0x62]
v_min_u16 v255, v1, v2 v_min_u16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x63] // CHECK: [0x01,0x05,0xfe,0x63]
v_min_u16 v5, v255, v2 v_min_u16 v5, v255, v2
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
v_min_u16_e64 v5, 0, v2 v_min_u16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x31,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x31,0xd1,0x80,0x04,0x02,0x00]
v_min_u16_e64 v5, -1, v2 v_min_u16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x31,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x31,0xd1,0xc1,0x04,0x02,0x00]
v_min_u16_e64 v5, 0.5, v2 v_min_u16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_u16_e64 v5, -4.0, v2 v_min_u16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_u16_e64 v5, v1, v255 v_min_u16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x31,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x31,0xd1,0x01,0xff,0x03,0x00]
v_min_u16_e64 v5, v1, s2 v_min_u16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x31,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x31,0xd1,0x01,0x05,0x00,0x00]
v_min_u16_e64 v5, v1, s101 v_min_u16_e64 v5, v1, s101
Show All 37 Lines
v_min_u16_e64 v5, v1, 0 v_min_u16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x31,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x31,0xd1,0x01,0x01,0x01,0x00]
v_min_u16_e64 v5, v1, -1 v_min_u16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x31,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x31,0xd1,0x01,0x83,0x01,0x00]
v_min_u16_e64 v5, v1, 0.5 v_min_u16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_u16_e64 v5, v1, -4.0 v_min_u16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_i16 v5, v1, v2 v_min_i16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x64] // CHECK: [0x01,0x05,0x0a,0x64]
v_min_i16 v255, v1, v2 v_min_i16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x65] // CHECK: [0x01,0x05,0xfe,0x65]
v_min_i16 v5, v255, v2 v_min_i16 v5, v255, v2
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
v_min_i16_e64 v5, 0, v2 v_min_i16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x32,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x32,0xd1,0x80,0x04,0x02,0x00]
v_min_i16_e64 v5, -1, v2 v_min_i16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x32,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x32,0xd1,0xc1,0x04,0x02,0x00]
v_min_i16_e64 v5, 0.5, v2 v_min_i16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_i16_e64 v5, -4.0, v2 v_min_i16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_i16_e64 v5, v1, v255 v_min_i16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x32,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x32,0xd1,0x01,0xff,0x03,0x00]
v_min_i16_e64 v5, v1, s2 v_min_i16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x32,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x32,0xd1,0x01,0x05,0x00,0x00]
v_min_i16_e64 v5, v1, s101 v_min_i16_e64 v5, v1, s101
Show All 37 Lines
v_min_i16_e64 v5, v1, 0 v_min_i16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x32,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x32,0xd1,0x01,0x01,0x01,0x00]
v_min_i16_e64 v5, v1, -1 v_min_i16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x32,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x32,0xd1,0x01,0x83,0x01,0x00]
v_min_i16_e64 v5, v1, 0.5 v_min_i16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_i16_e64 v5, v1, -4.0 v_min_i16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_ldexp_f16 v5, v1, v2 v_ldexp_f16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x66] // CHECK: [0x01,0x05,0x0a,0x66]
v_ldexp_f16 v255, v1, v2 v_ldexp_f16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x67] // CHECK: [0x01,0x05,0xfe,0x67]
v_ldexp_f16 v5, v255, v2 v_ldexp_f16 v5, v255, v2
▲ Show 20 Lines • Show All 7,957 Lines • ▼ Show 20 Lines
v_mad_u16 v5, 0, v2, v3 v_mad_u16 v5, 0, v2, v3
// CHECK: [0x05,0x00,0xeb,0xd1,0x80,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xeb,0xd1,0x80,0x04,0x0e,0x04]
v_mad_u16 v5, -1, v2, v3 v_mad_u16 v5, -1, v2, v3
// CHECK: [0x05,0x00,0xeb,0xd1,0xc1,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xeb,0xd1,0xc1,0x04,0x0e,0x04]
v_mad_u16 v5, 0.5, v2, v3 v_mad_u16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u16 v5, -4.0, v2, v3 v_mad_u16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u16 v5, v1, v255, v3 v_mad_u16 v5, v1, v255, v3
// CHECK: [0x05,0x00,0xeb,0xd1,0x01,0xff,0x0f,0x04] // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0xff,0x0f,0x04]
v_mad_u16 v5, v1, s2, v3 v_mad_u16 v5, v1, s2, v3
// CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0x0c,0x04] // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0x0c,0x04]
v_mad_u16 v5, v1, s101, v3 v_mad_u16 v5, v1, s101, v3
Show All 37 Lines
v_mad_u16 v5, v1, 0, v3 v_mad_u16 v5, v1, 0, v3
// CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x01,0x0d,0x04] // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x01,0x0d,0x04]
v_mad_u16 v5, v1, -1, v3 v_mad_u16 v5, v1, -1, v3
// CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x83,0x0d,0x04] // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x83,0x0d,0x04]
v_mad_u16 v5, v1, 0.5, v3 v_mad_u16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u16 v5, v1, -4.0, v3 v_mad_u16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u16 v5, v1, v2, v255 v_mad_u16 v5, v1, v2, v255
// CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0xfe,0x07] // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0xfe,0x07]
v_mad_u16 v5, v1, v2, s3 v_mad_u16 v5, v1, v2, s3
// CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0x0e,0x00] // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0x0e,0x00]
v_mad_u16 v5, v1, v2, s101 v_mad_u16 v5, v1, v2, s101
Show All 37 Lines
v_mad_u16 v5, v1, v2, 0 v_mad_u16 v5, v1, v2, 0
// CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0x02,0x02] // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0x02,0x02]
v_mad_u16 v5, v1, v2, -1 v_mad_u16 v5, v1, v2, -1
// CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0x06,0x03] // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0x06,0x03]
v_mad_u16 v5, v1, v2, 0.5 v_mad_u16 v5, v1, v2, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u16 v5, v1, v2, -4.0 v_mad_u16 v5, v1, v2, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u16 v5, v1, v2, v3 clamp v_mad_u16 v5, v1, v2, v3 clamp
// CHECK: [0x05,0x80,0xeb,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x80,0xeb,0xd1,0x01,0x05,0x0e,0x04]
v_mad_i16 v5, v1, v2, v3 v_mad_i16 v5, v1, v2, v3
// CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x0e,0x04]
v_mad_i16 v255, v1, v2, v3 v_mad_i16 v255, v1, v2, v3
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
v_mad_i16 v5, 0, v2, v3 v_mad_i16 v5, 0, v2, v3
// CHECK: [0x05,0x00,0xec,0xd1,0x80,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xec,0xd1,0x80,0x04,0x0e,0x04]
v_mad_i16 v5, -1, v2, v3 v_mad_i16 v5, -1, v2, v3
// CHECK: [0x05,0x00,0xec,0xd1,0xc1,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xec,0xd1,0xc1,0x04,0x0e,0x04]
v_mad_i16 v5, 0.5, v2, v3 v_mad_i16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i16 v5, -4.0, v2, v3 v_mad_i16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i16 v5, v1, v255, v3 v_mad_i16 v5, v1, v255, v3
// CHECK: [0x05,0x00,0xec,0xd1,0x01,0xff,0x0f,0x04] // CHECK: [0x05,0x00,0xec,0xd1,0x01,0xff,0x0f,0x04]
v_mad_i16 v5, v1, s2, v3 v_mad_i16 v5, v1, s2, v3
// CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x0c,0x04] // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x0c,0x04]
v_mad_i16 v5, v1, s101, v3 v_mad_i16 v5, v1, s101, v3
Show All 37 Lines
v_mad_i16 v5, v1, 0, v3 v_mad_i16 v5, v1, 0, v3
// CHECK: [0x05,0x00,0xec,0xd1,0x01,0x01,0x0d,0x04] // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x01,0x0d,0x04]
v_mad_i16 v5, v1, -1, v3 v_mad_i16 v5, v1, -1, v3
// CHECK: [0x05,0x00,0xec,0xd1,0x01,0x83,0x0d,0x04] // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x83,0x0d,0x04]
v_mad_i16 v5, v1, 0.5, v3 v_mad_i16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i16 v5, v1, -4.0, v3 v_mad_i16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i16 v5, v1, v2, v255 v_mad_i16 v5, v1, v2, v255
// CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0xfe,0x07] // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0xfe,0x07]
v_mad_i16 v5, v1, v2, s3 v_mad_i16 v5, v1, v2, s3
// CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x0e,0x00] // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x0e,0x00]
v_mad_i16 v5, v1, v2, s101 v_mad_i16 v5, v1, v2, s101
Show All 37 Lines
v_mad_i16 v5, v1, v2, 0 v_mad_i16 v5, v1, v2, 0
// CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x02,0x02] // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x02,0x02]
v_mad_i16 v5, v1, v2, -1 v_mad_i16 v5, v1, v2, -1
// CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x06,0x03] // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x06,0x03]
v_mad_i16 v5, v1, v2, 0.5 v_mad_i16 v5, v1, v2, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i16 v5, v1, v2, -4.0 v_mad_i16 v5, v1, v2, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i16 v5, v1, v2, v3 clamp v_mad_i16 v5, v1, v2, v3 clamp
// CHECK: [0x05,0x80,0xec,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x80,0xec,0xd1,0x01,0x05,0x0e,0x04]
v_perm_b32 v5, v1, v2, v3 v_perm_b32 v5, v1, v2, v3
// CHECK: [0x05,0x00,0xed,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x00,0xed,0xd1,0x01,0x05,0x0e,0x04]
v_perm_b32 v255, v1, v2, v3 v_perm_b32 v255, v1, v2, v3
▲ Show 20 Lines • Show All 24,571 Lines • ▼ Show 20 Lines
v_cmp_f_i16_e64 s[10:11], 0, v2 v_cmp_f_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa0,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa0,0xd0,0x80,0x04,0x02,0x00]
v_cmp_f_i16_e64 s[10:11], -1, v2 v_cmp_f_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa0,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa0,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_f_i16_e64 s[10:11], 0.5, v2 v_cmp_f_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_i16_e64 s[10:11], -4.0, v2 v_cmp_f_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_i16_e64 s[10:11], v1, v255 v_cmp_f_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0xff,0x03,0x00]
v_cmp_f_i16_e64 s[10:11], v1, s2 v_cmp_f_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x05,0x00,0x00]
v_cmp_f_i16_e64 s[10:11], v1, s101 v_cmp_f_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_f_i16_e64 s[10:11], v1, 0 v_cmp_f_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x01,0x01,0x00]
v_cmp_f_i16_e64 s[10:11], v1, -1 v_cmp_f_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x83,0x01,0x00]
v_cmp_f_i16_e64 s[10:11], v1, 0.5 v_cmp_f_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_i16_e64 s[10:11], v1, -4.0 v_cmp_f_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_i16 vcc, v1, v2 v_cmp_lt_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x42,0x7d] // CHECK: [0x01,0x05,0x42,0x7d]
v_cmp_lt_i16 vcc, v255, v2 v_cmp_lt_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x42,0x7d] // CHECK: [0xff,0x05,0x42,0x7d]
v_cmp_lt_i16 vcc, s1, v2 v_cmp_lt_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_lt_i16_e64 s[10:11], 0, v2 v_cmp_lt_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa1,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa1,0xd0,0x80,0x04,0x02,0x00]
v_cmp_lt_i16_e64 s[10:11], -1, v2 v_cmp_lt_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa1,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa1,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_lt_i16_e64 s[10:11], 0.5, v2 v_cmp_lt_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_i16_e64 s[10:11], -4.0, v2 v_cmp_lt_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_i16_e64 s[10:11], v1, v255 v_cmp_lt_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0xff,0x03,0x00]
v_cmp_lt_i16_e64 s[10:11], v1, s2 v_cmp_lt_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x05,0x00,0x00]
v_cmp_lt_i16_e64 s[10:11], v1, s101 v_cmp_lt_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_lt_i16_e64 s[10:11], v1, 0 v_cmp_lt_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x01,0x01,0x00]
v_cmp_lt_i16_e64 s[10:11], v1, -1 v_cmp_lt_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x83,0x01,0x00]
v_cmp_lt_i16_e64 s[10:11], v1, 0.5 v_cmp_lt_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_i16_e64 s[10:11], v1, -4.0 v_cmp_lt_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_i16 vcc, v1, v2 v_cmp_eq_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x44,0x7d] // CHECK: [0x01,0x05,0x44,0x7d]
v_cmp_eq_i16 vcc, v255, v2 v_cmp_eq_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x44,0x7d] // CHECK: [0xff,0x05,0x44,0x7d]
v_cmp_eq_i16 vcc, s1, v2 v_cmp_eq_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_eq_i16_e64 s[10:11], 0, v2 v_cmp_eq_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa2,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa2,0xd0,0x80,0x04,0x02,0x00]
v_cmp_eq_i16_e64 s[10:11], -1, v2 v_cmp_eq_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa2,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa2,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_eq_i16_e64 s[10:11], 0.5, v2 v_cmp_eq_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_i16_e64 s[10:11], -4.0, v2 v_cmp_eq_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_i16_e64 s[10:11], v1, v255 v_cmp_eq_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0xff,0x03,0x00]
v_cmp_eq_i16_e64 s[10:11], v1, s2 v_cmp_eq_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x05,0x00,0x00]
v_cmp_eq_i16_e64 s[10:11], v1, s101 v_cmp_eq_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_eq_i16_e64 s[10:11], v1, 0 v_cmp_eq_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x01,0x01,0x00]
v_cmp_eq_i16_e64 s[10:11], v1, -1 v_cmp_eq_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x83,0x01,0x00]
v_cmp_eq_i16_e64 s[10:11], v1, 0.5 v_cmp_eq_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_i16_e64 s[10:11], v1, -4.0 v_cmp_eq_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_i16 vcc, v1, v2 v_cmp_le_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x46,0x7d] // CHECK: [0x01,0x05,0x46,0x7d]
v_cmp_le_i16 vcc, v255, v2 v_cmp_le_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x46,0x7d] // CHECK: [0xff,0x05,0x46,0x7d]
v_cmp_le_i16 vcc, s1, v2 v_cmp_le_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_le_i16_e64 s[10:11], 0, v2 v_cmp_le_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa3,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa3,0xd0,0x80,0x04,0x02,0x00]
v_cmp_le_i16_e64 s[10:11], -1, v2 v_cmp_le_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa3,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa3,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_le_i16_e64 s[10:11], 0.5, v2 v_cmp_le_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_i16_e64 s[10:11], -4.0, v2 v_cmp_le_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_i16_e64 s[10:11], v1, v255 v_cmp_le_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0xff,0x03,0x00]
v_cmp_le_i16_e64 s[10:11], v1, s2 v_cmp_le_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x05,0x00,0x00]
v_cmp_le_i16_e64 s[10:11], v1, s101 v_cmp_le_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_le_i16_e64 s[10:11], v1, 0 v_cmp_le_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x01,0x01,0x00]
v_cmp_le_i16_e64 s[10:11], v1, -1 v_cmp_le_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x83,0x01,0x00]
v_cmp_le_i16_e64 s[10:11], v1, 0.5 v_cmp_le_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_i16_e64 s[10:11], v1, -4.0 v_cmp_le_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_i16 vcc, v1, v2 v_cmp_gt_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x48,0x7d] // CHECK: [0x01,0x05,0x48,0x7d]
v_cmp_gt_i16 vcc, v255, v2 v_cmp_gt_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x48,0x7d] // CHECK: [0xff,0x05,0x48,0x7d]
v_cmp_gt_i16 vcc, s1, v2 v_cmp_gt_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_gt_i16_e64 s[10:11], 0, v2 v_cmp_gt_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa4,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa4,0xd0,0x80,0x04,0x02,0x00]
v_cmp_gt_i16_e64 s[10:11], -1, v2 v_cmp_gt_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa4,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa4,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_gt_i16_e64 s[10:11], 0.5, v2 v_cmp_gt_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_i16_e64 s[10:11], -4.0, v2 v_cmp_gt_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_i16_e64 s[10:11], v1, v255 v_cmp_gt_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0xff,0x03,0x00]
v_cmp_gt_i16_e64 s[10:11], v1, s2 v_cmp_gt_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x05,0x00,0x00]
v_cmp_gt_i16_e64 s[10:11], v1, s101 v_cmp_gt_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_gt_i16_e64 s[10:11], v1, 0 v_cmp_gt_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x01,0x01,0x00]
v_cmp_gt_i16_e64 s[10:11], v1, -1 v_cmp_gt_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x83,0x01,0x00]
v_cmp_gt_i16_e64 s[10:11], v1, 0.5 v_cmp_gt_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_i16_e64 s[10:11], v1, -4.0 v_cmp_gt_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_i16 vcc, v1, v2 v_cmp_ne_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x4a,0x7d] // CHECK: [0x01,0x05,0x4a,0x7d]
v_cmp_ne_i16 vcc, v255, v2 v_cmp_ne_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x4a,0x7d] // CHECK: [0xff,0x05,0x4a,0x7d]
v_cmp_ne_i16 vcc, s1, v2 v_cmp_ne_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_ne_i16_e64 s[10:11], 0, v2 v_cmp_ne_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa5,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa5,0xd0,0x80,0x04,0x02,0x00]
v_cmp_ne_i16_e64 s[10:11], -1, v2 v_cmp_ne_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa5,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa5,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_ne_i16_e64 s[10:11], 0.5, v2 v_cmp_ne_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_i16_e64 s[10:11], -4.0, v2 v_cmp_ne_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_i16_e64 s[10:11], v1, v255 v_cmp_ne_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0xff,0x03,0x00]
v_cmp_ne_i16_e64 s[10:11], v1, s2 v_cmp_ne_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x05,0x00,0x00]
v_cmp_ne_i16_e64 s[10:11], v1, s101 v_cmp_ne_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_ne_i16_e64 s[10:11], v1, 0 v_cmp_ne_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x01,0x01,0x00]
v_cmp_ne_i16_e64 s[10:11], v1, -1 v_cmp_ne_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x83,0x01,0x00]
v_cmp_ne_i16_e64 s[10:11], v1, 0.5 v_cmp_ne_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_i16_e64 s[10:11], v1, -4.0 v_cmp_ne_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_i16 vcc, v1, v2 v_cmp_ge_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x4c,0x7d] // CHECK: [0x01,0x05,0x4c,0x7d]
v_cmp_ge_i16 vcc, v255, v2 v_cmp_ge_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x4c,0x7d] // CHECK: [0xff,0x05,0x4c,0x7d]
v_cmp_ge_i16 vcc, s1, v2 v_cmp_ge_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_ge_i16_e64 s[10:11], 0, v2 v_cmp_ge_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa6,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa6,0xd0,0x80,0x04,0x02,0x00]
v_cmp_ge_i16_e64 s[10:11], -1, v2 v_cmp_ge_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa6,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa6,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_ge_i16_e64 s[10:11], 0.5, v2 v_cmp_ge_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_i16_e64 s[10:11], -4.0, v2 v_cmp_ge_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_i16_e64 s[10:11], v1, v255 v_cmp_ge_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0xff,0x03,0x00]
v_cmp_ge_i16_e64 s[10:11], v1, s2 v_cmp_ge_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x05,0x00,0x00]
v_cmp_ge_i16_e64 s[10:11], v1, s101 v_cmp_ge_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_ge_i16_e64 s[10:11], v1, 0 v_cmp_ge_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x01,0x01,0x00]
v_cmp_ge_i16_e64 s[10:11], v1, -1 v_cmp_ge_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x83,0x01,0x00]
v_cmp_ge_i16_e64 s[10:11], v1, 0.5 v_cmp_ge_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_i16_e64 s[10:11], v1, -4.0 v_cmp_ge_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_i16 vcc, v1, v2 v_cmp_t_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x4e,0x7d] // CHECK: [0x01,0x05,0x4e,0x7d]
v_cmp_t_i16 vcc, v255, v2 v_cmp_t_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x4e,0x7d] // CHECK: [0xff,0x05,0x4e,0x7d]
v_cmp_t_i16 vcc, s1, v2 v_cmp_t_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_t_i16_e64 s[10:11], 0, v2 v_cmp_t_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa7,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa7,0xd0,0x80,0x04,0x02,0x00]
v_cmp_t_i16_e64 s[10:11], -1, v2 v_cmp_t_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa7,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa7,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_t_i16_e64 s[10:11], 0.5, v2 v_cmp_t_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_i16_e64 s[10:11], -4.0, v2 v_cmp_t_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_i16_e64 s[10:11], v1, v255 v_cmp_t_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0xff,0x03,0x00]
v_cmp_t_i16_e64 s[10:11], v1, s2 v_cmp_t_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x05,0x00,0x00]
v_cmp_t_i16_e64 s[10:11], v1, s101 v_cmp_t_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_t_i16_e64 s[10:11], v1, 0 v_cmp_t_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x01,0x01,0x00]
v_cmp_t_i16_e64 s[10:11], v1, -1 v_cmp_t_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x83,0x01,0x00]
v_cmp_t_i16_e64 s[10:11], v1, 0.5 v_cmp_t_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_i16_e64 s[10:11], v1, -4.0 v_cmp_t_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_u16 vcc, v1, v2 v_cmp_f_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x50,0x7d] // CHECK: [0x01,0x05,0x50,0x7d]
v_cmp_f_u16 vcc, v255, v2 v_cmp_f_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x50,0x7d] // CHECK: [0xff,0x05,0x50,0x7d]
v_cmp_f_u16 vcc, s1, v2 v_cmp_f_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_f_u16_e64 s[10:11], 0, v2 v_cmp_f_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa8,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa8,0xd0,0x80,0x04,0x02,0x00]
v_cmp_f_u16_e64 s[10:11], -1, v2 v_cmp_f_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa8,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa8,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_f_u16_e64 s[10:11], 0.5, v2 v_cmp_f_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_u16_e64 s[10:11], -4.0, v2 v_cmp_f_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_u16_e64 s[10:11], v1, v255 v_cmp_f_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0xff,0x03,0x00]
v_cmp_f_u16_e64 s[10:11], v1, s2 v_cmp_f_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x05,0x00,0x00]
v_cmp_f_u16_e64 s[10:11], v1, s101 v_cmp_f_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_f_u16_e64 s[10:11], v1, 0 v_cmp_f_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x01,0x01,0x00]
v_cmp_f_u16_e64 s[10:11], v1, -1 v_cmp_f_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x83,0x01,0x00]
v_cmp_f_u16_e64 s[10:11], v1, 0.5 v_cmp_f_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_u16_e64 s[10:11], v1, -4.0 v_cmp_f_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_u16 vcc, v1, v2 v_cmp_lt_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x52,0x7d] // CHECK: [0x01,0x05,0x52,0x7d]
v_cmp_lt_u16 vcc, v255, v2 v_cmp_lt_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x52,0x7d] // CHECK: [0xff,0x05,0x52,0x7d]
v_cmp_lt_u16 vcc, s1, v2 v_cmp_lt_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_lt_u16_e64 s[10:11], 0, v2 v_cmp_lt_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa9,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa9,0xd0,0x80,0x04,0x02,0x00]
v_cmp_lt_u16_e64 s[10:11], -1, v2 v_cmp_lt_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa9,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa9,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_lt_u16_e64 s[10:11], 0.5, v2 v_cmp_lt_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_u16_e64 s[10:11], -4.0, v2 v_cmp_lt_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_u16_e64 s[10:11], v1, v255 v_cmp_lt_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0xff,0x03,0x00]
v_cmp_lt_u16_e64 s[10:11], v1, s2 v_cmp_lt_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x05,0x00,0x00]
v_cmp_lt_u16_e64 s[10:11], v1, s101 v_cmp_lt_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_lt_u16_e64 s[10:11], v1, 0 v_cmp_lt_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x01,0x01,0x00]
v_cmp_lt_u16_e64 s[10:11], v1, -1 v_cmp_lt_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x83,0x01,0x00]
v_cmp_lt_u16_e64 s[10:11], v1, 0.5 v_cmp_lt_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_u16_e64 s[10:11], v1, -4.0 v_cmp_lt_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_u16 vcc, v1, v2 v_cmp_eq_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x54,0x7d] // CHECK: [0x01,0x05,0x54,0x7d]
v_cmp_eq_u16 vcc, v255, v2 v_cmp_eq_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x54,0x7d] // CHECK: [0xff,0x05,0x54,0x7d]
v_cmp_eq_u16 vcc, s1, v2 v_cmp_eq_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_eq_u16_e64 s[10:11], 0, v2 v_cmp_eq_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xaa,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xaa,0xd0,0x80,0x04,0x02,0x00]
v_cmp_eq_u16_e64 s[10:11], -1, v2 v_cmp_eq_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xaa,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xaa,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_eq_u16_e64 s[10:11], 0.5, v2 v_cmp_eq_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_u16_e64 s[10:11], -4.0, v2 v_cmp_eq_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_u16_e64 s[10:11], v1, v255 v_cmp_eq_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0xff,0x03,0x00]
v_cmp_eq_u16_e64 s[10:11], v1, s2 v_cmp_eq_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x05,0x00,0x00]
v_cmp_eq_u16_e64 s[10:11], v1, s101 v_cmp_eq_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_eq_u16_e64 s[10:11], v1, 0 v_cmp_eq_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x01,0x01,0x00]
v_cmp_eq_u16_e64 s[10:11], v1, -1 v_cmp_eq_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x83,0x01,0x00]
v_cmp_eq_u16_e64 s[10:11], v1, 0.5 v_cmp_eq_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_u16_e64 s[10:11], v1, -4.0 v_cmp_eq_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_u16 vcc, v1, v2 v_cmp_le_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x56,0x7d] // CHECK: [0x01,0x05,0x56,0x7d]
v_cmp_le_u16 vcc, v255, v2 v_cmp_le_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x56,0x7d] // CHECK: [0xff,0x05,0x56,0x7d]
v_cmp_le_u16 vcc, s1, v2 v_cmp_le_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_le_u16_e64 s[10:11], 0, v2 v_cmp_le_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xab,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xab,0xd0,0x80,0x04,0x02,0x00]
v_cmp_le_u16_e64 s[10:11], -1, v2 v_cmp_le_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xab,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xab,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_le_u16_e64 s[10:11], 0.5, v2 v_cmp_le_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_u16_e64 s[10:11], -4.0, v2 v_cmp_le_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_u16_e64 s[10:11], v1, v255 v_cmp_le_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xab,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0xff,0x03,0x00]
v_cmp_le_u16_e64 s[10:11], v1, s2 v_cmp_le_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x05,0x00,0x00]
v_cmp_le_u16_e64 s[10:11], v1, s101 v_cmp_le_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_le_u16_e64 s[10:11], v1, 0 v_cmp_le_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x01,0x01,0x00]
v_cmp_le_u16_e64 s[10:11], v1, -1 v_cmp_le_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x83,0x01,0x00]
v_cmp_le_u16_e64 s[10:11], v1, 0.5 v_cmp_le_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_u16_e64 s[10:11], v1, -4.0 v_cmp_le_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_u16 vcc, v1, v2 v_cmp_gt_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x58,0x7d] // CHECK: [0x01,0x05,0x58,0x7d]
v_cmp_gt_u16 vcc, v255, v2 v_cmp_gt_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x58,0x7d] // CHECK: [0xff,0x05,0x58,0x7d]
v_cmp_gt_u16 vcc, s1, v2 v_cmp_gt_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_gt_u16_e64 s[10:11], 0, v2 v_cmp_gt_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xac,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xac,0xd0,0x80,0x04,0x02,0x00]
v_cmp_gt_u16_e64 s[10:11], -1, v2 v_cmp_gt_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xac,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xac,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_gt_u16_e64 s[10:11], 0.5, v2 v_cmp_gt_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_u16_e64 s[10:11], -4.0, v2 v_cmp_gt_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_u16_e64 s[10:11], v1, v255 v_cmp_gt_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xac,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0xff,0x03,0x00]
v_cmp_gt_u16_e64 s[10:11], v1, s2 v_cmp_gt_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x05,0x00,0x00]
v_cmp_gt_u16_e64 s[10:11], v1, s101 v_cmp_gt_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_gt_u16_e64 s[10:11], v1, 0 v_cmp_gt_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x01,0x01,0x00]
v_cmp_gt_u16_e64 s[10:11], v1, -1 v_cmp_gt_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x83,0x01,0x00]
v_cmp_gt_u16_e64 s[10:11], v1, 0.5 v_cmp_gt_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_u16_e64 s[10:11], v1, -4.0 v_cmp_gt_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_u16 vcc, v1, v2 v_cmp_ne_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x5a,0x7d] // CHECK: [0x01,0x05,0x5a,0x7d]
v_cmp_ne_u16 vcc, v255, v2 v_cmp_ne_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x5a,0x7d] // CHECK: [0xff,0x05,0x5a,0x7d]
v_cmp_ne_u16 vcc, s1, v2 v_cmp_ne_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_ne_u16_e64 s[10:11], 0, v2 v_cmp_ne_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xad,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xad,0xd0,0x80,0x04,0x02,0x00]
v_cmp_ne_u16_e64 s[10:11], -1, v2 v_cmp_ne_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xad,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xad,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_ne_u16_e64 s[10:11], 0.5, v2 v_cmp_ne_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_u16_e64 s[10:11], -4.0, v2 v_cmp_ne_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_u16_e64 s[10:11], v1, v255 v_cmp_ne_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xad,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0xff,0x03,0x00]
v_cmp_ne_u16_e64 s[10:11], v1, s2 v_cmp_ne_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x05,0x00,0x00]
v_cmp_ne_u16_e64 s[10:11], v1, s101 v_cmp_ne_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_ne_u16_e64 s[10:11], v1, 0 v_cmp_ne_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x01,0x01,0x00]
v_cmp_ne_u16_e64 s[10:11], v1, -1 v_cmp_ne_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x83,0x01,0x00]
v_cmp_ne_u16_e64 s[10:11], v1, 0.5 v_cmp_ne_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_u16_e64 s[10:11], v1, -4.0 v_cmp_ne_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_u16 vcc, v1, v2 v_cmp_ge_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x5c,0x7d] // CHECK: [0x01,0x05,0x5c,0x7d]
v_cmp_ge_u16 vcc, v255, v2 v_cmp_ge_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x5c,0x7d] // CHECK: [0xff,0x05,0x5c,0x7d]
v_cmp_ge_u16 vcc, s1, v2 v_cmp_ge_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_ge_u16_e64 s[10:11], 0, v2 v_cmp_ge_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xae,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xae,0xd0,0x80,0x04,0x02,0x00]
v_cmp_ge_u16_e64 s[10:11], -1, v2 v_cmp_ge_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xae,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xae,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_ge_u16_e64 s[10:11], 0.5, v2 v_cmp_ge_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_u16_e64 s[10:11], -4.0, v2 v_cmp_ge_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_u16_e64 s[10:11], v1, v255 v_cmp_ge_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xae,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0xff,0x03,0x00]
v_cmp_ge_u16_e64 s[10:11], v1, s2 v_cmp_ge_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x05,0x00,0x00]
v_cmp_ge_u16_e64 s[10:11], v1, s101 v_cmp_ge_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_ge_u16_e64 s[10:11], v1, 0 v_cmp_ge_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x01,0x01,0x00]
v_cmp_ge_u16_e64 s[10:11], v1, -1 v_cmp_ge_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x83,0x01,0x00]
v_cmp_ge_u16_e64 s[10:11], v1, 0.5 v_cmp_ge_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_u16_e64 s[10:11], v1, -4.0 v_cmp_ge_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_u16 vcc, v1, v2 v_cmp_t_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x5e,0x7d] // CHECK: [0x01,0x05,0x5e,0x7d]
v_cmp_t_u16 vcc, v255, v2 v_cmp_t_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x5e,0x7d] // CHECK: [0xff,0x05,0x5e,0x7d]
v_cmp_t_u16 vcc, s1, v2 v_cmp_t_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmp_t_u16_e64 s[10:11], 0, v2 v_cmp_t_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xaf,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xaf,0xd0,0x80,0x04,0x02,0x00]
v_cmp_t_u16_e64 s[10:11], -1, v2 v_cmp_t_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xaf,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xaf,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_t_u16_e64 s[10:11], 0.5, v2 v_cmp_t_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_u16_e64 s[10:11], -4.0, v2 v_cmp_t_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_u16_e64 s[10:11], v1, v255 v_cmp_t_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0xff,0x03,0x00]
v_cmp_t_u16_e64 s[10:11], v1, s2 v_cmp_t_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x05,0x00,0x00]
v_cmp_t_u16_e64 s[10:11], v1, s101 v_cmp_t_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmp_t_u16_e64 s[10:11], v1, 0 v_cmp_t_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x01,0x01,0x00]
v_cmp_t_u16_e64 s[10:11], v1, -1 v_cmp_t_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x83,0x01,0x00]
v_cmp_t_u16_e64 s[10:11], v1, 0.5 v_cmp_t_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_u16_e64 s[10:11], v1, -4.0 v_cmp_t_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_i16 vcc, v1, v2 v_cmpx_f_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x60,0x7d] // CHECK: [0x01,0x05,0x60,0x7d]
v_cmpx_f_i16 vcc, v255, v2 v_cmpx_f_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x60,0x7d] // CHECK: [0xff,0x05,0x60,0x7d]
v_cmpx_f_i16 vcc, s1, v2 v_cmpx_f_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_f_i16_e64 s[10:11], 0, v2 v_cmpx_f_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb0,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb0,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_f_i16_e64 s[10:11], -1, v2 v_cmpx_f_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb0,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb0,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_f_i16_e64 s[10:11], 0.5, v2 v_cmpx_f_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_i16_e64 s[10:11], -4.0, v2 v_cmpx_f_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_i16_e64 s[10:11], v1, v255 v_cmpx_f_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_f_i16_e64 s[10:11], v1, s2 v_cmpx_f_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_f_i16_e64 s[10:11], v1, s101 v_cmpx_f_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_f_i16_e64 s[10:11], v1, 0 v_cmpx_f_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_f_i16_e64 s[10:11], v1, -1 v_cmpx_f_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_f_i16_e64 s[10:11], v1, 0.5 v_cmpx_f_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_i16_e64 s[10:11], v1, -4.0 v_cmpx_f_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_i16 vcc, v1, v2 v_cmpx_lt_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x62,0x7d] // CHECK: [0x01,0x05,0x62,0x7d]
v_cmpx_lt_i16 vcc, v255, v2 v_cmpx_lt_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x62,0x7d] // CHECK: [0xff,0x05,0x62,0x7d]
v_cmpx_lt_i16 vcc, s1, v2 v_cmpx_lt_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_lt_i16_e64 s[10:11], 0, v2 v_cmpx_lt_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb1,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb1,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_lt_i16_e64 s[10:11], -1, v2 v_cmpx_lt_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb1,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb1,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_lt_i16_e64 s[10:11], 0.5, v2 v_cmpx_lt_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_i16_e64 s[10:11], -4.0, v2 v_cmpx_lt_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_i16_e64 s[10:11], v1, v255 v_cmpx_lt_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_lt_i16_e64 s[10:11], v1, s2 v_cmpx_lt_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_lt_i16_e64 s[10:11], v1, s101 v_cmpx_lt_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_lt_i16_e64 s[10:11], v1, 0 v_cmpx_lt_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_lt_i16_e64 s[10:11], v1, -1 v_cmpx_lt_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_lt_i16_e64 s[10:11], v1, 0.5 v_cmpx_lt_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_i16_e64 s[10:11], v1, -4.0 v_cmpx_lt_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_i16 vcc, v1, v2 v_cmpx_eq_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x64,0x7d] // CHECK: [0x01,0x05,0x64,0x7d]
v_cmpx_eq_i16 vcc, v255, v2 v_cmpx_eq_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x64,0x7d] // CHECK: [0xff,0x05,0x64,0x7d]
v_cmpx_eq_i16 vcc, s1, v2 v_cmpx_eq_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_eq_i16_e64 s[10:11], 0, v2 v_cmpx_eq_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb2,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb2,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_eq_i16_e64 s[10:11], -1, v2 v_cmpx_eq_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb2,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb2,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_eq_i16_e64 s[10:11], 0.5, v2 v_cmpx_eq_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_i16_e64 s[10:11], -4.0, v2 v_cmpx_eq_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_i16_e64 s[10:11], v1, v255 v_cmpx_eq_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_eq_i16_e64 s[10:11], v1, s2 v_cmpx_eq_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_eq_i16_e64 s[10:11], v1, s101 v_cmpx_eq_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_eq_i16_e64 s[10:11], v1, 0 v_cmpx_eq_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_eq_i16_e64 s[10:11], v1, -1 v_cmpx_eq_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_eq_i16_e64 s[10:11], v1, 0.5 v_cmpx_eq_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_i16_e64 s[10:11], v1, -4.0 v_cmpx_eq_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_i16 vcc, v1, v2 v_cmpx_le_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x66,0x7d] // CHECK: [0x01,0x05,0x66,0x7d]
v_cmpx_le_i16 vcc, v255, v2 v_cmpx_le_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x66,0x7d] // CHECK: [0xff,0x05,0x66,0x7d]
v_cmpx_le_i16 vcc, s1, v2 v_cmpx_le_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_le_i16_e64 s[10:11], 0, v2 v_cmpx_le_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb3,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb3,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_le_i16_e64 s[10:11], -1, v2 v_cmpx_le_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb3,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb3,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_le_i16_e64 s[10:11], 0.5, v2 v_cmpx_le_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_i16_e64 s[10:11], -4.0, v2 v_cmpx_le_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_i16_e64 s[10:11], v1, v255 v_cmpx_le_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_le_i16_e64 s[10:11], v1, s2 v_cmpx_le_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_le_i16_e64 s[10:11], v1, s101 v_cmpx_le_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_le_i16_e64 s[10:11], v1, 0 v_cmpx_le_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_le_i16_e64 s[10:11], v1, -1 v_cmpx_le_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_le_i16_e64 s[10:11], v1, 0.5 v_cmpx_le_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_i16_e64 s[10:11], v1, -4.0 v_cmpx_le_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_i16 vcc, v1, v2 v_cmpx_gt_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x68,0x7d] // CHECK: [0x01,0x05,0x68,0x7d]
v_cmpx_gt_i16 vcc, v255, v2 v_cmpx_gt_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x68,0x7d] // CHECK: [0xff,0x05,0x68,0x7d]
v_cmpx_gt_i16 vcc, s1, v2 v_cmpx_gt_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_gt_i16_e64 s[10:11], 0, v2 v_cmpx_gt_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb4,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb4,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_gt_i16_e64 s[10:11], -1, v2 v_cmpx_gt_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb4,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb4,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_gt_i16_e64 s[10:11], 0.5, v2 v_cmpx_gt_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_i16_e64 s[10:11], -4.0, v2 v_cmpx_gt_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_i16_e64 s[10:11], v1, v255 v_cmpx_gt_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_gt_i16_e64 s[10:11], v1, s2 v_cmpx_gt_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_gt_i16_e64 s[10:11], v1, s101 v_cmpx_gt_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_gt_i16_e64 s[10:11], v1, 0 v_cmpx_gt_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_gt_i16_e64 s[10:11], v1, -1 v_cmpx_gt_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_gt_i16_e64 s[10:11], v1, 0.5 v_cmpx_gt_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_i16_e64 s[10:11], v1, -4.0 v_cmpx_gt_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_i16 vcc, v1, v2 v_cmpx_ne_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x6a,0x7d] // CHECK: [0x01,0x05,0x6a,0x7d]
v_cmpx_ne_i16 vcc, v255, v2 v_cmpx_ne_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x6a,0x7d] // CHECK: [0xff,0x05,0x6a,0x7d]
v_cmpx_ne_i16 vcc, s1, v2 v_cmpx_ne_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_ne_i16_e64 s[10:11], 0, v2 v_cmpx_ne_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb5,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb5,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_ne_i16_e64 s[10:11], -1, v2 v_cmpx_ne_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb5,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb5,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_ne_i16_e64 s[10:11], 0.5, v2 v_cmpx_ne_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_i16_e64 s[10:11], -4.0, v2 v_cmpx_ne_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_i16_e64 s[10:11], v1, v255 v_cmpx_ne_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_ne_i16_e64 s[10:11], v1, s2 v_cmpx_ne_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_ne_i16_e64 s[10:11], v1, s101 v_cmpx_ne_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_ne_i16_e64 s[10:11], v1, 0 v_cmpx_ne_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_ne_i16_e64 s[10:11], v1, -1 v_cmpx_ne_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_ne_i16_e64 s[10:11], v1, 0.5 v_cmpx_ne_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_i16_e64 s[10:11], v1, -4.0 v_cmpx_ne_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_i16 vcc, v1, v2 v_cmpx_ge_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x6c,0x7d] // CHECK: [0x01,0x05,0x6c,0x7d]
v_cmpx_ge_i16 vcc, v255, v2 v_cmpx_ge_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x6c,0x7d] // CHECK: [0xff,0x05,0x6c,0x7d]
v_cmpx_ge_i16 vcc, s1, v2 v_cmpx_ge_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_ge_i16_e64 s[10:11], 0, v2 v_cmpx_ge_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb6,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb6,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_ge_i16_e64 s[10:11], -1, v2 v_cmpx_ge_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb6,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb6,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_ge_i16_e64 s[10:11], 0.5, v2 v_cmpx_ge_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_i16_e64 s[10:11], -4.0, v2 v_cmpx_ge_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_i16_e64 s[10:11], v1, v255 v_cmpx_ge_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_ge_i16_e64 s[10:11], v1, s2 v_cmpx_ge_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_ge_i16_e64 s[10:11], v1, s101 v_cmpx_ge_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_ge_i16_e64 s[10:11], v1, 0 v_cmpx_ge_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_ge_i16_e64 s[10:11], v1, -1 v_cmpx_ge_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_ge_i16_e64 s[10:11], v1, 0.5 v_cmpx_ge_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_i16_e64 s[10:11], v1, -4.0 v_cmpx_ge_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_i16 vcc, v1, v2 v_cmpx_t_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x6e,0x7d] // CHECK: [0x01,0x05,0x6e,0x7d]
v_cmpx_t_i16 vcc, v255, v2 v_cmpx_t_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x6e,0x7d] // CHECK: [0xff,0x05,0x6e,0x7d]
v_cmpx_t_i16 vcc, s1, v2 v_cmpx_t_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_t_i16_e64 s[10:11], 0, v2 v_cmpx_t_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb7,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb7,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_t_i16_e64 s[10:11], -1, v2 v_cmpx_t_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb7,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb7,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_t_i16_e64 s[10:11], 0.5, v2 v_cmpx_t_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_i16_e64 s[10:11], -4.0, v2 v_cmpx_t_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_i16_e64 s[10:11], v1, v255 v_cmpx_t_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_t_i16_e64 s[10:11], v1, s2 v_cmpx_t_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_t_i16_e64 s[10:11], v1, s101 v_cmpx_t_i16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_t_i16_e64 s[10:11], v1, 0 v_cmpx_t_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_t_i16_e64 s[10:11], v1, -1 v_cmpx_t_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_t_i16_e64 s[10:11], v1, 0.5 v_cmpx_t_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_i16_e64 s[10:11], v1, -4.0 v_cmpx_t_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_u16 vcc, v1, v2 v_cmpx_f_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x70,0x7d] // CHECK: [0x01,0x05,0x70,0x7d]
v_cmpx_f_u16 vcc, v255, v2 v_cmpx_f_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x70,0x7d] // CHECK: [0xff,0x05,0x70,0x7d]
v_cmpx_f_u16 vcc, s1, v2 v_cmpx_f_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_f_u16_e64 s[10:11], 0, v2 v_cmpx_f_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb8,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb8,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_f_u16_e64 s[10:11], -1, v2 v_cmpx_f_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb8,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb8,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_f_u16_e64 s[10:11], 0.5, v2 v_cmpx_f_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_u16_e64 s[10:11], -4.0, v2 v_cmpx_f_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_u16_e64 s[10:11], v1, v255 v_cmpx_f_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_f_u16_e64 s[10:11], v1, s2 v_cmpx_f_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_f_u16_e64 s[10:11], v1, s101 v_cmpx_f_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_f_u16_e64 s[10:11], v1, 0 v_cmpx_f_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_f_u16_e64 s[10:11], v1, -1 v_cmpx_f_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_f_u16_e64 s[10:11], v1, 0.5 v_cmpx_f_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_u16_e64 s[10:11], v1, -4.0 v_cmpx_f_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_u16 vcc, v1, v2 v_cmpx_lt_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x72,0x7d] // CHECK: [0x01,0x05,0x72,0x7d]
v_cmpx_lt_u16 vcc, v255, v2 v_cmpx_lt_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x72,0x7d] // CHECK: [0xff,0x05,0x72,0x7d]
v_cmpx_lt_u16 vcc, s1, v2 v_cmpx_lt_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_lt_u16_e64 s[10:11], 0, v2 v_cmpx_lt_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb9,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb9,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_lt_u16_e64 s[10:11], -1, v2 v_cmpx_lt_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb9,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb9,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_lt_u16_e64 s[10:11], 0.5, v2 v_cmpx_lt_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_u16_e64 s[10:11], -4.0, v2 v_cmpx_lt_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_u16_e64 s[10:11], v1, v255 v_cmpx_lt_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_lt_u16_e64 s[10:11], v1, s2 v_cmpx_lt_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_lt_u16_e64 s[10:11], v1, s101 v_cmpx_lt_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_lt_u16_e64 s[10:11], v1, 0 v_cmpx_lt_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_lt_u16_e64 s[10:11], v1, -1 v_cmpx_lt_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_lt_u16_e64 s[10:11], v1, 0.5 v_cmpx_lt_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_u16_e64 s[10:11], v1, -4.0 v_cmpx_lt_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_u16 vcc, v1, v2 v_cmpx_eq_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x74,0x7d] // CHECK: [0x01,0x05,0x74,0x7d]
v_cmpx_eq_u16 vcc, v255, v2 v_cmpx_eq_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x74,0x7d] // CHECK: [0xff,0x05,0x74,0x7d]
v_cmpx_eq_u16 vcc, s1, v2 v_cmpx_eq_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_eq_u16_e64 s[10:11], 0, v2 v_cmpx_eq_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xba,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xba,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_eq_u16_e64 s[10:11], -1, v2 v_cmpx_eq_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xba,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xba,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_eq_u16_e64 s[10:11], 0.5, v2 v_cmpx_eq_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_u16_e64 s[10:11], -4.0, v2 v_cmpx_eq_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_u16_e64 s[10:11], v1, v255 v_cmpx_eq_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xba,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_eq_u16_e64 s[10:11], v1, s2 v_cmpx_eq_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_eq_u16_e64 s[10:11], v1, s101 v_cmpx_eq_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_eq_u16_e64 s[10:11], v1, 0 v_cmpx_eq_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_eq_u16_e64 s[10:11], v1, -1 v_cmpx_eq_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_eq_u16_e64 s[10:11], v1, 0.5 v_cmpx_eq_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_u16_e64 s[10:11], v1, -4.0 v_cmpx_eq_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_u16 vcc, v1, v2 v_cmpx_le_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x76,0x7d] // CHECK: [0x01,0x05,0x76,0x7d]
v_cmpx_le_u16 vcc, v255, v2 v_cmpx_le_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x76,0x7d] // CHECK: [0xff,0x05,0x76,0x7d]
v_cmpx_le_u16 vcc, s1, v2 v_cmpx_le_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_le_u16_e64 s[10:11], 0, v2 v_cmpx_le_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xbb,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbb,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_le_u16_e64 s[10:11], -1, v2 v_cmpx_le_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xbb,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbb,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_le_u16_e64 s[10:11], 0.5, v2 v_cmpx_le_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_u16_e64 s[10:11], -4.0, v2 v_cmpx_le_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_u16_e64 s[10:11], v1, v255 v_cmpx_le_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_le_u16_e64 s[10:11], v1, s2 v_cmpx_le_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_le_u16_e64 s[10:11], v1, s101 v_cmpx_le_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_le_u16_e64 s[10:11], v1, 0 v_cmpx_le_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_le_u16_e64 s[10:11], v1, -1 v_cmpx_le_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_le_u16_e64 s[10:11], v1, 0.5 v_cmpx_le_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_u16_e64 s[10:11], v1, -4.0 v_cmpx_le_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_u16 vcc, v1, v2 v_cmpx_gt_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x78,0x7d] // CHECK: [0x01,0x05,0x78,0x7d]
v_cmpx_gt_u16 vcc, v255, v2 v_cmpx_gt_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x78,0x7d] // CHECK: [0xff,0x05,0x78,0x7d]
v_cmpx_gt_u16 vcc, s1, v2 v_cmpx_gt_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_gt_u16_e64 s[10:11], 0, v2 v_cmpx_gt_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xbc,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbc,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_gt_u16_e64 s[10:11], -1, v2 v_cmpx_gt_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xbc,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbc,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_gt_u16_e64 s[10:11], 0.5, v2 v_cmpx_gt_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_u16_e64 s[10:11], -4.0, v2 v_cmpx_gt_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_u16_e64 s[10:11], v1, v255 v_cmpx_gt_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_gt_u16_e64 s[10:11], v1, s2 v_cmpx_gt_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_gt_u16_e64 s[10:11], v1, s101 v_cmpx_gt_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_gt_u16_e64 s[10:11], v1, 0 v_cmpx_gt_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_gt_u16_e64 s[10:11], v1, -1 v_cmpx_gt_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_gt_u16_e64 s[10:11], v1, 0.5 v_cmpx_gt_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_u16_e64 s[10:11], v1, -4.0 v_cmpx_gt_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_u16 vcc, v1, v2 v_cmpx_ne_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x7a,0x7d] // CHECK: [0x01,0x05,0x7a,0x7d]
v_cmpx_ne_u16 vcc, v255, v2 v_cmpx_ne_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x7a,0x7d] // CHECK: [0xff,0x05,0x7a,0x7d]
v_cmpx_ne_u16 vcc, s1, v2 v_cmpx_ne_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_ne_u16_e64 s[10:11], 0, v2 v_cmpx_ne_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xbd,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbd,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_ne_u16_e64 s[10:11], -1, v2 v_cmpx_ne_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xbd,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbd,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_ne_u16_e64 s[10:11], 0.5, v2 v_cmpx_ne_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_u16_e64 s[10:11], -4.0, v2 v_cmpx_ne_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_u16_e64 s[10:11], v1, v255 v_cmpx_ne_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_ne_u16_e64 s[10:11], v1, s2 v_cmpx_ne_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_ne_u16_e64 s[10:11], v1, s101 v_cmpx_ne_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_ne_u16_e64 s[10:11], v1, 0 v_cmpx_ne_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_ne_u16_e64 s[10:11], v1, -1 v_cmpx_ne_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_ne_u16_e64 s[10:11], v1, 0.5 v_cmpx_ne_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_u16_e64 s[10:11], v1, -4.0 v_cmpx_ne_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_u16 vcc, v1, v2 v_cmpx_ge_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x7c,0x7d] // CHECK: [0x01,0x05,0x7c,0x7d]
v_cmpx_ge_u16 vcc, v255, v2 v_cmpx_ge_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x7c,0x7d] // CHECK: [0xff,0x05,0x7c,0x7d]
v_cmpx_ge_u16 vcc, s1, v2 v_cmpx_ge_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_ge_u16_e64 s[10:11], 0, v2 v_cmpx_ge_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xbe,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbe,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_ge_u16_e64 s[10:11], -1, v2 v_cmpx_ge_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xbe,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbe,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_ge_u16_e64 s[10:11], 0.5, v2 v_cmpx_ge_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_u16_e64 s[10:11], -4.0, v2 v_cmpx_ge_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_u16_e64 s[10:11], v1, v255 v_cmpx_ge_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_ge_u16_e64 s[10:11], v1, s2 v_cmpx_ge_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_ge_u16_e64 s[10:11], v1, s101 v_cmpx_ge_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_ge_u16_e64 s[10:11], v1, 0 v_cmpx_ge_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_ge_u16_e64 s[10:11], v1, -1 v_cmpx_ge_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_ge_u16_e64 s[10:11], v1, 0.5 v_cmpx_ge_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_u16_e64 s[10:11], v1, -4.0 v_cmpx_ge_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_u16 vcc, v1, v2 v_cmpx_t_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x7e,0x7d] // CHECK: [0x01,0x05,0x7e,0x7d]
v_cmpx_t_u16 vcc, v255, v2 v_cmpx_t_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x7e,0x7d] // CHECK: [0xff,0x05,0x7e,0x7d]
v_cmpx_t_u16 vcc, s1, v2 v_cmpx_t_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
v_cmpx_t_u16_e64 s[10:11], 0, v2 v_cmpx_t_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xbf,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbf,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_t_u16_e64 s[10:11], -1, v2 v_cmpx_t_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xbf,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbf,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_t_u16_e64 s[10:11], 0.5, v2 v_cmpx_t_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_u16_e64 s[10:11], -4.0, v2 v_cmpx_t_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_u16_e64 s[10:11], v1, v255 v_cmpx_t_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_t_u16_e64 s[10:11], v1, s2 v_cmpx_t_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_t_u16_e64 s[10:11], v1, s101 v_cmpx_t_u16_e64 s[10:11], v1, s101
Show All 37 Lines
v_cmpx_t_u16_e64 s[10:11], v1, 0 v_cmpx_t_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_t_u16_e64 s[10:11], v1, -1 v_cmpx_t_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_t_u16_e64 s[10:11], v1, 0.5 v_cmpx_t_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_u16_e64 s[10:11], v1, -4.0 v_cmpx_t_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_i32 vcc, v1, v2 v_cmp_f_i32 vcc, v1, v2
// CHECK: [0x01,0x05,0x80,0x7d] // CHECK: [0x01,0x05,0x80,0x7d]
v_cmp_f_i32 vcc, v255, v2 v_cmp_f_i32 vcc, v255, v2
// CHECK: [0xff,0x05,0x80,0x7d] // CHECK: [0xff,0x05,0x80,0x7d]
v_cmp_f_i32 vcc, s1, v2 v_cmp_f_i32 vcc, s1, v2
▲ Show 20 Lines • Show All 36,661 Lines • Show Last 20 Lines

llvm/test/MC/AMDGPU/gfx9-asm-err.s

// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck -check-prefix=GFX9ERR --implicit-check-not=error: %s // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck -check-prefix=GFX9ERR --implicit-check-not=error: %s
v_cvt_f16_u16_e64 v5, 0.5 v_cvt_f16_u16_e64 v5, 0.5
// GFX9ERR: error: invalid literal operand // GFX9ERR: error: literal operands are not supported
v_cvt_f16_u16_e64 v5, -4.0 v_cvt_f16_u16_e64 v5, -4.0
// GFX9ERR: error: invalid literal operand // GFX9ERR: error: literal operands are not supported
v_add_u16_e64 v5, v1, 0.5 v_add_u16_e64 v5, v1, 0.5
// GFX9ERR: error: invalid literal operand // GFX9ERR: error: literal operands are not supported
v_add_u16_e64 v5, v1, -4.0 v_add_u16_e64 v5, v1, -4.0
// GFX9ERR: error: invalid literal operand // GFX9ERR: error: literal operands are not supported
v_cvt_f16_i16_e64 v5, 0.5 v_cvt_f16_i16_e64 v5, 0.5
// GFX9ERR: error: invalid literal operand // GFX9ERR: error: literal operands are not supported
v_cvt_f16_i16_e64 v5, -4.0 v_cvt_f16_i16_e64 v5, -4.0
// GFX9ERR: error: invalid literal operand // GFX9ERR: error: literal operands are not supported
v_add_u16_e64 v5, 0.5, v2 v_add_u16_e64 v5, 0.5, v2
// GFX9ERR: error: invalid literal operand // GFX9ERR: error: literal operands are not supported
v_add_u16_e64 v5, -4.0, v2 v_add_u16_e64 v5, -4.0, v2
// GFX9ERR: error: invalid literal operand // GFX9ERR: error: literal operands are not supported
v_subrev_u16_e64 v5, v1, 0.5 v_subrev_u16_e64 v5, v1, 0.5
// GFX9ERR: error: invalid literal operand // GFX9ERR: error: literal operands are not supported
v_subrev_u16_e64 v5, v1, -4.0 v_subrev_u16_e64 v5, v1, -4.0
// GFX9ERR: error: invalid literal operand // GFX9ERR: error: literal operands are not supported

llvm/test/MC/AMDGPU/gfx908_err_pos.s

// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx908 %s 2>&1 | FileCheck %s --implicit-check-not=error: --strict-whitespace // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx908 %s 2>&1 | FileCheck %s --implicit-check-not=error: --strict-whitespace
//============================================================================== //==============================================================================
// inline constants are not allowed for this operand
v_mfma_f32_32x32x1f32 a[0:31], v0, v1, 0
// CHECK: error: inline constants are not allowed for this operand
// CHECK-NEXT:{{^}}v_mfma_f32_32x32x1f32 a[0:31], v0, v1, 0
// CHECK-NEXT:{{^}} ^
//==============================================================================
// invalid neg_hi value // invalid neg_hi value
v_dot2_f32_f16 v0, v1, v2, v3 neg_hi:[0,2] v_dot2_f32_f16 v0, v1, v2, v3 neg_hi:[0,2]
// CHECK: error: invalid neg_hi value // CHECK: error: invalid neg_hi value
// CHECK-NEXT:{{^}}v_dot2_f32_f16 v0, v1, v2, v3 neg_hi:[0,2] // CHECK-NEXT:{{^}}v_dot2_f32_f16 v0, v1, v2, v3 neg_hi:[0,2]
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
//============================================================================== //==============================================================================
Show All 22 Lines

llvm/test/MC/AMDGPU/gfx9_asm_all.s

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 34,893 Lines • ▼ Show 20 Lines
v_sub_u16_e64 v5, 0, v2 v_sub_u16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x27,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x27,0xd1,0x80,0x04,0x02,0x00]
v_sub_u16_e64 v5, -1, v2 v_sub_u16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x27,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x27,0xd1,0xc1,0x04,0x02,0x00]
v_sub_u16_e64 v5, 0.5, v2 v_sub_u16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_sub_u16_e64 v5, -4.0, v2 v_sub_u16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_sub_u16_e64 v5, v1, v255 v_sub_u16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x27,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x27,0xd1,0x01,0xff,0x03,0x00]
v_sub_u16_e64 v5, v1, s2 v_sub_u16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x27,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x27,0xd1,0x01,0x05,0x00,0x00]
v_sub_u16_e64 v5, v1, s101 v_sub_u16_e64 v5, v1, s101
Show All 22 Lines
v_sub_u16_e64 v5, v1, 0 v_sub_u16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x27,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x27,0xd1,0x01,0x01,0x01,0x00]
v_sub_u16_e64 v5, v1, -1 v_sub_u16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x27,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x27,0xd1,0x01,0x83,0x01,0x00]
v_sub_u16_e64 v5, v1, 0.5 v_sub_u16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_sub_u16_e64 v5, v1, -4.0 v_sub_u16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_subrev_u16 v5, v1, v2 v_subrev_u16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x50] // CHECK: [0x01,0x05,0x0a,0x50]
v_subrev_u16 v255, v1, v2 v_subrev_u16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x51] // CHECK: [0x01,0x05,0xfe,0x51]
v_subrev_u16 v5, v255, v2 v_subrev_u16 v5, v255, v2
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
v_subrev_u16_e64 v5, 0, v2 v_subrev_u16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x28,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x28,0xd1,0x80,0x04,0x02,0x00]
v_subrev_u16_e64 v5, -1, v2 v_subrev_u16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x28,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x28,0xd1,0xc1,0x04,0x02,0x00]
v_subrev_u16_e64 v5, 0.5, v2 v_subrev_u16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_subrev_u16_e64 v5, -4.0, v2 v_subrev_u16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_subrev_u16_e64 v5, v1, v255 v_subrev_u16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x28,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x28,0xd1,0x01,0xff,0x03,0x00]
v_subrev_u16_e64 v5, v1, s2 v_subrev_u16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x28,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x28,0xd1,0x01,0x05,0x00,0x00]
v_subrev_u16_e64 v5, v1, s101 v_subrev_u16_e64 v5, v1, s101
▲ Show 20 Lines • Show All 121 Lines • ▼ Show 20 Lines
v_mul_lo_u16_e64 v5, 0, v2 v_mul_lo_u16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x29,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x29,0xd1,0x80,0x04,0x02,0x00]
v_mul_lo_u16_e64 v5, -1, v2 v_mul_lo_u16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x29,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x29,0xd1,0xc1,0x04,0x02,0x00]
v_mul_lo_u16_e64 v5, 0.5, v2 v_mul_lo_u16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mul_lo_u16_e64 v5, -4.0, v2 v_mul_lo_u16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mul_lo_u16_e64 v5, v1, v255 v_mul_lo_u16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x29,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x29,0xd1,0x01,0xff,0x03,0x00]
v_mul_lo_u16_e64 v5, v1, s2 v_mul_lo_u16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x29,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x29,0xd1,0x01,0x05,0x00,0x00]
v_mul_lo_u16_e64 v5, v1, s101 v_mul_lo_u16_e64 v5, v1, s101
Show All 22 Lines
v_mul_lo_u16_e64 v5, v1, 0 v_mul_lo_u16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x29,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x29,0xd1,0x01,0x01,0x01,0x00]
v_mul_lo_u16_e64 v5, v1, -1 v_mul_lo_u16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x29,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x29,0xd1,0x01,0x83,0x01,0x00]
v_mul_lo_u16_e64 v5, v1, 0.5 v_mul_lo_u16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mul_lo_u16_e64 v5, v1, -4.0 v_mul_lo_u16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshlrev_b16 v5, v1, v2 v_lshlrev_b16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x54] // CHECK: [0x01,0x05,0x0a,0x54]
v_lshlrev_b16 v255, v1, v2 v_lshlrev_b16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x55] // CHECK: [0x01,0x05,0xfe,0x55]
v_lshlrev_b16 v5, v255, v2 v_lshlrev_b16 v5, v255, v2
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
v_lshlrev_b16_e64 v5, 0, v2 v_lshlrev_b16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x2a,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2a,0xd1,0x80,0x04,0x02,0x00]
v_lshlrev_b16_e64 v5, -1, v2 v_lshlrev_b16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x2a,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2a,0xd1,0xc1,0x04,0x02,0x00]
v_lshlrev_b16_e64 v5, 0.5, v2 v_lshlrev_b16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshlrev_b16_e64 v5, -4.0, v2 v_lshlrev_b16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshlrev_b16_e64 v5, v1, v255 v_lshlrev_b16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x2a,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0xff,0x03,0x00]
v_lshlrev_b16_e64 v5, v1, s2 v_lshlrev_b16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x05,0x00,0x00]
v_lshlrev_b16_e64 v5, v1, s101 v_lshlrev_b16_e64 v5, v1, s101
Show All 22 Lines
v_lshlrev_b16_e64 v5, v1, 0 v_lshlrev_b16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x01,0x01,0x00]
v_lshlrev_b16_e64 v5, v1, -1 v_lshlrev_b16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x83,0x01,0x00]
v_lshlrev_b16_e64 v5, v1, 0.5 v_lshlrev_b16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshlrev_b16_e64 v5, v1, -4.0 v_lshlrev_b16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshrrev_b16 v5, v1, v2 v_lshrrev_b16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x56] // CHECK: [0x01,0x05,0x0a,0x56]
v_lshrrev_b16 v255, v1, v2 v_lshrrev_b16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x57] // CHECK: [0x01,0x05,0xfe,0x57]
v_lshrrev_b16 v5, v255, v2 v_lshrrev_b16 v5, v255, v2
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
v_lshrrev_b16_e64 v5, 0, v2 v_lshrrev_b16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x2b,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2b,0xd1,0x80,0x04,0x02,0x00]
v_lshrrev_b16_e64 v5, -1, v2 v_lshrrev_b16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x2b,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2b,0xd1,0xc1,0x04,0x02,0x00]
v_lshrrev_b16_e64 v5, 0.5, v2 v_lshrrev_b16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshrrev_b16_e64 v5, -4.0, v2 v_lshrrev_b16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshrrev_b16_e64 v5, v1, v255 v_lshrrev_b16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x2b,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0xff,0x03,0x00]
v_lshrrev_b16_e64 v5, v1, s2 v_lshrrev_b16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x05,0x00,0x00]
v_lshrrev_b16_e64 v5, v1, s101 v_lshrrev_b16_e64 v5, v1, s101
Show All 22 Lines
v_lshrrev_b16_e64 v5, v1, 0 v_lshrrev_b16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x01,0x01,0x00]
v_lshrrev_b16_e64 v5, v1, -1 v_lshrrev_b16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x83,0x01,0x00]
v_lshrrev_b16_e64 v5, v1, 0.5 v_lshrrev_b16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_lshrrev_b16_e64 v5, v1, -4.0 v_lshrrev_b16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_ashrrev_i16 v5, v1, v2 v_ashrrev_i16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x58] // CHECK: [0x01,0x05,0x0a,0x58]
v_ashrrev_i16 v255, v1, v2 v_ashrrev_i16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x59] // CHECK: [0x01,0x05,0xfe,0x59]
v_ashrrev_i16 v5, v255, v2 v_ashrrev_i16 v5, v255, v2
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
v_ashrrev_i16_e64 v5, 0, v2 v_ashrrev_i16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x2c,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2c,0xd1,0x80,0x04,0x02,0x00]
v_ashrrev_i16_e64 v5, -1, v2 v_ashrrev_i16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x2c,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2c,0xd1,0xc1,0x04,0x02,0x00]
v_ashrrev_i16_e64 v5, 0.5, v2 v_ashrrev_i16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_ashrrev_i16_e64 v5, -4.0, v2 v_ashrrev_i16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_ashrrev_i16_e64 v5, v1, v255 v_ashrrev_i16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x2c,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0xff,0x03,0x00]
v_ashrrev_i16_e64 v5, v1, s2 v_ashrrev_i16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x05,0x00,0x00]
v_ashrrev_i16_e64 v5, v1, s101 v_ashrrev_i16_e64 v5, v1, s101
Show All 22 Lines
v_ashrrev_i16_e64 v5, v1, 0 v_ashrrev_i16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x01,0x01,0x00]
v_ashrrev_i16_e64 v5, v1, -1 v_ashrrev_i16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x83,0x01,0x00]
v_ashrrev_i16_e64 v5, v1, 0.5 v_ashrrev_i16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_ashrrev_i16_e64 v5, v1, -4.0 v_ashrrev_i16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_f16 v5, v1, v2 v_max_f16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x5a] // CHECK: [0x01,0x05,0x0a,0x5a]
v_max_f16 v255, v1, v2 v_max_f16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x5b] // CHECK: [0x01,0x05,0xfe,0x5b]
v_max_f16 v5, v255, v2 v_max_f16 v5, v255, v2
▲ Show 20 Lines • Show All 421 Lines • ▼ Show 20 Lines
v_max_u16_e64 v5, 0, v2 v_max_u16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x2f,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2f,0xd1,0x80,0x04,0x02,0x00]
v_max_u16_e64 v5, -1, v2 v_max_u16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x2f,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x2f,0xd1,0xc1,0x04,0x02,0x00]
v_max_u16_e64 v5, 0.5, v2 v_max_u16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_u16_e64 v5, -4.0, v2 v_max_u16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_u16_e64 v5, v1, v255 v_max_u16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x2f,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0xff,0x03,0x00]
v_max_u16_e64 v5, v1, s2 v_max_u16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x05,0x00,0x00]
v_max_u16_e64 v5, v1, s101 v_max_u16_e64 v5, v1, s101
Show All 22 Lines
v_max_u16_e64 v5, v1, 0 v_max_u16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x01,0x01,0x00]
v_max_u16_e64 v5, v1, -1 v_max_u16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x83,0x01,0x00]
v_max_u16_e64 v5, v1, 0.5 v_max_u16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_u16_e64 v5, v1, -4.0 v_max_u16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_i16 v5, v1, v2 v_max_i16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x60] // CHECK: [0x01,0x05,0x0a,0x60]
v_max_i16 v255, v1, v2 v_max_i16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x61] // CHECK: [0x01,0x05,0xfe,0x61]
v_max_i16 v5, v255, v2 v_max_i16 v5, v255, v2
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
v_max_i16_e64 v5, 0, v2 v_max_i16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x30,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x30,0xd1,0x80,0x04,0x02,0x00]
v_max_i16_e64 v5, -1, v2 v_max_i16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x30,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x30,0xd1,0xc1,0x04,0x02,0x00]
v_max_i16_e64 v5, 0.5, v2 v_max_i16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_i16_e64 v5, -4.0, v2 v_max_i16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_i16_e64 v5, v1, v255 v_max_i16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x30,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x30,0xd1,0x01,0xff,0x03,0x00]
v_max_i16_e64 v5, v1, s2 v_max_i16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x30,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x30,0xd1,0x01,0x05,0x00,0x00]
v_max_i16_e64 v5, v1, s101 v_max_i16_e64 v5, v1, s101
Show All 22 Lines
v_max_i16_e64 v5, v1, 0 v_max_i16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x30,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x30,0xd1,0x01,0x01,0x01,0x00]
v_max_i16_e64 v5, v1, -1 v_max_i16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x30,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x30,0xd1,0x01,0x83,0x01,0x00]
v_max_i16_e64 v5, v1, 0.5 v_max_i16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max_i16_e64 v5, v1, -4.0 v_max_i16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_u16 v5, v1, v2 v_min_u16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x62] // CHECK: [0x01,0x05,0x0a,0x62]
v_min_u16 v255, v1, v2 v_min_u16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x63] // CHECK: [0x01,0x05,0xfe,0x63]
v_min_u16 v5, v255, v2 v_min_u16 v5, v255, v2
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
v_min_u16_e64 v5, 0, v2 v_min_u16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x31,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x31,0xd1,0x80,0x04,0x02,0x00]
v_min_u16_e64 v5, -1, v2 v_min_u16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x31,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x31,0xd1,0xc1,0x04,0x02,0x00]
v_min_u16_e64 v5, 0.5, v2 v_min_u16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_u16_e64 v5, -4.0, v2 v_min_u16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_u16_e64 v5, v1, v255 v_min_u16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x31,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x31,0xd1,0x01,0xff,0x03,0x00]
v_min_u16_e64 v5, v1, s2 v_min_u16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x31,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x31,0xd1,0x01,0x05,0x00,0x00]
v_min_u16_e64 v5, v1, s101 v_min_u16_e64 v5, v1, s101
Show All 22 Lines
v_min_u16_e64 v5, v1, 0 v_min_u16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x31,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x31,0xd1,0x01,0x01,0x01,0x00]
v_min_u16_e64 v5, v1, -1 v_min_u16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x31,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x31,0xd1,0x01,0x83,0x01,0x00]
v_min_u16_e64 v5, v1, 0.5 v_min_u16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_u16_e64 v5, v1, -4.0 v_min_u16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_i16 v5, v1, v2 v_min_i16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x64] // CHECK: [0x01,0x05,0x0a,0x64]
v_min_i16 v255, v1, v2 v_min_i16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x65] // CHECK: [0x01,0x05,0xfe,0x65]
v_min_i16 v5, v255, v2 v_min_i16 v5, v255, v2
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
v_min_i16_e64 v5, 0, v2 v_min_i16_e64 v5, 0, v2
// CHECK: [0x05,0x00,0x32,0xd1,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x32,0xd1,0x80,0x04,0x02,0x00]
v_min_i16_e64 v5, -1, v2 v_min_i16_e64 v5, -1, v2
// CHECK: [0x05,0x00,0x32,0xd1,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x32,0xd1,0xc1,0x04,0x02,0x00]
v_min_i16_e64 v5, 0.5, v2 v_min_i16_e64 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_i16_e64 v5, -4.0, v2 v_min_i16_e64 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_i16_e64 v5, v1, v255 v_min_i16_e64 v5, v1, v255
// CHECK: [0x05,0x00,0x32,0xd1,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x32,0xd1,0x01,0xff,0x03,0x00]
v_min_i16_e64 v5, v1, s2 v_min_i16_e64 v5, v1, s2
// CHECK: [0x05,0x00,0x32,0xd1,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x32,0xd1,0x01,0x05,0x00,0x00]
v_min_i16_e64 v5, v1, s101 v_min_i16_e64 v5, v1, s101
Show All 22 Lines
v_min_i16_e64 v5, v1, 0 v_min_i16_e64 v5, v1, 0
// CHECK: [0x05,0x00,0x32,0xd1,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x32,0xd1,0x01,0x01,0x01,0x00]
v_min_i16_e64 v5, v1, -1 v_min_i16_e64 v5, v1, -1
// CHECK: [0x05,0x00,0x32,0xd1,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x32,0xd1,0x01,0x83,0x01,0x00]
v_min_i16_e64 v5, v1, 0.5 v_min_i16_e64 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min_i16_e64 v5, v1, -4.0 v_min_i16_e64 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_ldexp_f16 v5, v1, v2 v_ldexp_f16 v5, v1, v2
// CHECK: [0x01,0x05,0x0a,0x66] // CHECK: [0x01,0x05,0x0a,0x66]
v_ldexp_f16 v255, v1, v2 v_ldexp_f16 v255, v1, v2
// CHECK: [0x01,0x05,0xfe,0x67] // CHECK: [0x01,0x05,0xfe,0x67]
v_ldexp_f16 v5, v255, v2 v_ldexp_f16 v5, v255, v2
▲ Show 20 Lines • Show All 7,150 Lines • ▼ Show 20 Lines
v_mad_u32_u16 v5, 0, v2, v3 v_mad_u32_u16 v5, 0, v2, v3
// CHECK: [0x05,0x00,0xf1,0xd1,0x80,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xf1,0xd1,0x80,0x04,0x0e,0x04]
v_mad_u32_u16 v5, -1, v2, v3 v_mad_u32_u16 v5, -1, v2, v3
// CHECK: [0x05,0x00,0xf1,0xd1,0xc1,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xf1,0xd1,0xc1,0x04,0x0e,0x04]
v_mad_u32_u16 v5, 0.5, v2, v3 v_mad_u32_u16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u32_u16 v5, -4.0, v2, v3 v_mad_u32_u16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u32_u16 v5, v1, v255, v3 v_mad_u32_u16 v5, v1, v255, v3
// CHECK: [0x05,0x00,0xf1,0xd1,0x01,0xff,0x0f,0x04] // CHECK: [0x05,0x00,0xf1,0xd1,0x01,0xff,0x0f,0x04]
v_mad_u32_u16 v5, v1, s2, v3 v_mad_u32_u16 v5, v1, s2, v3
// CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x05,0x0c,0x04] // CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x05,0x0c,0x04]
v_mad_u32_u16 v5, v1, s101, v3 v_mad_u32_u16 v5, v1, s101, v3
Show All 22 Lines
v_mad_u32_u16 v5, v1, 0, v3 v_mad_u32_u16 v5, v1, 0, v3
// CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x01,0x0d,0x04] // CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x01,0x0d,0x04]
v_mad_u32_u16 v5, v1, -1, v3 v_mad_u32_u16 v5, v1, -1, v3
// CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x83,0x0d,0x04] // CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x83,0x0d,0x04]
v_mad_u32_u16 v5, v1, 0.5, v3 v_mad_u32_u16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u32_u16 v5, v1, -4.0, v3 v_mad_u32_u16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u32_u16 v5, v1, v2, v255 v_mad_u32_u16 v5, v1, v2, v255
// CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x05,0xfe,0x07] // CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x05,0xfe,0x07]
v_mad_u32_u16 v5, v1, v2, s3 v_mad_u32_u16 v5, v1, v2, s3
// CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x05,0x0e,0x00] // CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x05,0x0e,0x00]
v_mad_u32_u16 v5, v1, v2, s101 v_mad_u32_u16 v5, v1, v2, s101
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_mad_i32_i16 v5, 0, v2, v3 v_mad_i32_i16 v5, 0, v2, v3
// CHECK: [0x05,0x00,0xf2,0xd1,0x80,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xf2,0xd1,0x80,0x04,0x0e,0x04]
v_mad_i32_i16 v5, -1, v2, v3 v_mad_i32_i16 v5, -1, v2, v3
// CHECK: [0x05,0x00,0xf2,0xd1,0xc1,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xf2,0xd1,0xc1,0x04,0x0e,0x04]
v_mad_i32_i16 v5, 0.5, v2, v3 v_mad_i32_i16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i32_i16 v5, -4.0, v2, v3 v_mad_i32_i16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i32_i16 v5, v1, v255, v3 v_mad_i32_i16 v5, v1, v255, v3
// CHECK: [0x05,0x00,0xf2,0xd1,0x01,0xff,0x0f,0x04] // CHECK: [0x05,0x00,0xf2,0xd1,0x01,0xff,0x0f,0x04]
v_mad_i32_i16 v5, v1, s2, v3 v_mad_i32_i16 v5, v1, s2, v3
// CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x05,0x0c,0x04] // CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x05,0x0c,0x04]
v_mad_i32_i16 v5, v1, s101, v3 v_mad_i32_i16 v5, v1, s101, v3
Show All 22 Lines
v_mad_i32_i16 v5, v1, 0, v3 v_mad_i32_i16 v5, v1, 0, v3
// CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x01,0x0d,0x04] // CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x01,0x0d,0x04]
v_mad_i32_i16 v5, v1, -1, v3 v_mad_i32_i16 v5, v1, -1, v3
// CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x83,0x0d,0x04] // CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x83,0x0d,0x04]
v_mad_i32_i16 v5, v1, 0.5, v3 v_mad_i32_i16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i32_i16 v5, v1, -4.0, v3 v_mad_i32_i16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i32_i16 v5, v1, v2, v255 v_mad_i32_i16 v5, v1, v2, v255
// CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x05,0xfe,0x07] // CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x05,0xfe,0x07]
v_mad_i32_i16 v5, v1, v2, s3 v_mad_i32_i16 v5, v1, v2, s3
// CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x05,0x0e,0x00] // CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x05,0x0e,0x00]
v_mad_i32_i16 v5, v1, v2, s101 v_mad_i32_i16 v5, v1, v2, s101
▲ Show 20 Lines • Show All 400 Lines • ▼ Show 20 Lines
v_min3_i16 v5, 0, v2, v3 v_min3_i16 v5, 0, v2, v3
// CHECK: [0x05,0x00,0xf5,0xd1,0x80,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xf5,0xd1,0x80,0x04,0x0e,0x04]
v_min3_i16 v5, -1, v2, v3 v_min3_i16 v5, -1, v2, v3
// CHECK: [0x05,0x00,0xf5,0xd1,0xc1,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xf5,0xd1,0xc1,0x04,0x0e,0x04]
v_min3_i16 v5, 0.5, v2, v3 v_min3_i16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min3_i16 v5, -4.0, v2, v3 v_min3_i16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min3_i16 v5, v1, v255, v3 v_min3_i16 v5, v1, v255, v3
// CHECK: [0x05,0x00,0xf5,0xd1,0x01,0xff,0x0f,0x04] // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0xff,0x0f,0x04]
v_min3_i16 v5, v1, s2, v3 v_min3_i16 v5, v1, s2, v3
// CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x0c,0x04] // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x0c,0x04]
v_min3_i16 v5, v1, s101, v3 v_min3_i16 v5, v1, s101, v3
Show All 22 Lines
v_min3_i16 v5, v1, 0, v3 v_min3_i16 v5, v1, 0, v3
// CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x01,0x0d,0x04] // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x01,0x0d,0x04]
v_min3_i16 v5, v1, -1, v3 v_min3_i16 v5, v1, -1, v3
// CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x83,0x0d,0x04] // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x83,0x0d,0x04]
v_min3_i16 v5, v1, 0.5, v3 v_min3_i16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min3_i16 v5, v1, -4.0, v3 v_min3_i16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min3_i16 v5, v1, v2, v255 v_min3_i16 v5, v1, v2, v255
// CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0xfe,0x07] // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0xfe,0x07]
v_min3_i16 v5, v1, v2, s3 v_min3_i16 v5, v1, v2, s3
// CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x0e,0x00] // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x0e,0x00]
v_min3_i16 v5, v1, v2, s101 v_min3_i16 v5, v1, v2, s101
Show All 22 Lines
v_min3_i16 v5, v1, v2, 0 v_min3_i16 v5, v1, v2, 0
// CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x02,0x02] // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x02,0x02]
v_min3_i16 v5, v1, v2, -1 v_min3_i16 v5, v1, v2, -1
// CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x06,0x03] // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x06,0x03]
v_min3_i16 v5, v1, v2, 0.5 v_min3_i16 v5, v1, v2, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min3_i16 v5, v1, v2, -4.0 v_min3_i16 v5, v1, v2, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min3_i16 v5, v1, v2, v3 op_sel:[0,0,0,0] v_min3_i16 v5, v1, v2, v3 op_sel:[0,0,0,0]
// CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x0e,0x04]
v_min3_i16 v5, v1, v2, v3 op_sel:[1,0,0,0] v_min3_i16 v5, v1, v2, v3 op_sel:[1,0,0,0]
// CHECK: [0x05,0x08,0xf5,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x08,0xf5,0xd1,0x01,0x05,0x0e,0x04]
v_min3_i16 v5, v1, v2, v3 op_sel:[0,1,0,0] v_min3_i16 v5, v1, v2, v3 op_sel:[0,1,0,0]
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
v_min3_u16 v5, 0, v2, v3 v_min3_u16 v5, 0, v2, v3
// CHECK: [0x05,0x00,0xf6,0xd1,0x80,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xf6,0xd1,0x80,0x04,0x0e,0x04]
v_min3_u16 v5, -1, v2, v3 v_min3_u16 v5, -1, v2, v3
// CHECK: [0x05,0x00,0xf6,0xd1,0xc1,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xf6,0xd1,0xc1,0x04,0x0e,0x04]
v_min3_u16 v5, 0.5, v2, v3 v_min3_u16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min3_u16 v5, -4.0, v2, v3 v_min3_u16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min3_u16 v5, v1, v255, v3 v_min3_u16 v5, v1, v255, v3
// CHECK: [0x05,0x00,0xf6,0xd1,0x01,0xff,0x0f,0x04] // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0xff,0x0f,0x04]
v_min3_u16 v5, v1, s2, v3 v_min3_u16 v5, v1, s2, v3
// CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x0c,0x04] // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x0c,0x04]
v_min3_u16 v5, v1, s101, v3 v_min3_u16 v5, v1, s101, v3
Show All 22 Lines
v_min3_u16 v5, v1, 0, v3 v_min3_u16 v5, v1, 0, v3
// CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x01,0x0d,0x04] // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x01,0x0d,0x04]
v_min3_u16 v5, v1, -1, v3 v_min3_u16 v5, v1, -1, v3
// CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x83,0x0d,0x04] // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x83,0x0d,0x04]
v_min3_u16 v5, v1, 0.5, v3 v_min3_u16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min3_u16 v5, v1, -4.0, v3 v_min3_u16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min3_u16 v5, v1, v2, v255 v_min3_u16 v5, v1, v2, v255
// CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0xfe,0x07] // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0xfe,0x07]
v_min3_u16 v5, v1, v2, s3 v_min3_u16 v5, v1, v2, s3
// CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x0e,0x00] // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x0e,0x00]
v_min3_u16 v5, v1, v2, s101 v_min3_u16 v5, v1, v2, s101
Show All 22 Lines
v_min3_u16 v5, v1, v2, 0 v_min3_u16 v5, v1, v2, 0
// CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x02,0x02] // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x02,0x02]
v_min3_u16 v5, v1, v2, -1 v_min3_u16 v5, v1, v2, -1
// CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x06,0x03] // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x06,0x03]
v_min3_u16 v5, v1, v2, 0.5 v_min3_u16 v5, v1, v2, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min3_u16 v5, v1, v2, -4.0 v_min3_u16 v5, v1, v2, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_min3_u16 v5, v1, v2, v3 op_sel:[0,0,0,0] v_min3_u16 v5, v1, v2, v3 op_sel:[0,0,0,0]
// CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x0e,0x04]
v_min3_u16 v5, v1, v2, v3 op_sel:[1,0,0,0] v_min3_u16 v5, v1, v2, v3 op_sel:[1,0,0,0]
// CHECK: [0x05,0x08,0xf6,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x08,0xf6,0xd1,0x01,0x05,0x0e,0x04]
v_min3_u16 v5, v1, v2, v3 op_sel:[0,1,0,0] v_min3_u16 v5, v1, v2, v3 op_sel:[0,1,0,0]
▲ Show 20 Lines • Show All 223 Lines • ▼ Show 20 Lines
v_max3_i16 v5, 0, v2, v3 v_max3_i16 v5, 0, v2, v3
// CHECK: [0x05,0x00,0xf8,0xd1,0x80,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xf8,0xd1,0x80,0x04,0x0e,0x04]
v_max3_i16 v5, -1, v2, v3 v_max3_i16 v5, -1, v2, v3
// CHECK: [0x05,0x00,0xf8,0xd1,0xc1,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xf8,0xd1,0xc1,0x04,0x0e,0x04]
v_max3_i16 v5, 0.5, v2, v3 v_max3_i16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max3_i16 v5, -4.0, v2, v3 v_max3_i16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max3_i16 v5, v1, v255, v3 v_max3_i16 v5, v1, v255, v3
// CHECK: [0x05,0x00,0xf8,0xd1,0x01,0xff,0x0f,0x04] // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0xff,0x0f,0x04]
v_max3_i16 v5, v1, s2, v3 v_max3_i16 v5, v1, s2, v3
// CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x0c,0x04] // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x0c,0x04]
v_max3_i16 v5, v1, s101, v3 v_max3_i16 v5, v1, s101, v3
Show All 22 Lines
v_max3_i16 v5, v1, 0, v3 v_max3_i16 v5, v1, 0, v3
// CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x01,0x0d,0x04] // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x01,0x0d,0x04]
v_max3_i16 v5, v1, -1, v3 v_max3_i16 v5, v1, -1, v3
// CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x83,0x0d,0x04] // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x83,0x0d,0x04]
v_max3_i16 v5, v1, 0.5, v3 v_max3_i16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max3_i16 v5, v1, -4.0, v3 v_max3_i16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max3_i16 v5, v1, v2, v255 v_max3_i16 v5, v1, v2, v255
// CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0xfe,0x07] // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0xfe,0x07]
v_max3_i16 v5, v1, v2, s3 v_max3_i16 v5, v1, v2, s3
// CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x0e,0x00] // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x0e,0x00]
v_max3_i16 v5, v1, v2, s101 v_max3_i16 v5, v1, v2, s101
Show All 22 Lines
v_max3_i16 v5, v1, v2, 0 v_max3_i16 v5, v1, v2, 0
// CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x02,0x02] // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x02,0x02]
v_max3_i16 v5, v1, v2, -1 v_max3_i16 v5, v1, v2, -1
// CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x06,0x03] // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x06,0x03]
v_max3_i16 v5, v1, v2, 0.5 v_max3_i16 v5, v1, v2, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max3_i16 v5, v1, v2, -4.0 v_max3_i16 v5, v1, v2, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max3_i16 v5, v1, v2, v3 op_sel:[0,0,0,0] v_max3_i16 v5, v1, v2, v3 op_sel:[0,0,0,0]
// CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x0e,0x04]
v_max3_i16 v5, v1, v2, v3 op_sel:[1,0,0,0] v_max3_i16 v5, v1, v2, v3 op_sel:[1,0,0,0]
// CHECK: [0x05,0x08,0xf8,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x08,0xf8,0xd1,0x01,0x05,0x0e,0x04]
v_max3_i16 v5, v1, v2, v3 op_sel:[0,1,0,0] v_max3_i16 v5, v1, v2, v3 op_sel:[0,1,0,0]
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
v_max3_u16 v5, 0, v2, v3 v_max3_u16 v5, 0, v2, v3
// CHECK: [0x05,0x00,0xf9,0xd1,0x80,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xf9,0xd1,0x80,0x04,0x0e,0x04]
v_max3_u16 v5, -1, v2, v3 v_max3_u16 v5, -1, v2, v3
// CHECK: [0x05,0x00,0xf9,0xd1,0xc1,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xf9,0xd1,0xc1,0x04,0x0e,0x04]
v_max3_u16 v5, 0.5, v2, v3 v_max3_u16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max3_u16 v5, -4.0, v2, v3 v_max3_u16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max3_u16 v5, v1, v255, v3 v_max3_u16 v5, v1, v255, v3
// CHECK: [0x05,0x00,0xf9,0xd1,0x01,0xff,0x0f,0x04] // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0xff,0x0f,0x04]
v_max3_u16 v5, v1, s2, v3 v_max3_u16 v5, v1, s2, v3
// CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x0c,0x04] // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x0c,0x04]
v_max3_u16 v5, v1, s101, v3 v_max3_u16 v5, v1, s101, v3
Show All 22 Lines
v_max3_u16 v5, v1, 0, v3 v_max3_u16 v5, v1, 0, v3
// CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x01,0x0d,0x04] // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x01,0x0d,0x04]
v_max3_u16 v5, v1, -1, v3 v_max3_u16 v5, v1, -1, v3
// CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x83,0x0d,0x04] // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x83,0x0d,0x04]
v_max3_u16 v5, v1, 0.5, v3 v_max3_u16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max3_u16 v5, v1, -4.0, v3 v_max3_u16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max3_u16 v5, v1, v2, v255 v_max3_u16 v5, v1, v2, v255
// CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0xfe,0x07] // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0xfe,0x07]
v_max3_u16 v5, v1, v2, s3 v_max3_u16 v5, v1, v2, s3
// CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x0e,0x00] // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x0e,0x00]
v_max3_u16 v5, v1, v2, s101 v_max3_u16 v5, v1, v2, s101
Show All 22 Lines
v_max3_u16 v5, v1, v2, 0 v_max3_u16 v5, v1, v2, 0
// CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x02,0x02] // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x02,0x02]
v_max3_u16 v5, v1, v2, -1 v_max3_u16 v5, v1, v2, -1
// CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x06,0x03] // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x06,0x03]
v_max3_u16 v5, v1, v2, 0.5 v_max3_u16 v5, v1, v2, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max3_u16 v5, v1, v2, -4.0 v_max3_u16 v5, v1, v2, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_max3_u16 v5, v1, v2, v3 op_sel:[0,0,0,0] v_max3_u16 v5, v1, v2, v3 op_sel:[0,0,0,0]
// CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x0e,0x04]
v_max3_u16 v5, v1, v2, v3 op_sel:[1,0,0,0] v_max3_u16 v5, v1, v2, v3 op_sel:[1,0,0,0]
// CHECK: [0x05,0x08,0xf9,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x08,0xf9,0xd1,0x01,0x05,0x0e,0x04]
v_max3_u16 v5, v1, v2, v3 op_sel:[0,1,0,0] v_max3_u16 v5, v1, v2, v3 op_sel:[0,1,0,0]
▲ Show 20 Lines • Show All 223 Lines • ▼ Show 20 Lines
v_med3_i16 v5, 0, v2, v3 v_med3_i16 v5, 0, v2, v3
// CHECK: [0x05,0x00,0xfb,0xd1,0x80,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xfb,0xd1,0x80,0x04,0x0e,0x04]
v_med3_i16 v5, -1, v2, v3 v_med3_i16 v5, -1, v2, v3
// CHECK: [0x05,0x00,0xfb,0xd1,0xc1,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xfb,0xd1,0xc1,0x04,0x0e,0x04]
v_med3_i16 v5, 0.5, v2, v3 v_med3_i16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_med3_i16 v5, -4.0, v2, v3 v_med3_i16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_med3_i16 v5, v1, v255, v3 v_med3_i16 v5, v1, v255, v3
// CHECK: [0x05,0x00,0xfb,0xd1,0x01,0xff,0x0f,0x04] // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0xff,0x0f,0x04]
v_med3_i16 v5, v1, s2, v3 v_med3_i16 v5, v1, s2, v3
// CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x0c,0x04] // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x0c,0x04]
v_med3_i16 v5, v1, s101, v3 v_med3_i16 v5, v1, s101, v3
Show All 22 Lines
v_med3_i16 v5, v1, 0, v3 v_med3_i16 v5, v1, 0, v3
// CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x01,0x0d,0x04] // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x01,0x0d,0x04]
v_med3_i16 v5, v1, -1, v3 v_med3_i16 v5, v1, -1, v3
// CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x83,0x0d,0x04] // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x83,0x0d,0x04]
v_med3_i16 v5, v1, 0.5, v3 v_med3_i16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_med3_i16 v5, v1, -4.0, v3 v_med3_i16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_med3_i16 v5, v1, v2, v255 v_med3_i16 v5, v1, v2, v255
// CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0xfe,0x07] // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0xfe,0x07]
v_med3_i16 v5, v1, v2, s3 v_med3_i16 v5, v1, v2, s3
// CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x0e,0x00] // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x0e,0x00]
v_med3_i16 v5, v1, v2, s101 v_med3_i16 v5, v1, v2, s101
Show All 22 Lines
v_med3_i16 v5, v1, v2, 0 v_med3_i16 v5, v1, v2, 0
// CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x02,0x02] // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x02,0x02]
v_med3_i16 v5, v1, v2, -1 v_med3_i16 v5, v1, v2, -1
// CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x06,0x03] // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x06,0x03]
v_med3_i16 v5, v1, v2, 0.5 v_med3_i16 v5, v1, v2, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_med3_i16 v5, v1, v2, -4.0 v_med3_i16 v5, v1, v2, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_med3_i16 v5, v1, v2, v3 op_sel:[0,0,0,0] v_med3_i16 v5, v1, v2, v3 op_sel:[0,0,0,0]
// CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x0e,0x04]
v_med3_i16 v5, v1, v2, v3 op_sel:[1,0,0,0] v_med3_i16 v5, v1, v2, v3 op_sel:[1,0,0,0]
// CHECK: [0x05,0x08,0xfb,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x08,0xfb,0xd1,0x01,0x05,0x0e,0x04]
v_med3_i16 v5, v1, v2, v3 op_sel:[0,1,0,0] v_med3_i16 v5, v1, v2, v3 op_sel:[0,1,0,0]
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
v_med3_u16 v5, 0, v2, v3 v_med3_u16 v5, 0, v2, v3
// CHECK: [0x05,0x00,0xfc,0xd1,0x80,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xfc,0xd1,0x80,0x04,0x0e,0x04]
v_med3_u16 v5, -1, v2, v3 v_med3_u16 v5, -1, v2, v3
// CHECK: [0x05,0x00,0xfc,0xd1,0xc1,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0xfc,0xd1,0xc1,0x04,0x0e,0x04]
v_med3_u16 v5, 0.5, v2, v3 v_med3_u16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_med3_u16 v5, -4.0, v2, v3 v_med3_u16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_med3_u16 v5, v1, v255, v3 v_med3_u16 v5, v1, v255, v3
// CHECK: [0x05,0x00,0xfc,0xd1,0x01,0xff,0x0f,0x04] // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0xff,0x0f,0x04]
v_med3_u16 v5, v1, s2, v3 v_med3_u16 v5, v1, s2, v3
// CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x0c,0x04] // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x0c,0x04]
v_med3_u16 v5, v1, s101, v3 v_med3_u16 v5, v1, s101, v3
Show All 22 Lines
v_med3_u16 v5, v1, 0, v3 v_med3_u16 v5, v1, 0, v3
// CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x01,0x0d,0x04] // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x01,0x0d,0x04]
v_med3_u16 v5, v1, -1, v3 v_med3_u16 v5, v1, -1, v3
// CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x83,0x0d,0x04] // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x83,0x0d,0x04]
v_med3_u16 v5, v1, 0.5, v3 v_med3_u16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_med3_u16 v5, v1, -4.0, v3 v_med3_u16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_med3_u16 v5, v1, v2, v255 v_med3_u16 v5, v1, v2, v255
// CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0xfe,0x07] // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0xfe,0x07]
v_med3_u16 v5, v1, v2, s3 v_med3_u16 v5, v1, v2, s3
// CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x0e,0x00] // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x0e,0x00]
v_med3_u16 v5, v1, v2, s101 v_med3_u16 v5, v1, v2, s101
Show All 22 Lines
v_med3_u16 v5, v1, v2, 0 v_med3_u16 v5, v1, v2, 0
// CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x02,0x02] // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x02,0x02]
v_med3_u16 v5, v1, v2, -1 v_med3_u16 v5, v1, v2, -1
// CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x06,0x03] // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x06,0x03]
v_med3_u16 v5, v1, v2, 0.5 v_med3_u16 v5, v1, v2, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_med3_u16 v5, v1, v2, -4.0 v_med3_u16 v5, v1, v2, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_med3_u16 v5, v1, v2, v3 op_sel:[0,0,0,0] v_med3_u16 v5, v1, v2, v3 op_sel:[0,0,0,0]
// CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x0e,0x04]
v_med3_u16 v5, v1, v2, v3 op_sel:[1,0,0,0] v_med3_u16 v5, v1, v2, v3 op_sel:[1,0,0,0]
// CHECK: [0x05,0x08,0xfc,0xd1,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x08,0xfc,0xd1,0x01,0x05,0x0e,0x04]
v_med3_u16 v5, v1, v2, v3 op_sel:[0,1,0,0] v_med3_u16 v5, v1, v2, v3 op_sel:[0,1,0,0]
▲ Show 20 Lines • Show All 1,015 Lines • ▼ Show 20 Lines
v_mad_u16 v5, 0, v2, v3 v_mad_u16 v5, 0, v2, v3
// CHECK: [0x05,0x00,0x04,0xd2,0x80,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0x04,0xd2,0x80,0x04,0x0e,0x04]
v_mad_u16 v5, -1, v2, v3 v_mad_u16 v5, -1, v2, v3
// CHECK: [0x05,0x00,0x04,0xd2,0xc1,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0x04,0xd2,0xc1,0x04,0x0e,0x04]
v_mad_u16 v5, 0.5, v2, v3 v_mad_u16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u16 v5, -4.0, v2, v3 v_mad_u16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u16 v5, v1, v255, v3 v_mad_u16 v5, v1, v255, v3
// CHECK: [0x05,0x00,0x04,0xd2,0x01,0xff,0x0f,0x04] // CHECK: [0x05,0x00,0x04,0xd2,0x01,0xff,0x0f,0x04]
v_mad_u16 v5, v1, s2, v3 v_mad_u16 v5, v1, s2, v3
// CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x0c,0x04] // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x0c,0x04]
v_mad_u16 v5, v1, s101, v3 v_mad_u16 v5, v1, s101, v3
Show All 22 Lines
v_mad_u16 v5, v1, 0, v3 v_mad_u16 v5, v1, 0, v3
// CHECK: [0x05,0x00,0x04,0xd2,0x01,0x01,0x0d,0x04] // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x01,0x0d,0x04]
v_mad_u16 v5, v1, -1, v3 v_mad_u16 v5, v1, -1, v3
// CHECK: [0x05,0x00,0x04,0xd2,0x01,0x83,0x0d,0x04] // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x83,0x0d,0x04]
v_mad_u16 v5, v1, 0.5, v3 v_mad_u16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u16 v5, v1, -4.0, v3 v_mad_u16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u16 v5, v1, v2, v255 v_mad_u16 v5, v1, v2, v255
// CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0xfe,0x07] // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0xfe,0x07]
v_mad_u16 v5, v1, v2, s3 v_mad_u16 v5, v1, v2, s3
// CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x0e,0x00] // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x0e,0x00]
v_mad_u16 v5, v1, v2, s101 v_mad_u16 v5, v1, v2, s101
Show All 22 Lines
v_mad_u16 v5, v1, v2, 0 v_mad_u16 v5, v1, v2, 0
// CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x02,0x02] // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x02,0x02]
v_mad_u16 v5, v1, v2, -1 v_mad_u16 v5, v1, v2, -1
// CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x06,0x03] // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x06,0x03]
v_mad_u16 v5, v1, v2, 0.5 v_mad_u16 v5, v1, v2, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u16 v5, v1, v2, -4.0 v_mad_u16 v5, v1, v2, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_u16 v5, v1, v2, v3 op_sel:[0,0,0,0] v_mad_u16 v5, v1, v2, v3 op_sel:[0,0,0,0]
// CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x0e,0x04]
v_mad_u16 v5, v1, v2, v3 op_sel:[1,0,0,0] v_mad_u16 v5, v1, v2, v3 op_sel:[1,0,0,0]
// CHECK: [0x05,0x08,0x04,0xd2,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x08,0x04,0xd2,0x01,0x05,0x0e,0x04]
v_mad_u16 v5, v1, v2, v3 op_sel:[0,1,0,0] v_mad_u16 v5, v1, v2, v3 op_sel:[0,1,0,0]
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
v_mad_i16 v5, 0, v2, v3 v_mad_i16 v5, 0, v2, v3
// CHECK: [0x05,0x00,0x05,0xd2,0x80,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0x05,0xd2,0x80,0x04,0x0e,0x04]
v_mad_i16 v5, -1, v2, v3 v_mad_i16 v5, -1, v2, v3
// CHECK: [0x05,0x00,0x05,0xd2,0xc1,0x04,0x0e,0x04] // CHECK: [0x05,0x00,0x05,0xd2,0xc1,0x04,0x0e,0x04]
v_mad_i16 v5, 0.5, v2, v3 v_mad_i16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i16 v5, -4.0, v2, v3 v_mad_i16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i16 v5, v1, v255, v3 v_mad_i16 v5, v1, v255, v3
// CHECK: [0x05,0x00,0x05,0xd2,0x01,0xff,0x0f,0x04] // CHECK: [0x05,0x00,0x05,0xd2,0x01,0xff,0x0f,0x04]
v_mad_i16 v5, v1, s2, v3 v_mad_i16 v5, v1, s2, v3
// CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x0c,0x04] // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x0c,0x04]
v_mad_i16 v5, v1, s101, v3 v_mad_i16 v5, v1, s101, v3
Show All 22 Lines
v_mad_i16 v5, v1, 0, v3 v_mad_i16 v5, v1, 0, v3
// CHECK: [0x05,0x00,0x05,0xd2,0x01,0x01,0x0d,0x04] // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x01,0x0d,0x04]
v_mad_i16 v5, v1, -1, v3 v_mad_i16 v5, v1, -1, v3
// CHECK: [0x05,0x00,0x05,0xd2,0x01,0x83,0x0d,0x04] // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x83,0x0d,0x04]
v_mad_i16 v5, v1, 0.5, v3 v_mad_i16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i16 v5, v1, -4.0, v3 v_mad_i16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i16 v5, v1, v2, v255 v_mad_i16 v5, v1, v2, v255
// CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0xfe,0x07] // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0xfe,0x07]
v_mad_i16 v5, v1, v2, s3 v_mad_i16 v5, v1, v2, s3
// CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x0e,0x00] // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x0e,0x00]
v_mad_i16 v5, v1, v2, s101 v_mad_i16 v5, v1, v2, s101
Show All 22 Lines
v_mad_i16 v5, v1, v2, 0 v_mad_i16 v5, v1, v2, 0
// CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x02,0x02] // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x02,0x02]
v_mad_i16 v5, v1, v2, -1 v_mad_i16 v5, v1, v2, -1
// CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x06,0x03] // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x06,0x03]
v_mad_i16 v5, v1, v2, 0.5 v_mad_i16 v5, v1, v2, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i16 v5, v1, v2, -4.0 v_mad_i16 v5, v1, v2, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_mad_i16 v5, v1, v2, v3 op_sel:[0,0,0,0] v_mad_i16 v5, v1, v2, v3 op_sel:[0,0,0,0]
// CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x0e,0x04]
v_mad_i16 v5, v1, v2, v3 op_sel:[1,0,0,0] v_mad_i16 v5, v1, v2, v3 op_sel:[1,0,0,0]
// CHECK: [0x05,0x08,0x05,0xd2,0x01,0x05,0x0e,0x04] // CHECK: [0x05,0x08,0x05,0xd2,0x01,0x05,0x0e,0x04]
v_mad_i16 v5, v1, v2, v3 op_sel:[0,1,0,0] v_mad_i16 v5, v1, v2, v3 op_sel:[0,1,0,0]
▲ Show 20 Lines • Show All 3,193 Lines • ▼ Show 20 Lines
v_add_i16 v5, 0, v2 v_add_i16 v5, 0, v2
// CHECK: [0x05,0x00,0x9e,0xd2,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x9e,0xd2,0x80,0x04,0x02,0x00]
v_add_i16 v5, -1, v2 v_add_i16 v5, -1, v2
// CHECK: [0x05,0x00,0x9e,0xd2,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x9e,0xd2,0xc1,0x04,0x02,0x00]
v_add_i16 v5, 0.5, v2 v_add_i16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_add_i16 v5, -4.0, v2 v_add_i16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_add_i16 v5, v1, v255 v_add_i16 v5, v1, v255
// CHECK: [0x05,0x00,0x9e,0xd2,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x9e,0xd2,0x01,0xff,0x03,0x00]
v_add_i16 v5, v1, s2 v_add_i16 v5, v1, s2
// CHECK: [0x05,0x00,0x9e,0xd2,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x9e,0xd2,0x01,0x05,0x00,0x00]
v_add_i16 v5, v1, s101 v_add_i16 v5, v1, s101
Show All 22 Lines
v_add_i16 v5, v1, 0 v_add_i16 v5, v1, 0
// CHECK: [0x05,0x00,0x9e,0xd2,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x9e,0xd2,0x01,0x01,0x01,0x00]
v_add_i16 v5, v1, -1 v_add_i16 v5, v1, -1
// CHECK: [0x05,0x00,0x9e,0xd2,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x9e,0xd2,0x01,0x83,0x01,0x00]
v_add_i16 v5, v1, 0.5 v_add_i16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_add_i16 v5, v1, -4.0 v_add_i16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_add_i16 v5, v1, v2 op_sel:[0,0,0] v_add_i16 v5, v1, v2 op_sel:[0,0,0]
// CHECK: [0x05,0x00,0x9e,0xd2,0x01,0x05,0x02,0x00] // CHECK: [0x05,0x00,0x9e,0xd2,0x01,0x05,0x02,0x00]
v_add_i16 v5, v1, v2 op_sel:[1,0,0] v_add_i16 v5, v1, v2 op_sel:[1,0,0]
// CHECK: [0x05,0x08,0x9e,0xd2,0x01,0x05,0x02,0x00] // CHECK: [0x05,0x08,0x9e,0xd2,0x01,0x05,0x02,0x00]
v_add_i16 v5, v1, v2 op_sel:[0,1,0] v_add_i16 v5, v1, v2 op_sel:[0,1,0]
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
v_sub_i16 v5, 0, v2 v_sub_i16 v5, 0, v2
// CHECK: [0x05,0x00,0x9f,0xd2,0x80,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x9f,0xd2,0x80,0x04,0x02,0x00]
v_sub_i16 v5, -1, v2 v_sub_i16 v5, -1, v2
// CHECK: [0x05,0x00,0x9f,0xd2,0xc1,0x04,0x02,0x00] // CHECK: [0x05,0x00,0x9f,0xd2,0xc1,0x04,0x02,0x00]
v_sub_i16 v5, 0.5, v2 v_sub_i16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_sub_i16 v5, -4.0, v2 v_sub_i16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_sub_i16 v5, v1, v255 v_sub_i16 v5, v1, v255
// CHECK: [0x05,0x00,0x9f,0xd2,0x01,0xff,0x03,0x00] // CHECK: [0x05,0x00,0x9f,0xd2,0x01,0xff,0x03,0x00]
v_sub_i16 v5, v1, s2 v_sub_i16 v5, v1, s2
// CHECK: [0x05,0x00,0x9f,0xd2,0x01,0x05,0x00,0x00] // CHECK: [0x05,0x00,0x9f,0xd2,0x01,0x05,0x00,0x00]
v_sub_i16 v5, v1, s101 v_sub_i16 v5, v1, s101
Show All 22 Lines
v_sub_i16 v5, v1, 0 v_sub_i16 v5, v1, 0
// CHECK: [0x05,0x00,0x9f,0xd2,0x01,0x01,0x01,0x00] // CHECK: [0x05,0x00,0x9f,0xd2,0x01,0x01,0x01,0x00]
v_sub_i16 v5, v1, -1 v_sub_i16 v5, v1, -1
// CHECK: [0x05,0x00,0x9f,0xd2,0x01,0x83,0x01,0x00] // CHECK: [0x05,0x00,0x9f,0xd2,0x01,0x83,0x01,0x00]
v_sub_i16 v5, v1, 0.5 v_sub_i16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_sub_i16 v5, v1, -4.0 v_sub_i16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_sub_i16 v5, v1, v2 op_sel:[0,0,0] v_sub_i16 v5, v1, v2 op_sel:[0,0,0]
// CHECK: [0x05,0x00,0x9f,0xd2,0x01,0x05,0x02,0x00] // CHECK: [0x05,0x00,0x9f,0xd2,0x01,0x05,0x02,0x00]
v_sub_i16 v5, v1, v2 op_sel:[1,0,0] v_sub_i16 v5, v1, v2 op_sel:[1,0,0]
// CHECK: [0x05,0x08,0x9f,0xd2,0x01,0x05,0x02,0x00] // CHECK: [0x05,0x08,0x9f,0xd2,0x01,0x05,0x02,0x00]
v_sub_i16 v5, v1, v2 op_sel:[0,1,0] v_sub_i16 v5, v1, v2 op_sel:[0,1,0]
▲ Show 20 Lines • Show All 169 Lines • ▼ Show 20 Lines
v_pk_mad_i16 v5, 0, v2, v3 v_pk_mad_i16 v5, 0, v2, v3
// CHECK: [0x05,0x40,0x80,0xd3,0x80,0x04,0x0e,0x1c] // CHECK: [0x05,0x40,0x80,0xd3,0x80,0x04,0x0e,0x1c]
v_pk_mad_i16 v5, -1, v2, v3 v_pk_mad_i16 v5, -1, v2, v3
// CHECK: [0x05,0x40,0x80,0xd3,0xc1,0x04,0x0e,0x1c] // CHECK: [0x05,0x40,0x80,0xd3,0xc1,0x04,0x0e,0x1c]
v_pk_mad_i16 v5, 0.5, v2, v3 v_pk_mad_i16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mad_i16 v5, -4.0, v2, v3 v_pk_mad_i16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mad_i16 v5, v1, v255, v3 v_pk_mad_i16 v5, v1, v255, v3
// CHECK: [0x05,0x40,0x80,0xd3,0x01,0xff,0x0f,0x1c] // CHECK: [0x05,0x40,0x80,0xd3,0x01,0xff,0x0f,0x1c]
v_pk_mad_i16 v5, v1, s2, v3 v_pk_mad_i16 v5, v1, s2, v3
// CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0x0c,0x1c] // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0x0c,0x1c]
v_pk_mad_i16 v5, v1, s101, v3 v_pk_mad_i16 v5, v1, s101, v3
Show All 22 Lines
v_pk_mad_i16 v5, v1, 0, v3 v_pk_mad_i16 v5, v1, 0, v3
// CHECK: [0x05,0x40,0x80,0xd3,0x01,0x01,0x0d,0x1c] // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x01,0x0d,0x1c]
v_pk_mad_i16 v5, v1, -1, v3 v_pk_mad_i16 v5, v1, -1, v3
// CHECK: [0x05,0x40,0x80,0xd3,0x01,0x83,0x0d,0x1c] // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x83,0x0d,0x1c]
v_pk_mad_i16 v5, v1, 0.5, v3 v_pk_mad_i16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mad_i16 v5, v1, -4.0, v3 v_pk_mad_i16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mad_i16 v5, v1, v2, v255 v_pk_mad_i16 v5, v1, v2, v255
// CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0xfe,0x1f] // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0xfe,0x1f]
v_pk_mad_i16 v5, v1, v2, s3 v_pk_mad_i16 v5, v1, v2, s3
// CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0x0e,0x18] // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0x0e,0x18]
v_pk_mad_i16 v5, v1, v2, s101 v_pk_mad_i16 v5, v1, v2, s101
Show All 22 Lines
v_pk_mad_i16 v5, v1, v2, 0 v_pk_mad_i16 v5, v1, v2, 0
// CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0x02,0x1a] // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0x02,0x1a]
v_pk_mad_i16 v5, v1, v2, -1 v_pk_mad_i16 v5, v1, v2, -1
// CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0x06,0x1b] // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0x06,0x1b]
v_pk_mad_i16 v5, v1, v2, 0.5 v_pk_mad_i16 v5, v1, v2, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mad_i16 v5, v1, v2, -4.0 v_pk_mad_i16 v5, v1, v2, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mad_i16 v5, v1, v2, v3 op_sel:[1,0,0] v_pk_mad_i16 v5, v1, v2, v3 op_sel:[1,0,0]
// CHECK: [0x05,0x48,0x80,0xd3,0x01,0x05,0x0e,0x1c] // CHECK: [0x05,0x48,0x80,0xd3,0x01,0x05,0x0e,0x1c]
v_pk_mad_i16 v5, v1, v2, v3 op_sel:[0,1,0] v_pk_mad_i16 v5, v1, v2, v3 op_sel:[0,1,0]
// CHECK: [0x05,0x50,0x80,0xd3,0x01,0x05,0x0e,0x1c] // CHECK: [0x05,0x50,0x80,0xd3,0x01,0x05,0x0e,0x1c]
v_pk_mad_i16 v5, v1, v2, v3 op_sel:[0,0,1] v_pk_mad_i16 v5, v1, v2, v3 op_sel:[0,0,1]
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
v_pk_mul_lo_u16 v5, 0, v2 v_pk_mul_lo_u16 v5, 0, v2
// CHECK: [0x05,0x00,0x81,0xd3,0x80,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x81,0xd3,0x80,0x04,0x02,0x18]
v_pk_mul_lo_u16 v5, -1, v2 v_pk_mul_lo_u16 v5, -1, v2
// CHECK: [0x05,0x00,0x81,0xd3,0xc1,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x81,0xd3,0xc1,0x04,0x02,0x18]
v_pk_mul_lo_u16 v5, 0.5, v2 v_pk_mul_lo_u16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mul_lo_u16 v5, -4.0, v2 v_pk_mul_lo_u16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mul_lo_u16 v5, v1, v255 v_pk_mul_lo_u16 v5, v1, v255
// CHECK: [0x05,0x00,0x81,0xd3,0x01,0xff,0x03,0x18] // CHECK: [0x05,0x00,0x81,0xd3,0x01,0xff,0x03,0x18]
v_pk_mul_lo_u16 v5, v1, s2 v_pk_mul_lo_u16 v5, v1, s2
// CHECK: [0x05,0x00,0x81,0xd3,0x01,0x05,0x00,0x18] // CHECK: [0x05,0x00,0x81,0xd3,0x01,0x05,0x00,0x18]
v_pk_mul_lo_u16 v5, v1, s101 v_pk_mul_lo_u16 v5, v1, s101
Show All 25 Lines
v_pk_mul_lo_u16 v5, v1, 0 v_pk_mul_lo_u16 v5, v1, 0
// CHECK: [0x05,0x00,0x81,0xd3,0x01,0x01,0x01,0x18] // CHECK: [0x05,0x00,0x81,0xd3,0x01,0x01,0x01,0x18]
v_pk_mul_lo_u16 v5, v1, -1 v_pk_mul_lo_u16 v5, v1, -1
// CHECK: [0x05,0x00,0x81,0xd3,0x01,0x83,0x01,0x18] // CHECK: [0x05,0x00,0x81,0xd3,0x01,0x83,0x01,0x18]
v_pk_mul_lo_u16 v5, v1, 0.5 v_pk_mul_lo_u16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mul_lo_u16 v5, v1, -4.0 v_pk_mul_lo_u16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mul_lo_u16 v5, v1, v2 op_sel:[1,0] v_pk_mul_lo_u16 v5, v1, v2 op_sel:[1,0]
// CHECK: [0x05,0x08,0x81,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x08,0x81,0xd3,0x01,0x05,0x02,0x18]
v_pk_mul_lo_u16 v5, v1, v2 op_sel:[0,1] v_pk_mul_lo_u16 v5, v1, v2 op_sel:[0,1]
// CHECK: [0x05,0x10,0x81,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x10,0x81,0xd3,0x01,0x05,0x02,0x18]
v_pk_mul_lo_u16 v5, v1, v2 op_sel:[1,1] v_pk_mul_lo_u16 v5, v1, v2 op_sel:[1,1]
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
v_pk_add_i16 v5, 0, v2 v_pk_add_i16 v5, 0, v2
// CHECK: [0x05,0x00,0x82,0xd3,0x80,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x82,0xd3,0x80,0x04,0x02,0x18]
v_pk_add_i16 v5, -1, v2 v_pk_add_i16 v5, -1, v2
// CHECK: [0x05,0x00,0x82,0xd3,0xc1,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x82,0xd3,0xc1,0x04,0x02,0x18]
v_pk_add_i16 v5, 0.5, v2 v_pk_add_i16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_add_i16 v5, -4.0, v2 v_pk_add_i16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_add_i16 v5, v1, v255 v_pk_add_i16 v5, v1, v255
// CHECK: [0x05,0x00,0x82,0xd3,0x01,0xff,0x03,0x18] // CHECK: [0x05,0x00,0x82,0xd3,0x01,0xff,0x03,0x18]
v_pk_add_i16 v5, v1, s2 v_pk_add_i16 v5, v1, s2
// CHECK: [0x05,0x00,0x82,0xd3,0x01,0x05,0x00,0x18] // CHECK: [0x05,0x00,0x82,0xd3,0x01,0x05,0x00,0x18]
v_pk_add_i16 v5, v1, s101 v_pk_add_i16 v5, v1, s101
Show All 25 Lines
v_pk_add_i16 v5, v1, 0 v_pk_add_i16 v5, v1, 0
// CHECK: [0x05,0x00,0x82,0xd3,0x01,0x01,0x01,0x18] // CHECK: [0x05,0x00,0x82,0xd3,0x01,0x01,0x01,0x18]
v_pk_add_i16 v5, v1, -1 v_pk_add_i16 v5, v1, -1
// CHECK: [0x05,0x00,0x82,0xd3,0x01,0x83,0x01,0x18] // CHECK: [0x05,0x00,0x82,0xd3,0x01,0x83,0x01,0x18]
v_pk_add_i16 v5, v1, 0.5 v_pk_add_i16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_add_i16 v5, v1, -4.0 v_pk_add_i16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_add_i16 v5, v1, v2 op_sel:[1,0] v_pk_add_i16 v5, v1, v2 op_sel:[1,0]
// CHECK: [0x05,0x08,0x82,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x08,0x82,0xd3,0x01,0x05,0x02,0x18]
v_pk_add_i16 v5, v1, v2 op_sel:[0,1] v_pk_add_i16 v5, v1, v2 op_sel:[0,1]
// CHECK: [0x05,0x10,0x82,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x10,0x82,0xd3,0x01,0x05,0x02,0x18]
v_pk_add_i16 v5, v1, v2 op_sel:[1,1] v_pk_add_i16 v5, v1, v2 op_sel:[1,1]
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
v_pk_sub_i16 v5, 0, v2 v_pk_sub_i16 v5, 0, v2
// CHECK: [0x05,0x00,0x83,0xd3,0x80,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x83,0xd3,0x80,0x04,0x02,0x18]
v_pk_sub_i16 v5, -1, v2 v_pk_sub_i16 v5, -1, v2
// CHECK: [0x05,0x00,0x83,0xd3,0xc1,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x83,0xd3,0xc1,0x04,0x02,0x18]
v_pk_sub_i16 v5, 0.5, v2 v_pk_sub_i16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_sub_i16 v5, -4.0, v2 v_pk_sub_i16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_sub_i16 v5, v1, v255 v_pk_sub_i16 v5, v1, v255
// CHECK: [0x05,0x00,0x83,0xd3,0x01,0xff,0x03,0x18] // CHECK: [0x05,0x00,0x83,0xd3,0x01,0xff,0x03,0x18]
v_pk_sub_i16 v5, v1, s2 v_pk_sub_i16 v5, v1, s2
// CHECK: [0x05,0x00,0x83,0xd3,0x01,0x05,0x00,0x18] // CHECK: [0x05,0x00,0x83,0xd3,0x01,0x05,0x00,0x18]
v_pk_sub_i16 v5, v1, s101 v_pk_sub_i16 v5, v1, s101
Show All 25 Lines
v_pk_sub_i16 v5, v1, 0 v_pk_sub_i16 v5, v1, 0
// CHECK: [0x05,0x00,0x83,0xd3,0x01,0x01,0x01,0x18] // CHECK: [0x05,0x00,0x83,0xd3,0x01,0x01,0x01,0x18]
v_pk_sub_i16 v5, v1, -1 v_pk_sub_i16 v5, v1, -1
// CHECK: [0x05,0x00,0x83,0xd3,0x01,0x83,0x01,0x18] // CHECK: [0x05,0x00,0x83,0xd3,0x01,0x83,0x01,0x18]
v_pk_sub_i16 v5, v1, 0.5 v_pk_sub_i16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_sub_i16 v5, v1, -4.0 v_pk_sub_i16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_sub_i16 v5, v1, v2 op_sel:[1,0] v_pk_sub_i16 v5, v1, v2 op_sel:[1,0]
// CHECK: [0x05,0x08,0x83,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x08,0x83,0xd3,0x01,0x05,0x02,0x18]
v_pk_sub_i16 v5, v1, v2 op_sel:[0,1] v_pk_sub_i16 v5, v1, v2 op_sel:[0,1]
// CHECK: [0x05,0x10,0x83,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x10,0x83,0xd3,0x01,0x05,0x02,0x18]
v_pk_sub_i16 v5, v1, v2 op_sel:[1,1] v_pk_sub_i16 v5, v1, v2 op_sel:[1,1]
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
v_pk_lshlrev_b16 v5, 0, v2 v_pk_lshlrev_b16 v5, 0, v2
// CHECK: [0x05,0x00,0x84,0xd3,0x80,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x84,0xd3,0x80,0x04,0x02,0x18]
v_pk_lshlrev_b16 v5, -1, v2 v_pk_lshlrev_b16 v5, -1, v2
// CHECK: [0x05,0x00,0x84,0xd3,0xc1,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x84,0xd3,0xc1,0x04,0x02,0x18]
v_pk_lshlrev_b16 v5, 0.5, v2 v_pk_lshlrev_b16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_lshlrev_b16 v5, -4.0, v2 v_pk_lshlrev_b16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_lshlrev_b16 v5, v1, v255 v_pk_lshlrev_b16 v5, v1, v255
// CHECK: [0x05,0x00,0x84,0xd3,0x01,0xff,0x03,0x18] // CHECK: [0x05,0x00,0x84,0xd3,0x01,0xff,0x03,0x18]
v_pk_lshlrev_b16 v5, v1, s2 v_pk_lshlrev_b16 v5, v1, s2
// CHECK: [0x05,0x00,0x84,0xd3,0x01,0x05,0x00,0x18] // CHECK: [0x05,0x00,0x84,0xd3,0x01,0x05,0x00,0x18]
v_pk_lshlrev_b16 v5, v1, s101 v_pk_lshlrev_b16 v5, v1, s101
Show All 25 Lines
v_pk_lshlrev_b16 v5, v1, 0 v_pk_lshlrev_b16 v5, v1, 0
// CHECK: [0x05,0x00,0x84,0xd3,0x01,0x01,0x01,0x18] // CHECK: [0x05,0x00,0x84,0xd3,0x01,0x01,0x01,0x18]
v_pk_lshlrev_b16 v5, v1, -1 v_pk_lshlrev_b16 v5, v1, -1
// CHECK: [0x05,0x00,0x84,0xd3,0x01,0x83,0x01,0x18] // CHECK: [0x05,0x00,0x84,0xd3,0x01,0x83,0x01,0x18]
v_pk_lshlrev_b16 v5, v1, 0.5 v_pk_lshlrev_b16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_lshlrev_b16 v5, v1, -4.0 v_pk_lshlrev_b16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_lshlrev_b16 v5, v1, v2 op_sel:[1,0] v_pk_lshlrev_b16 v5, v1, v2 op_sel:[1,0]
// CHECK: [0x05,0x08,0x84,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x08,0x84,0xd3,0x01,0x05,0x02,0x18]
v_pk_lshlrev_b16 v5, v1, v2 op_sel:[0,1] v_pk_lshlrev_b16 v5, v1, v2 op_sel:[0,1]
// CHECK: [0x05,0x10,0x84,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x10,0x84,0xd3,0x01,0x05,0x02,0x18]
v_pk_lshlrev_b16 v5, v1, v2 op_sel:[1,1] v_pk_lshlrev_b16 v5, v1, v2 op_sel:[1,1]
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
v_pk_lshrrev_b16 v5, 0, v2 v_pk_lshrrev_b16 v5, 0, v2
// CHECK: [0x05,0x00,0x85,0xd3,0x80,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x85,0xd3,0x80,0x04,0x02,0x18]
v_pk_lshrrev_b16 v5, -1, v2 v_pk_lshrrev_b16 v5, -1, v2
// CHECK: [0x05,0x00,0x85,0xd3,0xc1,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x85,0xd3,0xc1,0x04,0x02,0x18]
v_pk_lshrrev_b16 v5, 0.5, v2 v_pk_lshrrev_b16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_lshrrev_b16 v5, -4.0, v2 v_pk_lshrrev_b16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_lshrrev_b16 v5, v1, v255 v_pk_lshrrev_b16 v5, v1, v255
// CHECK: [0x05,0x00,0x85,0xd3,0x01,0xff,0x03,0x18] // CHECK: [0x05,0x00,0x85,0xd3,0x01,0xff,0x03,0x18]
v_pk_lshrrev_b16 v5, v1, s2 v_pk_lshrrev_b16 v5, v1, s2
// CHECK: [0x05,0x00,0x85,0xd3,0x01,0x05,0x00,0x18] // CHECK: [0x05,0x00,0x85,0xd3,0x01,0x05,0x00,0x18]
v_pk_lshrrev_b16 v5, v1, s101 v_pk_lshrrev_b16 v5, v1, s101
Show All 25 Lines
v_pk_lshrrev_b16 v5, v1, 0 v_pk_lshrrev_b16 v5, v1, 0
// CHECK: [0x05,0x00,0x85,0xd3,0x01,0x01,0x01,0x18] // CHECK: [0x05,0x00,0x85,0xd3,0x01,0x01,0x01,0x18]
v_pk_lshrrev_b16 v5, v1, -1 v_pk_lshrrev_b16 v5, v1, -1
// CHECK: [0x05,0x00,0x85,0xd3,0x01,0x83,0x01,0x18] // CHECK: [0x05,0x00,0x85,0xd3,0x01,0x83,0x01,0x18]
v_pk_lshrrev_b16 v5, v1, 0.5 v_pk_lshrrev_b16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_lshrrev_b16 v5, v1, -4.0 v_pk_lshrrev_b16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_lshrrev_b16 v5, v1, v2 op_sel:[1,0] v_pk_lshrrev_b16 v5, v1, v2 op_sel:[1,0]
// CHECK: [0x05,0x08,0x85,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x08,0x85,0xd3,0x01,0x05,0x02,0x18]
v_pk_lshrrev_b16 v5, v1, v2 op_sel:[0,1] v_pk_lshrrev_b16 v5, v1, v2 op_sel:[0,1]
// CHECK: [0x05,0x10,0x85,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x10,0x85,0xd3,0x01,0x05,0x02,0x18]
v_pk_lshrrev_b16 v5, v1, v2 op_sel:[1,1] v_pk_lshrrev_b16 v5, v1, v2 op_sel:[1,1]
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
v_pk_ashrrev_i16 v5, 0, v2 v_pk_ashrrev_i16 v5, 0, v2
// CHECK: [0x05,0x00,0x86,0xd3,0x80,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x86,0xd3,0x80,0x04,0x02,0x18]
v_pk_ashrrev_i16 v5, -1, v2 v_pk_ashrrev_i16 v5, -1, v2
// CHECK: [0x05,0x00,0x86,0xd3,0xc1,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x86,0xd3,0xc1,0x04,0x02,0x18]
v_pk_ashrrev_i16 v5, 0.5, v2 v_pk_ashrrev_i16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_ashrrev_i16 v5, -4.0, v2 v_pk_ashrrev_i16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_ashrrev_i16 v5, v1, v255 v_pk_ashrrev_i16 v5, v1, v255
// CHECK: [0x05,0x00,0x86,0xd3,0x01,0xff,0x03,0x18] // CHECK: [0x05,0x00,0x86,0xd3,0x01,0xff,0x03,0x18]
v_pk_ashrrev_i16 v5, v1, s2 v_pk_ashrrev_i16 v5, v1, s2
// CHECK: [0x05,0x00,0x86,0xd3,0x01,0x05,0x00,0x18] // CHECK: [0x05,0x00,0x86,0xd3,0x01,0x05,0x00,0x18]
v_pk_ashrrev_i16 v5, v1, s101 v_pk_ashrrev_i16 v5, v1, s101
Show All 25 Lines
v_pk_ashrrev_i16 v5, v1, 0 v_pk_ashrrev_i16 v5, v1, 0
// CHECK: [0x05,0x00,0x86,0xd3,0x01,0x01,0x01,0x18] // CHECK: [0x05,0x00,0x86,0xd3,0x01,0x01,0x01,0x18]
v_pk_ashrrev_i16 v5, v1, -1 v_pk_ashrrev_i16 v5, v1, -1
// CHECK: [0x05,0x00,0x86,0xd3,0x01,0x83,0x01,0x18] // CHECK: [0x05,0x00,0x86,0xd3,0x01,0x83,0x01,0x18]
v_pk_ashrrev_i16 v5, v1, 0.5 v_pk_ashrrev_i16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_ashrrev_i16 v5, v1, -4.0 v_pk_ashrrev_i16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_ashrrev_i16 v5, v1, v2 op_sel:[1,0] v_pk_ashrrev_i16 v5, v1, v2 op_sel:[1,0]
// CHECK: [0x05,0x08,0x86,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x08,0x86,0xd3,0x01,0x05,0x02,0x18]
v_pk_ashrrev_i16 v5, v1, v2 op_sel:[0,1] v_pk_ashrrev_i16 v5, v1, v2 op_sel:[0,1]
// CHECK: [0x05,0x10,0x86,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x10,0x86,0xd3,0x01,0x05,0x02,0x18]
v_pk_ashrrev_i16 v5, v1, v2 op_sel:[1,1] v_pk_ashrrev_i16 v5, v1, v2 op_sel:[1,1]
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
v_pk_max_i16 v5, 0, v2 v_pk_max_i16 v5, 0, v2
// CHECK: [0x05,0x00,0x87,0xd3,0x80,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x87,0xd3,0x80,0x04,0x02,0x18]
v_pk_max_i16 v5, -1, v2 v_pk_max_i16 v5, -1, v2
// CHECK: [0x05,0x00,0x87,0xd3,0xc1,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x87,0xd3,0xc1,0x04,0x02,0x18]
v_pk_max_i16 v5, 0.5, v2 v_pk_max_i16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_max_i16 v5, -4.0, v2 v_pk_max_i16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_max_i16 v5, v1, v255 v_pk_max_i16 v5, v1, v255
// CHECK: [0x05,0x00,0x87,0xd3,0x01,0xff,0x03,0x18] // CHECK: [0x05,0x00,0x87,0xd3,0x01,0xff,0x03,0x18]
v_pk_max_i16 v5, v1, s2 v_pk_max_i16 v5, v1, s2
// CHECK: [0x05,0x00,0x87,0xd3,0x01,0x05,0x00,0x18] // CHECK: [0x05,0x00,0x87,0xd3,0x01,0x05,0x00,0x18]
v_pk_max_i16 v5, v1, s101 v_pk_max_i16 v5, v1, s101
Show All 25 Lines
v_pk_max_i16 v5, v1, 0 v_pk_max_i16 v5, v1, 0
// CHECK: [0x05,0x00,0x87,0xd3,0x01,0x01,0x01,0x18] // CHECK: [0x05,0x00,0x87,0xd3,0x01,0x01,0x01,0x18]
v_pk_max_i16 v5, v1, -1 v_pk_max_i16 v5, v1, -1
// CHECK: [0x05,0x00,0x87,0xd3,0x01,0x83,0x01,0x18] // CHECK: [0x05,0x00,0x87,0xd3,0x01,0x83,0x01,0x18]
v_pk_max_i16 v5, v1, 0.5 v_pk_max_i16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_max_i16 v5, v1, -4.0 v_pk_max_i16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_max_i16 v5, v1, v2 op_sel:[1,0] v_pk_max_i16 v5, v1, v2 op_sel:[1,0]
// CHECK: [0x05,0x08,0x87,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x08,0x87,0xd3,0x01,0x05,0x02,0x18]
v_pk_max_i16 v5, v1, v2 op_sel:[0,1] v_pk_max_i16 v5, v1, v2 op_sel:[0,1]
// CHECK: [0x05,0x10,0x87,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x10,0x87,0xd3,0x01,0x05,0x02,0x18]
v_pk_max_i16 v5, v1, v2 op_sel:[1,1] v_pk_max_i16 v5, v1, v2 op_sel:[1,1]
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
v_pk_min_i16 v5, 0, v2 v_pk_min_i16 v5, 0, v2
// CHECK: [0x05,0x00,0x88,0xd3,0x80,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x88,0xd3,0x80,0x04,0x02,0x18]
v_pk_min_i16 v5, -1, v2 v_pk_min_i16 v5, -1, v2
// CHECK: [0x05,0x00,0x88,0xd3,0xc1,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x88,0xd3,0xc1,0x04,0x02,0x18]
v_pk_min_i16 v5, 0.5, v2 v_pk_min_i16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_min_i16 v5, -4.0, v2 v_pk_min_i16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_min_i16 v5, v1, v255 v_pk_min_i16 v5, v1, v255
// CHECK: [0x05,0x00,0x88,0xd3,0x01,0xff,0x03,0x18] // CHECK: [0x05,0x00,0x88,0xd3,0x01,0xff,0x03,0x18]
v_pk_min_i16 v5, v1, s2 v_pk_min_i16 v5, v1, s2
// CHECK: [0x05,0x00,0x88,0xd3,0x01,0x05,0x00,0x18] // CHECK: [0x05,0x00,0x88,0xd3,0x01,0x05,0x00,0x18]
v_pk_min_i16 v5, v1, s101 v_pk_min_i16 v5, v1, s101
Show All 25 Lines
v_pk_min_i16 v5, v1, 0 v_pk_min_i16 v5, v1, 0
// CHECK: [0x05,0x00,0x88,0xd3,0x01,0x01,0x01,0x18] // CHECK: [0x05,0x00,0x88,0xd3,0x01,0x01,0x01,0x18]
v_pk_min_i16 v5, v1, -1 v_pk_min_i16 v5, v1, -1
// CHECK: [0x05,0x00,0x88,0xd3,0x01,0x83,0x01,0x18] // CHECK: [0x05,0x00,0x88,0xd3,0x01,0x83,0x01,0x18]
v_pk_min_i16 v5, v1, 0.5 v_pk_min_i16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_min_i16 v5, v1, -4.0 v_pk_min_i16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_min_i16 v5, v1, v2 op_sel:[1,0] v_pk_min_i16 v5, v1, v2 op_sel:[1,0]
// CHECK: [0x05,0x08,0x88,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x08,0x88,0xd3,0x01,0x05,0x02,0x18]
v_pk_min_i16 v5, v1, v2 op_sel:[0,1] v_pk_min_i16 v5, v1, v2 op_sel:[0,1]
// CHECK: [0x05,0x10,0x88,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x10,0x88,0xd3,0x01,0x05,0x02,0x18]
v_pk_min_i16 v5, v1, v2 op_sel:[1,1] v_pk_min_i16 v5, v1, v2 op_sel:[1,1]
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
v_pk_mad_u16 v5, 0, v2, v3 v_pk_mad_u16 v5, 0, v2, v3
// CHECK: [0x05,0x40,0x89,0xd3,0x80,0x04,0x0e,0x1c] // CHECK: [0x05,0x40,0x89,0xd3,0x80,0x04,0x0e,0x1c]
v_pk_mad_u16 v5, -1, v2, v3 v_pk_mad_u16 v5, -1, v2, v3
// CHECK: [0x05,0x40,0x89,0xd3,0xc1,0x04,0x0e,0x1c] // CHECK: [0x05,0x40,0x89,0xd3,0xc1,0x04,0x0e,0x1c]
v_pk_mad_u16 v5, 0.5, v2, v3 v_pk_mad_u16 v5, 0.5, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mad_u16 v5, -4.0, v2, v3 v_pk_mad_u16 v5, -4.0, v2, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mad_u16 v5, v1, v255, v3 v_pk_mad_u16 v5, v1, v255, v3
// CHECK: [0x05,0x40,0x89,0xd3,0x01,0xff,0x0f,0x1c] // CHECK: [0x05,0x40,0x89,0xd3,0x01,0xff,0x0f,0x1c]
v_pk_mad_u16 v5, v1, s2, v3 v_pk_mad_u16 v5, v1, s2, v3
// CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0x0c,0x1c] // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0x0c,0x1c]
v_pk_mad_u16 v5, v1, s101, v3 v_pk_mad_u16 v5, v1, s101, v3
Show All 22 Lines
v_pk_mad_u16 v5, v1, 0, v3 v_pk_mad_u16 v5, v1, 0, v3
// CHECK: [0x05,0x40,0x89,0xd3,0x01,0x01,0x0d,0x1c] // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x01,0x0d,0x1c]
v_pk_mad_u16 v5, v1, -1, v3 v_pk_mad_u16 v5, v1, -1, v3
// CHECK: [0x05,0x40,0x89,0xd3,0x01,0x83,0x0d,0x1c] // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x83,0x0d,0x1c]
v_pk_mad_u16 v5, v1, 0.5, v3 v_pk_mad_u16 v5, v1, 0.5, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mad_u16 v5, v1, -4.0, v3 v_pk_mad_u16 v5, v1, -4.0, v3
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mad_u16 v5, v1, v2, v255 v_pk_mad_u16 v5, v1, v2, v255
// CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0xfe,0x1f] // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0xfe,0x1f]
v_pk_mad_u16 v5, v1, v2, s3 v_pk_mad_u16 v5, v1, v2, s3
// CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0x0e,0x18] // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0x0e,0x18]
v_pk_mad_u16 v5, v1, v2, s101 v_pk_mad_u16 v5, v1, v2, s101
Show All 22 Lines
v_pk_mad_u16 v5, v1, v2, 0 v_pk_mad_u16 v5, v1, v2, 0
// CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0x02,0x1a] // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0x02,0x1a]
v_pk_mad_u16 v5, v1, v2, -1 v_pk_mad_u16 v5, v1, v2, -1
// CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0x06,0x1b] // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0x06,0x1b]
v_pk_mad_u16 v5, v1, v2, 0.5 v_pk_mad_u16 v5, v1, v2, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mad_u16 v5, v1, v2, -4.0 v_pk_mad_u16 v5, v1, v2, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_mad_u16 v5, v1, v2, v3 op_sel:[1,0,0] v_pk_mad_u16 v5, v1, v2, v3 op_sel:[1,0,0]
// CHECK: [0x05,0x48,0x89,0xd3,0x01,0x05,0x0e,0x1c] // CHECK: [0x05,0x48,0x89,0xd3,0x01,0x05,0x0e,0x1c]
v_pk_mad_u16 v5, v1, v2, v3 op_sel:[0,1,0] v_pk_mad_u16 v5, v1, v2, v3 op_sel:[0,1,0]
// CHECK: [0x05,0x50,0x89,0xd3,0x01,0x05,0x0e,0x1c] // CHECK: [0x05,0x50,0x89,0xd3,0x01,0x05,0x0e,0x1c]
v_pk_mad_u16 v5, v1, v2, v3 op_sel:[0,0,1] v_pk_mad_u16 v5, v1, v2, v3 op_sel:[0,0,1]
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
v_pk_add_u16 v5, 0, v2 v_pk_add_u16 v5, 0, v2
// CHECK: [0x05,0x00,0x8a,0xd3,0x80,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x8a,0xd3,0x80,0x04,0x02,0x18]
v_pk_add_u16 v5, -1, v2 v_pk_add_u16 v5, -1, v2
// CHECK: [0x05,0x00,0x8a,0xd3,0xc1,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x8a,0xd3,0xc1,0x04,0x02,0x18]
v_pk_add_u16 v5, 0.5, v2 v_pk_add_u16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_add_u16 v5, -4.0, v2 v_pk_add_u16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_add_u16 v5, v1, v255 v_pk_add_u16 v5, v1, v255
// CHECK: [0x05,0x00,0x8a,0xd3,0x01,0xff,0x03,0x18] // CHECK: [0x05,0x00,0x8a,0xd3,0x01,0xff,0x03,0x18]
v_pk_add_u16 v5, v1, s2 v_pk_add_u16 v5, v1, s2
// CHECK: [0x05,0x00,0x8a,0xd3,0x01,0x05,0x00,0x18] // CHECK: [0x05,0x00,0x8a,0xd3,0x01,0x05,0x00,0x18]
v_pk_add_u16 v5, v1, s101 v_pk_add_u16 v5, v1, s101
Show All 25 Lines
v_pk_add_u16 v5, v1, 0 v_pk_add_u16 v5, v1, 0
// CHECK: [0x05,0x00,0x8a,0xd3,0x01,0x01,0x01,0x18] // CHECK: [0x05,0x00,0x8a,0xd3,0x01,0x01,0x01,0x18]
v_pk_add_u16 v5, v1, -1 v_pk_add_u16 v5, v1, -1
// CHECK: [0x05,0x00,0x8a,0xd3,0x01,0x83,0x01,0x18] // CHECK: [0x05,0x00,0x8a,0xd3,0x01,0x83,0x01,0x18]
v_pk_add_u16 v5, v1, 0.5 v_pk_add_u16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_add_u16 v5, v1, -4.0 v_pk_add_u16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_add_u16 v5, v1, v2 op_sel:[1,0] v_pk_add_u16 v5, v1, v2 op_sel:[1,0]
// CHECK: [0x05,0x08,0x8a,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x08,0x8a,0xd3,0x01,0x05,0x02,0x18]
v_pk_add_u16 v5, v1, v2 op_sel:[0,1] v_pk_add_u16 v5, v1, v2 op_sel:[0,1]
// CHECK: [0x05,0x10,0x8a,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x10,0x8a,0xd3,0x01,0x05,0x02,0x18]
v_pk_add_u16 v5, v1, v2 op_sel:[1,1] v_pk_add_u16 v5, v1, v2 op_sel:[1,1]
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
v_pk_sub_u16 v5, 0, v2 v_pk_sub_u16 v5, 0, v2
// CHECK: [0x05,0x00,0x8b,0xd3,0x80,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x8b,0xd3,0x80,0x04,0x02,0x18]
v_pk_sub_u16 v5, -1, v2 v_pk_sub_u16 v5, -1, v2
// CHECK: [0x05,0x00,0x8b,0xd3,0xc1,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x8b,0xd3,0xc1,0x04,0x02,0x18]
v_pk_sub_u16 v5, 0.5, v2 v_pk_sub_u16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_sub_u16 v5, -4.0, v2 v_pk_sub_u16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_sub_u16 v5, v1, v255 v_pk_sub_u16 v5, v1, v255
// CHECK: [0x05,0x00,0x8b,0xd3,0x01,0xff,0x03,0x18] // CHECK: [0x05,0x00,0x8b,0xd3,0x01,0xff,0x03,0x18]
v_pk_sub_u16 v5, v1, s2 v_pk_sub_u16 v5, v1, s2
// CHECK: [0x05,0x00,0x8b,0xd3,0x01,0x05,0x00,0x18] // CHECK: [0x05,0x00,0x8b,0xd3,0x01,0x05,0x00,0x18]
v_pk_sub_u16 v5, v1, s101 v_pk_sub_u16 v5, v1, s101
Show All 25 Lines
v_pk_sub_u16 v5, v1, 0 v_pk_sub_u16 v5, v1, 0
// CHECK: [0x05,0x00,0x8b,0xd3,0x01,0x01,0x01,0x18] // CHECK: [0x05,0x00,0x8b,0xd3,0x01,0x01,0x01,0x18]
v_pk_sub_u16 v5, v1, -1 v_pk_sub_u16 v5, v1, -1
// CHECK: [0x05,0x00,0x8b,0xd3,0x01,0x83,0x01,0x18] // CHECK: [0x05,0x00,0x8b,0xd3,0x01,0x83,0x01,0x18]
v_pk_sub_u16 v5, v1, 0.5 v_pk_sub_u16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_sub_u16 v5, v1, -4.0 v_pk_sub_u16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_sub_u16 v5, v1, v2 op_sel:[1,0] v_pk_sub_u16 v5, v1, v2 op_sel:[1,0]
// CHECK: [0x05,0x08,0x8b,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x08,0x8b,0xd3,0x01,0x05,0x02,0x18]
v_pk_sub_u16 v5, v1, v2 op_sel:[0,1] v_pk_sub_u16 v5, v1, v2 op_sel:[0,1]
// CHECK: [0x05,0x10,0x8b,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x10,0x8b,0xd3,0x01,0x05,0x02,0x18]
v_pk_sub_u16 v5, v1, v2 op_sel:[1,1] v_pk_sub_u16 v5, v1, v2 op_sel:[1,1]
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
v_pk_max_u16 v5, 0, v2 v_pk_max_u16 v5, 0, v2
// CHECK: [0x05,0x00,0x8c,0xd3,0x80,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x8c,0xd3,0x80,0x04,0x02,0x18]
v_pk_max_u16 v5, -1, v2 v_pk_max_u16 v5, -1, v2
// CHECK: [0x05,0x00,0x8c,0xd3,0xc1,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x8c,0xd3,0xc1,0x04,0x02,0x18]
v_pk_max_u16 v5, 0.5, v2 v_pk_max_u16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_max_u16 v5, -4.0, v2 v_pk_max_u16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_max_u16 v5, v1, v255 v_pk_max_u16 v5, v1, v255
// CHECK: [0x05,0x00,0x8c,0xd3,0x01,0xff,0x03,0x18] // CHECK: [0x05,0x00,0x8c,0xd3,0x01,0xff,0x03,0x18]
v_pk_max_u16 v5, v1, s2 v_pk_max_u16 v5, v1, s2
// CHECK: [0x05,0x00,0x8c,0xd3,0x01,0x05,0x00,0x18] // CHECK: [0x05,0x00,0x8c,0xd3,0x01,0x05,0x00,0x18]
v_pk_max_u16 v5, v1, s101 v_pk_max_u16 v5, v1, s101
Show All 25 Lines
v_pk_max_u16 v5, v1, 0 v_pk_max_u16 v5, v1, 0
// CHECK: [0x05,0x00,0x8c,0xd3,0x01,0x01,0x01,0x18] // CHECK: [0x05,0x00,0x8c,0xd3,0x01,0x01,0x01,0x18]
v_pk_max_u16 v5, v1, -1 v_pk_max_u16 v5, v1, -1
// CHECK: [0x05,0x00,0x8c,0xd3,0x01,0x83,0x01,0x18] // CHECK: [0x05,0x00,0x8c,0xd3,0x01,0x83,0x01,0x18]
v_pk_max_u16 v5, v1, 0.5 v_pk_max_u16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_max_u16 v5, v1, -4.0 v_pk_max_u16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_max_u16 v5, v1, v2 op_sel:[1,0] v_pk_max_u16 v5, v1, v2 op_sel:[1,0]
// CHECK: [0x05,0x08,0x8c,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x08,0x8c,0xd3,0x01,0x05,0x02,0x18]
v_pk_max_u16 v5, v1, v2 op_sel:[0,1] v_pk_max_u16 v5, v1, v2 op_sel:[0,1]
// CHECK: [0x05,0x10,0x8c,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x10,0x8c,0xd3,0x01,0x05,0x02,0x18]
v_pk_max_u16 v5, v1, v2 op_sel:[1,1] v_pk_max_u16 v5, v1, v2 op_sel:[1,1]
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
v_pk_min_u16 v5, 0, v2 v_pk_min_u16 v5, 0, v2
// CHECK: [0x05,0x00,0x8d,0xd3,0x80,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x8d,0xd3,0x80,0x04,0x02,0x18]
v_pk_min_u16 v5, -1, v2 v_pk_min_u16 v5, -1, v2
// CHECK: [0x05,0x00,0x8d,0xd3,0xc1,0x04,0x02,0x18] // CHECK: [0x05,0x00,0x8d,0xd3,0xc1,0x04,0x02,0x18]
v_pk_min_u16 v5, 0.5, v2 v_pk_min_u16 v5, 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_min_u16 v5, -4.0, v2 v_pk_min_u16 v5, -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_min_u16 v5, v1, v255 v_pk_min_u16 v5, v1, v255
// CHECK: [0x05,0x00,0x8d,0xd3,0x01,0xff,0x03,0x18] // CHECK: [0x05,0x00,0x8d,0xd3,0x01,0xff,0x03,0x18]
v_pk_min_u16 v5, v1, s2 v_pk_min_u16 v5, v1, s2
// CHECK: [0x05,0x00,0x8d,0xd3,0x01,0x05,0x00,0x18] // CHECK: [0x05,0x00,0x8d,0xd3,0x01,0x05,0x00,0x18]
v_pk_min_u16 v5, v1, s101 v_pk_min_u16 v5, v1, s101
Show All 25 Lines
v_pk_min_u16 v5, v1, 0 v_pk_min_u16 v5, v1, 0
// CHECK: [0x05,0x00,0x8d,0xd3,0x01,0x01,0x01,0x18] // CHECK: [0x05,0x00,0x8d,0xd3,0x01,0x01,0x01,0x18]
v_pk_min_u16 v5, v1, -1 v_pk_min_u16 v5, v1, -1
// CHECK: [0x05,0x00,0x8d,0xd3,0x01,0x83,0x01,0x18] // CHECK: [0x05,0x00,0x8d,0xd3,0x01,0x83,0x01,0x18]
v_pk_min_u16 v5, v1, 0.5 v_pk_min_u16 v5, v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_min_u16 v5, v1, -4.0 v_pk_min_u16 v5, v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_pk_min_u16 v5, v1, v2 op_sel:[1,0] v_pk_min_u16 v5, v1, v2 op_sel:[1,0]
// CHECK: [0x05,0x08,0x8d,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x08,0x8d,0xd3,0x01,0x05,0x02,0x18]
v_pk_min_u16 v5, v1, v2 op_sel:[0,1] v_pk_min_u16 v5, v1, v2 op_sel:[0,1]
// CHECK: [0x05,0x10,0x8d,0xd3,0x01,0x05,0x02,0x18] // CHECK: [0x05,0x10,0x8d,0xd3,0x01,0x05,0x02,0x18]
v_pk_min_u16 v5, v1, v2 op_sel:[1,1] v_pk_min_u16 v5, v1, v2 op_sel:[1,1]
▲ Show 20 Lines • Show All 17,431 Lines • ▼ Show 20 Lines
v_cmp_f_i16_e64 s[10:11], 0, v2 v_cmp_f_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa0,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa0,0xd0,0x80,0x04,0x02,0x00]
v_cmp_f_i16_e64 s[10:11], -1, v2 v_cmp_f_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa0,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa0,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_f_i16_e64 s[10:11], 0.5, v2 v_cmp_f_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_i16_e64 s[10:11], -4.0, v2 v_cmp_f_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_i16_e64 s[10:11], v1, v255 v_cmp_f_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0xff,0x03,0x00]
v_cmp_f_i16_e64 s[10:11], v1, s2 v_cmp_f_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x05,0x00,0x00]
v_cmp_f_i16_e64 s[10:11], v1, s101 v_cmp_f_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_f_i16_e64 s[10:11], v1, 0 v_cmp_f_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x01,0x01,0x00]
v_cmp_f_i16_e64 s[10:11], v1, -1 v_cmp_f_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x83,0x01,0x00]
v_cmp_f_i16_e64 s[10:11], v1, 0.5 v_cmp_f_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_i16_e64 s[10:11], v1, -4.0 v_cmp_f_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_i16 vcc, v1, v2 v_cmp_lt_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x42,0x7d] // CHECK: [0x01,0x05,0x42,0x7d]
v_cmp_lt_i16 vcc, v255, v2 v_cmp_lt_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x42,0x7d] // CHECK: [0xff,0x05,0x42,0x7d]
v_cmp_lt_i16 vcc, s1, v2 v_cmp_lt_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_lt_i16_e64 s[10:11], 0, v2 v_cmp_lt_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa1,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa1,0xd0,0x80,0x04,0x02,0x00]
v_cmp_lt_i16_e64 s[10:11], -1, v2 v_cmp_lt_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa1,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa1,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_lt_i16_e64 s[10:11], 0.5, v2 v_cmp_lt_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_i16_e64 s[10:11], -4.0, v2 v_cmp_lt_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_i16_e64 s[10:11], v1, v255 v_cmp_lt_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0xff,0x03,0x00]
v_cmp_lt_i16_e64 s[10:11], v1, s2 v_cmp_lt_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x05,0x00,0x00]
v_cmp_lt_i16_e64 s[10:11], v1, s101 v_cmp_lt_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_lt_i16_e64 s[10:11], v1, 0 v_cmp_lt_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x01,0x01,0x00]
v_cmp_lt_i16_e64 s[10:11], v1, -1 v_cmp_lt_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x83,0x01,0x00]
v_cmp_lt_i16_e64 s[10:11], v1, 0.5 v_cmp_lt_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_i16_e64 s[10:11], v1, -4.0 v_cmp_lt_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_i16 vcc, v1, v2 v_cmp_eq_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x44,0x7d] // CHECK: [0x01,0x05,0x44,0x7d]
v_cmp_eq_i16 vcc, v255, v2 v_cmp_eq_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x44,0x7d] // CHECK: [0xff,0x05,0x44,0x7d]
v_cmp_eq_i16 vcc, s1, v2 v_cmp_eq_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_eq_i16_e64 s[10:11], 0, v2 v_cmp_eq_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa2,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa2,0xd0,0x80,0x04,0x02,0x00]
v_cmp_eq_i16_e64 s[10:11], -1, v2 v_cmp_eq_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa2,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa2,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_eq_i16_e64 s[10:11], 0.5, v2 v_cmp_eq_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_i16_e64 s[10:11], -4.0, v2 v_cmp_eq_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_i16_e64 s[10:11], v1, v255 v_cmp_eq_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0xff,0x03,0x00]
v_cmp_eq_i16_e64 s[10:11], v1, s2 v_cmp_eq_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x05,0x00,0x00]
v_cmp_eq_i16_e64 s[10:11], v1, s101 v_cmp_eq_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_eq_i16_e64 s[10:11], v1, 0 v_cmp_eq_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x01,0x01,0x00]
v_cmp_eq_i16_e64 s[10:11], v1, -1 v_cmp_eq_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x83,0x01,0x00]
v_cmp_eq_i16_e64 s[10:11], v1, 0.5 v_cmp_eq_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_i16_e64 s[10:11], v1, -4.0 v_cmp_eq_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_i16 vcc, v1, v2 v_cmp_le_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x46,0x7d] // CHECK: [0x01,0x05,0x46,0x7d]
v_cmp_le_i16 vcc, v255, v2 v_cmp_le_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x46,0x7d] // CHECK: [0xff,0x05,0x46,0x7d]
v_cmp_le_i16 vcc, s1, v2 v_cmp_le_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_le_i16_e64 s[10:11], 0, v2 v_cmp_le_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa3,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa3,0xd0,0x80,0x04,0x02,0x00]
v_cmp_le_i16_e64 s[10:11], -1, v2 v_cmp_le_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa3,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa3,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_le_i16_e64 s[10:11], 0.5, v2 v_cmp_le_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_i16_e64 s[10:11], -4.0, v2 v_cmp_le_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_i16_e64 s[10:11], v1, v255 v_cmp_le_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0xff,0x03,0x00]
v_cmp_le_i16_e64 s[10:11], v1, s2 v_cmp_le_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x05,0x00,0x00]
v_cmp_le_i16_e64 s[10:11], v1, s101 v_cmp_le_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_le_i16_e64 s[10:11], v1, 0 v_cmp_le_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x01,0x01,0x00]
v_cmp_le_i16_e64 s[10:11], v1, -1 v_cmp_le_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x83,0x01,0x00]
v_cmp_le_i16_e64 s[10:11], v1, 0.5 v_cmp_le_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_i16_e64 s[10:11], v1, -4.0 v_cmp_le_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_i16 vcc, v1, v2 v_cmp_gt_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x48,0x7d] // CHECK: [0x01,0x05,0x48,0x7d]
v_cmp_gt_i16 vcc, v255, v2 v_cmp_gt_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x48,0x7d] // CHECK: [0xff,0x05,0x48,0x7d]
v_cmp_gt_i16 vcc, s1, v2 v_cmp_gt_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_gt_i16_e64 s[10:11], 0, v2 v_cmp_gt_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa4,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa4,0xd0,0x80,0x04,0x02,0x00]
v_cmp_gt_i16_e64 s[10:11], -1, v2 v_cmp_gt_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa4,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa4,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_gt_i16_e64 s[10:11], 0.5, v2 v_cmp_gt_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_i16_e64 s[10:11], -4.0, v2 v_cmp_gt_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_i16_e64 s[10:11], v1, v255 v_cmp_gt_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0xff,0x03,0x00]
v_cmp_gt_i16_e64 s[10:11], v1, s2 v_cmp_gt_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x05,0x00,0x00]
v_cmp_gt_i16_e64 s[10:11], v1, s101 v_cmp_gt_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_gt_i16_e64 s[10:11], v1, 0 v_cmp_gt_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x01,0x01,0x00]
v_cmp_gt_i16_e64 s[10:11], v1, -1 v_cmp_gt_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x83,0x01,0x00]
v_cmp_gt_i16_e64 s[10:11], v1, 0.5 v_cmp_gt_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_i16_e64 s[10:11], v1, -4.0 v_cmp_gt_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_i16 vcc, v1, v2 v_cmp_ne_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x4a,0x7d] // CHECK: [0x01,0x05,0x4a,0x7d]
v_cmp_ne_i16 vcc, v255, v2 v_cmp_ne_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x4a,0x7d] // CHECK: [0xff,0x05,0x4a,0x7d]
v_cmp_ne_i16 vcc, s1, v2 v_cmp_ne_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_ne_i16_e64 s[10:11], 0, v2 v_cmp_ne_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa5,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa5,0xd0,0x80,0x04,0x02,0x00]
v_cmp_ne_i16_e64 s[10:11], -1, v2 v_cmp_ne_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa5,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa5,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_ne_i16_e64 s[10:11], 0.5, v2 v_cmp_ne_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_i16_e64 s[10:11], -4.0, v2 v_cmp_ne_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_i16_e64 s[10:11], v1, v255 v_cmp_ne_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0xff,0x03,0x00]
v_cmp_ne_i16_e64 s[10:11], v1, s2 v_cmp_ne_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x05,0x00,0x00]
v_cmp_ne_i16_e64 s[10:11], v1, s101 v_cmp_ne_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_ne_i16_e64 s[10:11], v1, 0 v_cmp_ne_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x01,0x01,0x00]
v_cmp_ne_i16_e64 s[10:11], v1, -1 v_cmp_ne_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x83,0x01,0x00]
v_cmp_ne_i16_e64 s[10:11], v1, 0.5 v_cmp_ne_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_i16_e64 s[10:11], v1, -4.0 v_cmp_ne_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_i16 vcc, v1, v2 v_cmp_ge_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x4c,0x7d] // CHECK: [0x01,0x05,0x4c,0x7d]
v_cmp_ge_i16 vcc, v255, v2 v_cmp_ge_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x4c,0x7d] // CHECK: [0xff,0x05,0x4c,0x7d]
v_cmp_ge_i16 vcc, s1, v2 v_cmp_ge_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_ge_i16_e64 s[10:11], 0, v2 v_cmp_ge_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa6,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa6,0xd0,0x80,0x04,0x02,0x00]
v_cmp_ge_i16_e64 s[10:11], -1, v2 v_cmp_ge_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa6,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa6,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_ge_i16_e64 s[10:11], 0.5, v2 v_cmp_ge_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_i16_e64 s[10:11], -4.0, v2 v_cmp_ge_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_i16_e64 s[10:11], v1, v255 v_cmp_ge_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0xff,0x03,0x00]
v_cmp_ge_i16_e64 s[10:11], v1, s2 v_cmp_ge_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x05,0x00,0x00]
v_cmp_ge_i16_e64 s[10:11], v1, s101 v_cmp_ge_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_ge_i16_e64 s[10:11], v1, 0 v_cmp_ge_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x01,0x01,0x00]
v_cmp_ge_i16_e64 s[10:11], v1, -1 v_cmp_ge_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x83,0x01,0x00]
v_cmp_ge_i16_e64 s[10:11], v1, 0.5 v_cmp_ge_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_i16_e64 s[10:11], v1, -4.0 v_cmp_ge_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_i16 vcc, v1, v2 v_cmp_t_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x4e,0x7d] // CHECK: [0x01,0x05,0x4e,0x7d]
v_cmp_t_i16 vcc, v255, v2 v_cmp_t_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x4e,0x7d] // CHECK: [0xff,0x05,0x4e,0x7d]
v_cmp_t_i16 vcc, s1, v2 v_cmp_t_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_t_i16_e64 s[10:11], 0, v2 v_cmp_t_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa7,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa7,0xd0,0x80,0x04,0x02,0x00]
v_cmp_t_i16_e64 s[10:11], -1, v2 v_cmp_t_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa7,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa7,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_t_i16_e64 s[10:11], 0.5, v2 v_cmp_t_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_i16_e64 s[10:11], -4.0, v2 v_cmp_t_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_i16_e64 s[10:11], v1, v255 v_cmp_t_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0xff,0x03,0x00]
v_cmp_t_i16_e64 s[10:11], v1, s2 v_cmp_t_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x05,0x00,0x00]
v_cmp_t_i16_e64 s[10:11], v1, s101 v_cmp_t_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_t_i16_e64 s[10:11], v1, 0 v_cmp_t_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x01,0x01,0x00]
v_cmp_t_i16_e64 s[10:11], v1, -1 v_cmp_t_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x83,0x01,0x00]
v_cmp_t_i16_e64 s[10:11], v1, 0.5 v_cmp_t_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_i16_e64 s[10:11], v1, -4.0 v_cmp_t_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_u16 vcc, v1, v2 v_cmp_f_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x50,0x7d] // CHECK: [0x01,0x05,0x50,0x7d]
v_cmp_f_u16 vcc, v255, v2 v_cmp_f_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x50,0x7d] // CHECK: [0xff,0x05,0x50,0x7d]
v_cmp_f_u16 vcc, s1, v2 v_cmp_f_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_f_u16_e64 s[10:11], 0, v2 v_cmp_f_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa8,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa8,0xd0,0x80,0x04,0x02,0x00]
v_cmp_f_u16_e64 s[10:11], -1, v2 v_cmp_f_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa8,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa8,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_f_u16_e64 s[10:11], 0.5, v2 v_cmp_f_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_u16_e64 s[10:11], -4.0, v2 v_cmp_f_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_u16_e64 s[10:11], v1, v255 v_cmp_f_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0xff,0x03,0x00]
v_cmp_f_u16_e64 s[10:11], v1, s2 v_cmp_f_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x05,0x00,0x00]
v_cmp_f_u16_e64 s[10:11], v1, s101 v_cmp_f_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_f_u16_e64 s[10:11], v1, 0 v_cmp_f_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x01,0x01,0x00]
v_cmp_f_u16_e64 s[10:11], v1, -1 v_cmp_f_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x83,0x01,0x00]
v_cmp_f_u16_e64 s[10:11], v1, 0.5 v_cmp_f_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_u16_e64 s[10:11], v1, -4.0 v_cmp_f_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_u16 vcc, v1, v2 v_cmp_lt_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x52,0x7d] // CHECK: [0x01,0x05,0x52,0x7d]
v_cmp_lt_u16 vcc, v255, v2 v_cmp_lt_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x52,0x7d] // CHECK: [0xff,0x05,0x52,0x7d]
v_cmp_lt_u16 vcc, s1, v2 v_cmp_lt_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_lt_u16_e64 s[10:11], 0, v2 v_cmp_lt_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xa9,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa9,0xd0,0x80,0x04,0x02,0x00]
v_cmp_lt_u16_e64 s[10:11], -1, v2 v_cmp_lt_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xa9,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xa9,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_lt_u16_e64 s[10:11], 0.5, v2 v_cmp_lt_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_u16_e64 s[10:11], -4.0, v2 v_cmp_lt_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_u16_e64 s[10:11], v1, v255 v_cmp_lt_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0xff,0x03,0x00]
v_cmp_lt_u16_e64 s[10:11], v1, s2 v_cmp_lt_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x05,0x00,0x00]
v_cmp_lt_u16_e64 s[10:11], v1, s101 v_cmp_lt_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_lt_u16_e64 s[10:11], v1, 0 v_cmp_lt_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x01,0x01,0x00]
v_cmp_lt_u16_e64 s[10:11], v1, -1 v_cmp_lt_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x83,0x01,0x00]
v_cmp_lt_u16_e64 s[10:11], v1, 0.5 v_cmp_lt_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_lt_u16_e64 s[10:11], v1, -4.0 v_cmp_lt_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_u16 vcc, v1, v2 v_cmp_eq_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x54,0x7d] // CHECK: [0x01,0x05,0x54,0x7d]
v_cmp_eq_u16 vcc, v255, v2 v_cmp_eq_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x54,0x7d] // CHECK: [0xff,0x05,0x54,0x7d]
v_cmp_eq_u16 vcc, s1, v2 v_cmp_eq_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_eq_u16_e64 s[10:11], 0, v2 v_cmp_eq_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xaa,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xaa,0xd0,0x80,0x04,0x02,0x00]
v_cmp_eq_u16_e64 s[10:11], -1, v2 v_cmp_eq_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xaa,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xaa,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_eq_u16_e64 s[10:11], 0.5, v2 v_cmp_eq_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_u16_e64 s[10:11], -4.0, v2 v_cmp_eq_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_u16_e64 s[10:11], v1, v255 v_cmp_eq_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0xff,0x03,0x00]
v_cmp_eq_u16_e64 s[10:11], v1, s2 v_cmp_eq_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x05,0x00,0x00]
v_cmp_eq_u16_e64 s[10:11], v1, s101 v_cmp_eq_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_eq_u16_e64 s[10:11], v1, 0 v_cmp_eq_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x01,0x01,0x00]
v_cmp_eq_u16_e64 s[10:11], v1, -1 v_cmp_eq_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x83,0x01,0x00]
v_cmp_eq_u16_e64 s[10:11], v1, 0.5 v_cmp_eq_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_eq_u16_e64 s[10:11], v1, -4.0 v_cmp_eq_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_u16 vcc, v1, v2 v_cmp_le_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x56,0x7d] // CHECK: [0x01,0x05,0x56,0x7d]
v_cmp_le_u16 vcc, v255, v2 v_cmp_le_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x56,0x7d] // CHECK: [0xff,0x05,0x56,0x7d]
v_cmp_le_u16 vcc, s1, v2 v_cmp_le_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_le_u16_e64 s[10:11], 0, v2 v_cmp_le_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xab,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xab,0xd0,0x80,0x04,0x02,0x00]
v_cmp_le_u16_e64 s[10:11], -1, v2 v_cmp_le_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xab,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xab,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_le_u16_e64 s[10:11], 0.5, v2 v_cmp_le_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_u16_e64 s[10:11], -4.0, v2 v_cmp_le_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_u16_e64 s[10:11], v1, v255 v_cmp_le_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xab,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0xff,0x03,0x00]
v_cmp_le_u16_e64 s[10:11], v1, s2 v_cmp_le_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x05,0x00,0x00]
v_cmp_le_u16_e64 s[10:11], v1, s101 v_cmp_le_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_le_u16_e64 s[10:11], v1, 0 v_cmp_le_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x01,0x01,0x00]
v_cmp_le_u16_e64 s[10:11], v1, -1 v_cmp_le_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x83,0x01,0x00]
v_cmp_le_u16_e64 s[10:11], v1, 0.5 v_cmp_le_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_le_u16_e64 s[10:11], v1, -4.0 v_cmp_le_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_u16 vcc, v1, v2 v_cmp_gt_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x58,0x7d] // CHECK: [0x01,0x05,0x58,0x7d]
v_cmp_gt_u16 vcc, v255, v2 v_cmp_gt_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x58,0x7d] // CHECK: [0xff,0x05,0x58,0x7d]
v_cmp_gt_u16 vcc, s1, v2 v_cmp_gt_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_gt_u16_e64 s[10:11], 0, v2 v_cmp_gt_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xac,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xac,0xd0,0x80,0x04,0x02,0x00]
v_cmp_gt_u16_e64 s[10:11], -1, v2 v_cmp_gt_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xac,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xac,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_gt_u16_e64 s[10:11], 0.5, v2 v_cmp_gt_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_u16_e64 s[10:11], -4.0, v2 v_cmp_gt_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_u16_e64 s[10:11], v1, v255 v_cmp_gt_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xac,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0xff,0x03,0x00]
v_cmp_gt_u16_e64 s[10:11], v1, s2 v_cmp_gt_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x05,0x00,0x00]
v_cmp_gt_u16_e64 s[10:11], v1, s101 v_cmp_gt_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_gt_u16_e64 s[10:11], v1, 0 v_cmp_gt_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x01,0x01,0x00]
v_cmp_gt_u16_e64 s[10:11], v1, -1 v_cmp_gt_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x83,0x01,0x00]
v_cmp_gt_u16_e64 s[10:11], v1, 0.5 v_cmp_gt_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_gt_u16_e64 s[10:11], v1, -4.0 v_cmp_gt_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_u16 vcc, v1, v2 v_cmp_ne_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x5a,0x7d] // CHECK: [0x01,0x05,0x5a,0x7d]
v_cmp_ne_u16 vcc, v255, v2 v_cmp_ne_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x5a,0x7d] // CHECK: [0xff,0x05,0x5a,0x7d]
v_cmp_ne_u16 vcc, s1, v2 v_cmp_ne_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_ne_u16_e64 s[10:11], 0, v2 v_cmp_ne_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xad,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xad,0xd0,0x80,0x04,0x02,0x00]
v_cmp_ne_u16_e64 s[10:11], -1, v2 v_cmp_ne_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xad,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xad,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_ne_u16_e64 s[10:11], 0.5, v2 v_cmp_ne_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_u16_e64 s[10:11], -4.0, v2 v_cmp_ne_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_u16_e64 s[10:11], v1, v255 v_cmp_ne_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xad,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0xff,0x03,0x00]
v_cmp_ne_u16_e64 s[10:11], v1, s2 v_cmp_ne_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x05,0x00,0x00]
v_cmp_ne_u16_e64 s[10:11], v1, s101 v_cmp_ne_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_ne_u16_e64 s[10:11], v1, 0 v_cmp_ne_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x01,0x01,0x00]
v_cmp_ne_u16_e64 s[10:11], v1, -1 v_cmp_ne_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x83,0x01,0x00]
v_cmp_ne_u16_e64 s[10:11], v1, 0.5 v_cmp_ne_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ne_u16_e64 s[10:11], v1, -4.0 v_cmp_ne_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_u16 vcc, v1, v2 v_cmp_ge_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x5c,0x7d] // CHECK: [0x01,0x05,0x5c,0x7d]
v_cmp_ge_u16 vcc, v255, v2 v_cmp_ge_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x5c,0x7d] // CHECK: [0xff,0x05,0x5c,0x7d]
v_cmp_ge_u16 vcc, s1, v2 v_cmp_ge_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_ge_u16_e64 s[10:11], 0, v2 v_cmp_ge_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xae,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xae,0xd0,0x80,0x04,0x02,0x00]
v_cmp_ge_u16_e64 s[10:11], -1, v2 v_cmp_ge_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xae,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xae,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_ge_u16_e64 s[10:11], 0.5, v2 v_cmp_ge_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_u16_e64 s[10:11], -4.0, v2 v_cmp_ge_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_u16_e64 s[10:11], v1, v255 v_cmp_ge_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xae,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0xff,0x03,0x00]
v_cmp_ge_u16_e64 s[10:11], v1, s2 v_cmp_ge_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x05,0x00,0x00]
v_cmp_ge_u16_e64 s[10:11], v1, s101 v_cmp_ge_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_ge_u16_e64 s[10:11], v1, 0 v_cmp_ge_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x01,0x01,0x00]
v_cmp_ge_u16_e64 s[10:11], v1, -1 v_cmp_ge_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x83,0x01,0x00]
v_cmp_ge_u16_e64 s[10:11], v1, 0.5 v_cmp_ge_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_ge_u16_e64 s[10:11], v1, -4.0 v_cmp_ge_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_u16 vcc, v1, v2 v_cmp_t_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x5e,0x7d] // CHECK: [0x01,0x05,0x5e,0x7d]
v_cmp_t_u16 vcc, v255, v2 v_cmp_t_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x5e,0x7d] // CHECK: [0xff,0x05,0x5e,0x7d]
v_cmp_t_u16 vcc, s1, v2 v_cmp_t_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
v_cmp_t_u16_e64 s[10:11], 0, v2 v_cmp_t_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xaf,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xaf,0xd0,0x80,0x04,0x02,0x00]
v_cmp_t_u16_e64 s[10:11], -1, v2 v_cmp_t_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xaf,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xaf,0xd0,0xc1,0x04,0x02,0x00]
v_cmp_t_u16_e64 s[10:11], 0.5, v2 v_cmp_t_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_u16_e64 s[10:11], -4.0, v2 v_cmp_t_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_u16_e64 s[10:11], v1, v255 v_cmp_t_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0xff,0x03,0x00]
v_cmp_t_u16_e64 s[10:11], v1, s2 v_cmp_t_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x05,0x00,0x00]
v_cmp_t_u16_e64 s[10:11], v1, s101 v_cmp_t_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmp_t_u16_e64 s[10:11], v1, 0 v_cmp_t_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x01,0x01,0x00]
v_cmp_t_u16_e64 s[10:11], v1, -1 v_cmp_t_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x83,0x01,0x00]
v_cmp_t_u16_e64 s[10:11], v1, 0.5 v_cmp_t_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_t_u16_e64 s[10:11], v1, -4.0 v_cmp_t_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_i16 vcc, v1, v2 v_cmpx_f_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x60,0x7d] // CHECK: [0x01,0x05,0x60,0x7d]
v_cmpx_f_i16 vcc, v255, v2 v_cmpx_f_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x60,0x7d] // CHECK: [0xff,0x05,0x60,0x7d]
v_cmpx_f_i16 vcc, s1, v2 v_cmpx_f_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_f_i16_e64 s[10:11], 0, v2 v_cmpx_f_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb0,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb0,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_f_i16_e64 s[10:11], -1, v2 v_cmpx_f_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb0,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb0,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_f_i16_e64 s[10:11], 0.5, v2 v_cmpx_f_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_i16_e64 s[10:11], -4.0, v2 v_cmpx_f_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_i16_e64 s[10:11], v1, v255 v_cmpx_f_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_f_i16_e64 s[10:11], v1, s2 v_cmpx_f_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_f_i16_e64 s[10:11], v1, s101 v_cmpx_f_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_f_i16_e64 s[10:11], v1, 0 v_cmpx_f_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_f_i16_e64 s[10:11], v1, -1 v_cmpx_f_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_f_i16_e64 s[10:11], v1, 0.5 v_cmpx_f_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_i16_e64 s[10:11], v1, -4.0 v_cmpx_f_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_i16 vcc, v1, v2 v_cmpx_lt_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x62,0x7d] // CHECK: [0x01,0x05,0x62,0x7d]
v_cmpx_lt_i16 vcc, v255, v2 v_cmpx_lt_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x62,0x7d] // CHECK: [0xff,0x05,0x62,0x7d]
v_cmpx_lt_i16 vcc, s1, v2 v_cmpx_lt_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_lt_i16_e64 s[10:11], 0, v2 v_cmpx_lt_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb1,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb1,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_lt_i16_e64 s[10:11], -1, v2 v_cmpx_lt_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb1,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb1,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_lt_i16_e64 s[10:11], 0.5, v2 v_cmpx_lt_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_i16_e64 s[10:11], -4.0, v2 v_cmpx_lt_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_i16_e64 s[10:11], v1, v255 v_cmpx_lt_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_lt_i16_e64 s[10:11], v1, s2 v_cmpx_lt_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_lt_i16_e64 s[10:11], v1, s101 v_cmpx_lt_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_lt_i16_e64 s[10:11], v1, 0 v_cmpx_lt_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_lt_i16_e64 s[10:11], v1, -1 v_cmpx_lt_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_lt_i16_e64 s[10:11], v1, 0.5 v_cmpx_lt_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_i16_e64 s[10:11], v1, -4.0 v_cmpx_lt_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_i16 vcc, v1, v2 v_cmpx_eq_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x64,0x7d] // CHECK: [0x01,0x05,0x64,0x7d]
v_cmpx_eq_i16 vcc, v255, v2 v_cmpx_eq_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x64,0x7d] // CHECK: [0xff,0x05,0x64,0x7d]
v_cmpx_eq_i16 vcc, s1, v2 v_cmpx_eq_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_eq_i16_e64 s[10:11], 0, v2 v_cmpx_eq_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb2,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb2,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_eq_i16_e64 s[10:11], -1, v2 v_cmpx_eq_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb2,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb2,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_eq_i16_e64 s[10:11], 0.5, v2 v_cmpx_eq_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_i16_e64 s[10:11], -4.0, v2 v_cmpx_eq_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_i16_e64 s[10:11], v1, v255 v_cmpx_eq_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_eq_i16_e64 s[10:11], v1, s2 v_cmpx_eq_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_eq_i16_e64 s[10:11], v1, s101 v_cmpx_eq_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_eq_i16_e64 s[10:11], v1, 0 v_cmpx_eq_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_eq_i16_e64 s[10:11], v1, -1 v_cmpx_eq_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_eq_i16_e64 s[10:11], v1, 0.5 v_cmpx_eq_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_i16_e64 s[10:11], v1, -4.0 v_cmpx_eq_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_i16 vcc, v1, v2 v_cmpx_le_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x66,0x7d] // CHECK: [0x01,0x05,0x66,0x7d]
v_cmpx_le_i16 vcc, v255, v2 v_cmpx_le_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x66,0x7d] // CHECK: [0xff,0x05,0x66,0x7d]
v_cmpx_le_i16 vcc, s1, v2 v_cmpx_le_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_le_i16_e64 s[10:11], 0, v2 v_cmpx_le_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb3,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb3,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_le_i16_e64 s[10:11], -1, v2 v_cmpx_le_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb3,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb3,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_le_i16_e64 s[10:11], 0.5, v2 v_cmpx_le_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_i16_e64 s[10:11], -4.0, v2 v_cmpx_le_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_i16_e64 s[10:11], v1, v255 v_cmpx_le_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_le_i16_e64 s[10:11], v1, s2 v_cmpx_le_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_le_i16_e64 s[10:11], v1, s101 v_cmpx_le_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_le_i16_e64 s[10:11], v1, 0 v_cmpx_le_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_le_i16_e64 s[10:11], v1, -1 v_cmpx_le_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_le_i16_e64 s[10:11], v1, 0.5 v_cmpx_le_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_i16_e64 s[10:11], v1, -4.0 v_cmpx_le_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_i16 vcc, v1, v2 v_cmpx_gt_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x68,0x7d] // CHECK: [0x01,0x05,0x68,0x7d]
v_cmpx_gt_i16 vcc, v255, v2 v_cmpx_gt_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x68,0x7d] // CHECK: [0xff,0x05,0x68,0x7d]
v_cmpx_gt_i16 vcc, s1, v2 v_cmpx_gt_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_gt_i16_e64 s[10:11], 0, v2 v_cmpx_gt_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb4,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb4,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_gt_i16_e64 s[10:11], -1, v2 v_cmpx_gt_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb4,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb4,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_gt_i16_e64 s[10:11], 0.5, v2 v_cmpx_gt_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_i16_e64 s[10:11], -4.0, v2 v_cmpx_gt_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_i16_e64 s[10:11], v1, v255 v_cmpx_gt_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_gt_i16_e64 s[10:11], v1, s2 v_cmpx_gt_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_gt_i16_e64 s[10:11], v1, s101 v_cmpx_gt_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_gt_i16_e64 s[10:11], v1, 0 v_cmpx_gt_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_gt_i16_e64 s[10:11], v1, -1 v_cmpx_gt_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_gt_i16_e64 s[10:11], v1, 0.5 v_cmpx_gt_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_i16_e64 s[10:11], v1, -4.0 v_cmpx_gt_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_i16 vcc, v1, v2 v_cmpx_ne_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x6a,0x7d] // CHECK: [0x01,0x05,0x6a,0x7d]
v_cmpx_ne_i16 vcc, v255, v2 v_cmpx_ne_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x6a,0x7d] // CHECK: [0xff,0x05,0x6a,0x7d]
v_cmpx_ne_i16 vcc, s1, v2 v_cmpx_ne_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_ne_i16_e64 s[10:11], 0, v2 v_cmpx_ne_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb5,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb5,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_ne_i16_e64 s[10:11], -1, v2 v_cmpx_ne_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb5,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb5,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_ne_i16_e64 s[10:11], 0.5, v2 v_cmpx_ne_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_i16_e64 s[10:11], -4.0, v2 v_cmpx_ne_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_i16_e64 s[10:11], v1, v255 v_cmpx_ne_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_ne_i16_e64 s[10:11], v1, s2 v_cmpx_ne_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_ne_i16_e64 s[10:11], v1, s101 v_cmpx_ne_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_ne_i16_e64 s[10:11], v1, 0 v_cmpx_ne_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_ne_i16_e64 s[10:11], v1, -1 v_cmpx_ne_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_ne_i16_e64 s[10:11], v1, 0.5 v_cmpx_ne_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_i16_e64 s[10:11], v1, -4.0 v_cmpx_ne_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_i16 vcc, v1, v2 v_cmpx_ge_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x6c,0x7d] // CHECK: [0x01,0x05,0x6c,0x7d]
v_cmpx_ge_i16 vcc, v255, v2 v_cmpx_ge_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x6c,0x7d] // CHECK: [0xff,0x05,0x6c,0x7d]
v_cmpx_ge_i16 vcc, s1, v2 v_cmpx_ge_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_ge_i16_e64 s[10:11], 0, v2 v_cmpx_ge_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb6,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb6,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_ge_i16_e64 s[10:11], -1, v2 v_cmpx_ge_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb6,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb6,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_ge_i16_e64 s[10:11], 0.5, v2 v_cmpx_ge_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_i16_e64 s[10:11], -4.0, v2 v_cmpx_ge_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_i16_e64 s[10:11], v1, v255 v_cmpx_ge_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_ge_i16_e64 s[10:11], v1, s2 v_cmpx_ge_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_ge_i16_e64 s[10:11], v1, s101 v_cmpx_ge_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_ge_i16_e64 s[10:11], v1, 0 v_cmpx_ge_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_ge_i16_e64 s[10:11], v1, -1 v_cmpx_ge_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_ge_i16_e64 s[10:11], v1, 0.5 v_cmpx_ge_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_i16_e64 s[10:11], v1, -4.0 v_cmpx_ge_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_i16 vcc, v1, v2 v_cmpx_t_i16 vcc, v1, v2
// CHECK: [0x01,0x05,0x6e,0x7d] // CHECK: [0x01,0x05,0x6e,0x7d]
v_cmpx_t_i16 vcc, v255, v2 v_cmpx_t_i16 vcc, v255, v2
// CHECK: [0xff,0x05,0x6e,0x7d] // CHECK: [0xff,0x05,0x6e,0x7d]
v_cmpx_t_i16 vcc, s1, v2 v_cmpx_t_i16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_t_i16_e64 s[10:11], 0, v2 v_cmpx_t_i16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb7,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb7,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_t_i16_e64 s[10:11], -1, v2 v_cmpx_t_i16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb7,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb7,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_t_i16_e64 s[10:11], 0.5, v2 v_cmpx_t_i16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_i16_e64 s[10:11], -4.0, v2 v_cmpx_t_i16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_i16_e64 s[10:11], v1, v255 v_cmpx_t_i16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_t_i16_e64 s[10:11], v1, s2 v_cmpx_t_i16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_t_i16_e64 s[10:11], v1, s101 v_cmpx_t_i16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_t_i16_e64 s[10:11], v1, 0 v_cmpx_t_i16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_t_i16_e64 s[10:11], v1, -1 v_cmpx_t_i16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_t_i16_e64 s[10:11], v1, 0.5 v_cmpx_t_i16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_i16_e64 s[10:11], v1, -4.0 v_cmpx_t_i16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_u16 vcc, v1, v2 v_cmpx_f_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x70,0x7d] // CHECK: [0x01,0x05,0x70,0x7d]
v_cmpx_f_u16 vcc, v255, v2 v_cmpx_f_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x70,0x7d] // CHECK: [0xff,0x05,0x70,0x7d]
v_cmpx_f_u16 vcc, s1, v2 v_cmpx_f_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_f_u16_e64 s[10:11], 0, v2 v_cmpx_f_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb8,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb8,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_f_u16_e64 s[10:11], -1, v2 v_cmpx_f_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb8,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb8,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_f_u16_e64 s[10:11], 0.5, v2 v_cmpx_f_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_u16_e64 s[10:11], -4.0, v2 v_cmpx_f_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_u16_e64 s[10:11], v1, v255 v_cmpx_f_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_f_u16_e64 s[10:11], v1, s2 v_cmpx_f_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_f_u16_e64 s[10:11], v1, s101 v_cmpx_f_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_f_u16_e64 s[10:11], v1, 0 v_cmpx_f_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_f_u16_e64 s[10:11], v1, -1 v_cmpx_f_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_f_u16_e64 s[10:11], v1, 0.5 v_cmpx_f_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_f_u16_e64 s[10:11], v1, -4.0 v_cmpx_f_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_u16 vcc, v1, v2 v_cmpx_lt_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x72,0x7d] // CHECK: [0x01,0x05,0x72,0x7d]
v_cmpx_lt_u16 vcc, v255, v2 v_cmpx_lt_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x72,0x7d] // CHECK: [0xff,0x05,0x72,0x7d]
v_cmpx_lt_u16 vcc, s1, v2 v_cmpx_lt_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_lt_u16_e64 s[10:11], 0, v2 v_cmpx_lt_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xb9,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb9,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_lt_u16_e64 s[10:11], -1, v2 v_cmpx_lt_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xb9,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xb9,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_lt_u16_e64 s[10:11], 0.5, v2 v_cmpx_lt_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_u16_e64 s[10:11], -4.0, v2 v_cmpx_lt_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_u16_e64 s[10:11], v1, v255 v_cmpx_lt_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_lt_u16_e64 s[10:11], v1, s2 v_cmpx_lt_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_lt_u16_e64 s[10:11], v1, s101 v_cmpx_lt_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_lt_u16_e64 s[10:11], v1, 0 v_cmpx_lt_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_lt_u16_e64 s[10:11], v1, -1 v_cmpx_lt_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_lt_u16_e64 s[10:11], v1, 0.5 v_cmpx_lt_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_lt_u16_e64 s[10:11], v1, -4.0 v_cmpx_lt_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_u16 vcc, v1, v2 v_cmpx_eq_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x74,0x7d] // CHECK: [0x01,0x05,0x74,0x7d]
v_cmpx_eq_u16 vcc, v255, v2 v_cmpx_eq_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x74,0x7d] // CHECK: [0xff,0x05,0x74,0x7d]
v_cmpx_eq_u16 vcc, s1, v2 v_cmpx_eq_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_eq_u16_e64 s[10:11], 0, v2 v_cmpx_eq_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xba,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xba,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_eq_u16_e64 s[10:11], -1, v2 v_cmpx_eq_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xba,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xba,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_eq_u16_e64 s[10:11], 0.5, v2 v_cmpx_eq_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_u16_e64 s[10:11], -4.0, v2 v_cmpx_eq_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_u16_e64 s[10:11], v1, v255 v_cmpx_eq_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xba,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_eq_u16_e64 s[10:11], v1, s2 v_cmpx_eq_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_eq_u16_e64 s[10:11], v1, s101 v_cmpx_eq_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_eq_u16_e64 s[10:11], v1, 0 v_cmpx_eq_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_eq_u16_e64 s[10:11], v1, -1 v_cmpx_eq_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_eq_u16_e64 s[10:11], v1, 0.5 v_cmpx_eq_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_eq_u16_e64 s[10:11], v1, -4.0 v_cmpx_eq_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_u16 vcc, v1, v2 v_cmpx_le_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x76,0x7d] // CHECK: [0x01,0x05,0x76,0x7d]
v_cmpx_le_u16 vcc, v255, v2 v_cmpx_le_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x76,0x7d] // CHECK: [0xff,0x05,0x76,0x7d]
v_cmpx_le_u16 vcc, s1, v2 v_cmpx_le_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_le_u16_e64 s[10:11], 0, v2 v_cmpx_le_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xbb,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbb,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_le_u16_e64 s[10:11], -1, v2 v_cmpx_le_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xbb,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbb,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_le_u16_e64 s[10:11], 0.5, v2 v_cmpx_le_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_u16_e64 s[10:11], -4.0, v2 v_cmpx_le_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_u16_e64 s[10:11], v1, v255 v_cmpx_le_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_le_u16_e64 s[10:11], v1, s2 v_cmpx_le_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_le_u16_e64 s[10:11], v1, s101 v_cmpx_le_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_le_u16_e64 s[10:11], v1, 0 v_cmpx_le_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_le_u16_e64 s[10:11], v1, -1 v_cmpx_le_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_le_u16_e64 s[10:11], v1, 0.5 v_cmpx_le_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_le_u16_e64 s[10:11], v1, -4.0 v_cmpx_le_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_u16 vcc, v1, v2 v_cmpx_gt_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x78,0x7d] // CHECK: [0x01,0x05,0x78,0x7d]
v_cmpx_gt_u16 vcc, v255, v2 v_cmpx_gt_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x78,0x7d] // CHECK: [0xff,0x05,0x78,0x7d]
v_cmpx_gt_u16 vcc, s1, v2 v_cmpx_gt_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_gt_u16_e64 s[10:11], 0, v2 v_cmpx_gt_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xbc,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbc,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_gt_u16_e64 s[10:11], -1, v2 v_cmpx_gt_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xbc,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbc,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_gt_u16_e64 s[10:11], 0.5, v2 v_cmpx_gt_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_u16_e64 s[10:11], -4.0, v2 v_cmpx_gt_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_u16_e64 s[10:11], v1, v255 v_cmpx_gt_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_gt_u16_e64 s[10:11], v1, s2 v_cmpx_gt_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_gt_u16_e64 s[10:11], v1, s101 v_cmpx_gt_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_gt_u16_e64 s[10:11], v1, 0 v_cmpx_gt_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_gt_u16_e64 s[10:11], v1, -1 v_cmpx_gt_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_gt_u16_e64 s[10:11], v1, 0.5 v_cmpx_gt_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_gt_u16_e64 s[10:11], v1, -4.0 v_cmpx_gt_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_u16 vcc, v1, v2 v_cmpx_ne_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x7a,0x7d] // CHECK: [0x01,0x05,0x7a,0x7d]
v_cmpx_ne_u16 vcc, v255, v2 v_cmpx_ne_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x7a,0x7d] // CHECK: [0xff,0x05,0x7a,0x7d]
v_cmpx_ne_u16 vcc, s1, v2 v_cmpx_ne_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_ne_u16_e64 s[10:11], 0, v2 v_cmpx_ne_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xbd,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbd,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_ne_u16_e64 s[10:11], -1, v2 v_cmpx_ne_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xbd,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbd,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_ne_u16_e64 s[10:11], 0.5, v2 v_cmpx_ne_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_u16_e64 s[10:11], -4.0, v2 v_cmpx_ne_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_u16_e64 s[10:11], v1, v255 v_cmpx_ne_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_ne_u16_e64 s[10:11], v1, s2 v_cmpx_ne_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_ne_u16_e64 s[10:11], v1, s101 v_cmpx_ne_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_ne_u16_e64 s[10:11], v1, 0 v_cmpx_ne_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_ne_u16_e64 s[10:11], v1, -1 v_cmpx_ne_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_ne_u16_e64 s[10:11], v1, 0.5 v_cmpx_ne_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ne_u16_e64 s[10:11], v1, -4.0 v_cmpx_ne_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_u16 vcc, v1, v2 v_cmpx_ge_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x7c,0x7d] // CHECK: [0x01,0x05,0x7c,0x7d]
v_cmpx_ge_u16 vcc, v255, v2 v_cmpx_ge_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x7c,0x7d] // CHECK: [0xff,0x05,0x7c,0x7d]
v_cmpx_ge_u16 vcc, s1, v2 v_cmpx_ge_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_ge_u16_e64 s[10:11], 0, v2 v_cmpx_ge_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xbe,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbe,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_ge_u16_e64 s[10:11], -1, v2 v_cmpx_ge_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xbe,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbe,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_ge_u16_e64 s[10:11], 0.5, v2 v_cmpx_ge_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_u16_e64 s[10:11], -4.0, v2 v_cmpx_ge_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_u16_e64 s[10:11], v1, v255 v_cmpx_ge_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_ge_u16_e64 s[10:11], v1, s2 v_cmpx_ge_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_ge_u16_e64 s[10:11], v1, s101 v_cmpx_ge_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_ge_u16_e64 s[10:11], v1, 0 v_cmpx_ge_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_ge_u16_e64 s[10:11], v1, -1 v_cmpx_ge_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_ge_u16_e64 s[10:11], v1, 0.5 v_cmpx_ge_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_ge_u16_e64 s[10:11], v1, -4.0 v_cmpx_ge_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_u16 vcc, v1, v2 v_cmpx_t_u16 vcc, v1, v2
// CHECK: [0x01,0x05,0x7e,0x7d] // CHECK: [0x01,0x05,0x7e,0x7d]
v_cmpx_t_u16 vcc, v255, v2 v_cmpx_t_u16 vcc, v255, v2
// CHECK: [0xff,0x05,0x7e,0x7d] // CHECK: [0xff,0x05,0x7e,0x7d]
v_cmpx_t_u16 vcc, s1, v2 v_cmpx_t_u16 vcc, s1, v2
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
v_cmpx_t_u16_e64 s[10:11], 0, v2 v_cmpx_t_u16_e64 s[10:11], 0, v2
// CHECK: [0x0a,0x00,0xbf,0xd0,0x80,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbf,0xd0,0x80,0x04,0x02,0x00]
v_cmpx_t_u16_e64 s[10:11], -1, v2 v_cmpx_t_u16_e64 s[10:11], -1, v2
// CHECK: [0x0a,0x00,0xbf,0xd0,0xc1,0x04,0x02,0x00] // CHECK: [0x0a,0x00,0xbf,0xd0,0xc1,0x04,0x02,0x00]
v_cmpx_t_u16_e64 s[10:11], 0.5, v2 v_cmpx_t_u16_e64 s[10:11], 0.5, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_u16_e64 s[10:11], -4.0, v2 v_cmpx_t_u16_e64 s[10:11], -4.0, v2
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_u16_e64 s[10:11], v1, v255 v_cmpx_t_u16_e64 s[10:11], v1, v255
// CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0xff,0x03,0x00] // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0xff,0x03,0x00]
v_cmpx_t_u16_e64 s[10:11], v1, s2 v_cmpx_t_u16_e64 s[10:11], v1, s2
// CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x05,0x00,0x00] // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x05,0x00,0x00]
v_cmpx_t_u16_e64 s[10:11], v1, s101 v_cmpx_t_u16_e64 s[10:11], v1, s101
Show All 22 Lines
v_cmpx_t_u16_e64 s[10:11], v1, 0 v_cmpx_t_u16_e64 s[10:11], v1, 0
// CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x01,0x01,0x00] // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x01,0x01,0x00]
v_cmpx_t_u16_e64 s[10:11], v1, -1 v_cmpx_t_u16_e64 s[10:11], v1, -1
// CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x83,0x01,0x00] // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x83,0x01,0x00]
v_cmpx_t_u16_e64 s[10:11], v1, 0.5 v_cmpx_t_u16_e64 s[10:11], v1, 0.5
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmpx_t_u16_e64 s[10:11], v1, -4.0 v_cmpx_t_u16_e64 s[10:11], v1, -4.0
// CHECK-ERR: error: invalid literal operand // CHECK-ERR: error: literal operands are not supported
v_cmp_f_i32 vcc, v1, v2 v_cmp_f_i32 vcc, v1, v2
// CHECK: [0x01,0x05,0x80,0x7d] // CHECK: [0x01,0x05,0x80,0x7d]
v_cmp_f_i32 vcc, v255, v2 v_cmp_f_i32 vcc, v255, v2
// CHECK: [0xff,0x05,0x80,0x7d] // CHECK: [0xff,0x05,0x80,0x7d]
v_cmp_f_i32 vcc, s1, v2 v_cmp_f_i32 vcc, s1, v2
▲ Show 20 Lines • Show All 44,983 Lines • Show Last 20 Lines

llvm/test/MC/AMDGPU/gfx9_err_pos.s

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
// invalid operand (violates constant bus restrictions) // invalid operand (violates constant bus restrictions)
v_add_f32_e64 v0, flat_scratch_hi, m0 v_add_f32_e64 v0, flat_scratch_hi, m0
// CHECK: error: invalid operand (violates constant bus restrictions) // CHECK: error: invalid operand (violates constant bus restrictions)
// CHECK-NEXT:{{^}}v_add_f32_e64 v0, flat_scratch_hi, m0 // CHECK-NEXT:{{^}}v_add_f32_e64 v0, flat_scratch_hi, m0
// CHECK-NEXT:{{^}}^ // CHECK-NEXT:{{^}}^
//============================================================================== //==============================================================================
// literal operands are not supported
v_bfe_u32 v0, v2, v3, undef
// CHECK: error: literal operands are not supported
// CHECK-NEXT:{{^}}v_bfe_u32 v0, v2, v3, undef
// CHECK-NEXT:{{^}} ^
v_bfe_u32 v0, v2, undef, v3
// CHECK: error: literal operands are not supported
// CHECK-NEXT:{{^}}v_bfe_u32 v0, v2, undef, v3
// CHECK-NEXT:{{^}} ^
v_add_i16 v5, v1, 0.5
// CHECK: error: literal operands are not supported
// CHECK-NEXT:{{^}}v_add_i16 v5, v1, 0.5
// CHECK-NEXT:{{^}} ^
v_add_i16 v5, 0.5, v2
// CHECK: error: literal operands are not supported
// CHECK-NEXT:{{^}}v_add_i16 v5, 0.5, v2
// CHECK-NEXT:{{^}} ^
//==============================================================================
// r128 modifier is not supported on this GPU // r128 modifier is not supported on this GPU
image_atomic_add v10, v6, s[8:15] dmask:0x1 r128 image_atomic_add v10, v6, s[8:15] dmask:0x1 r128
// CHECK: error: r128 modifier is not supported on this GPU // CHECK: error: r128 modifier is not supported on this GPU
// CHECK-NEXT:{{^}}image_atomic_add v10, v6, s[8:15] dmask:0x1 r128 // CHECK-NEXT:{{^}}image_atomic_add v10, v6, s[8:15] dmask:0x1 r128
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
//============================================================================== //==============================================================================
Show All 30 Lines

llvm/test/MC/AMDGPU/literals.s

Show First 20 Lines • Show All 276 Lines • ▼ Show 20 Lines
// SICI: v_trunc_f32_e32 v0, 0x4d2 ; encoding: [0xff,0x42,0x00,0x7e,0xd2,0x04,0x00,0x00] // SICI: v_trunc_f32_e32 v0, 0x4d2 ; encoding: [0xff,0x42,0x00,0x7e,0xd2,0x04,0x00,0x00]
// GFX89: v_trunc_f32_e32 v0, 0x4d2 ; encoding: [0xff,0x38,0x00,0x7e,0xd2,0x04,0x00,0x00] // GFX89: v_trunc_f32_e32 v0, 0x4d2 ; encoding: [0xff,0x38,0x00,0x7e,0xd2,0x04,0x00,0x00]
v_trunc_f32_e32 v0, 1234 v_trunc_f32_e32 v0, 1234
// SICI: v_fract_f64_e32 v[0:1], 0x4d2 ; encoding: [0xff,0x7c,0x00,0x7e,0xd2,0x04,0x00,0x00] // SICI: v_fract_f64_e32 v[0:1], 0x4d2 ; encoding: [0xff,0x7c,0x00,0x7e,0xd2,0x04,0x00,0x00]
// GFX89: v_fract_f64_e32 v[0:1], 0x4d2 ; encoding: [0xff,0x64,0x00,0x7e,0xd2,0x04,0x00,0x00] // GFX89: v_fract_f64_e32 v[0:1], 0x4d2 ; encoding: [0xff,0x64,0x00,0x7e,0xd2,0x04,0x00,0x00]
v_fract_f64_e32 v[0:1], 1234 v_fract_f64_e32 v[0:1], 1234
// NOSICI: error: invalid literal operand // NOSICI: error: literal operands are not supported
// NOGFX89: error: invalid literal operand // NOGFX89: error: literal operands are not supported
v_trunc_f32_e64 v0, 1234 v_trunc_f32_e64 v0, 1234
// NOSICI: error: invalid literal operand // NOSICI: error: literal operands are not supported
// NOGFX89: error: invalid literal operand // NOGFX89: error: literal operands are not supported
v_fract_f64_e64 v[0:1], 1234 v_fract_f64_e64 v[0:1], 1234
// SICI: v_trunc_f32_e32 v0, 0xffff2bcf ; encoding: [0xff,0x42,0x00,0x7e,0xcf,0x2b,0xff,0xff] // SICI: v_trunc_f32_e32 v0, 0xffff2bcf ; encoding: [0xff,0x42,0x00,0x7e,0xcf,0x2b,0xff,0xff]
// GFX89: v_trunc_f32_e32 v0, 0xffff2bcf ; encoding: [0xff,0x38,0x00,0x7e,0xcf,0x2b,0xff,0xff] // GFX89: v_trunc_f32_e32 v0, 0xffff2bcf ; encoding: [0xff,0x38,0x00,0x7e,0xcf,0x2b,0xff,0xff]
v_trunc_f32_e32 v0, -54321 v_trunc_f32_e32 v0, -54321
// SICI: v_fract_f64_e32 v[0:1], 0xffff2bcf ; encoding: [0xff,0x7c,0x00,0x7e,0xcf,0x2b,0xff,0xff] // SICI: v_fract_f64_e32 v[0:1], 0xffff2bcf ; encoding: [0xff,0x7c,0x00,0x7e,0xcf,0x2b,0xff,0xff]
// GFX89: v_fract_f64_e32 v[0:1], 0xffff2bcf ; encoding: [0xff,0x64,0x00,0x7e,0xcf,0x2b,0xff,0xff] // GFX89: v_fract_f64_e32 v[0:1], 0xffff2bcf ; encoding: [0xff,0x64,0x00,0x7e,0xcf,0x2b,0xff,0xff]
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
// SICI: s_mov_b64 s[0:1], 0x4d2 ; encoding: [0xff,0x04,0x80,0xbe,0xd2,0x04,0x00,0x00] // SICI: s_mov_b64 s[0:1], 0x4d2 ; encoding: [0xff,0x04,0x80,0xbe,0xd2,0x04,0x00,0x00]
// GFX89: s_mov_b64 s[0:1], 0x4d2 ; encoding: [0xff,0x01,0x80,0xbe,0xd2,0x04,0x00,0x00] // GFX89: s_mov_b64 s[0:1], 0x4d2 ; encoding: [0xff,0x01,0x80,0xbe,0xd2,0x04,0x00,0x00]
s_mov_b64_e32 s[0:1], 1234 s_mov_b64_e32 s[0:1], 1234
// SICI: v_and_b32_e32 v0, 0x4d2, v1 ; encoding: [0xff,0x02,0x00,0x36,0xd2,0x04,0x00,0x00] // SICI: v_and_b32_e32 v0, 0x4d2, v1 ; encoding: [0xff,0x02,0x00,0x36,0xd2,0x04,0x00,0x00]
// GFX89: v_and_b32_e32 v0, 0x4d2, v1 ; encoding: [0xff,0x02,0x00,0x26,0xd2,0x04,0x00,0x00] // GFX89: v_and_b32_e32 v0, 0x4d2, v1 ; encoding: [0xff,0x02,0x00,0x26,0xd2,0x04,0x00,0x00]
v_and_b32_e32 v0, 1234, v1 v_and_b32_e32 v0, 1234, v1
// NOSICI: error: invalid literal operand // NOSICI: error: literal operands are not supported
// NOGFX89: error: invalid literal operand // NOGFX89: error: literal operands are not supported
v_and_b32_e64 v0, 1234, v1 v_and_b32_e64 v0, 1234, v1
// SICI: s_mov_b64 s[0:1], 0xffff2bcf ; encoding: [0xff,0x04,0x80,0xbe,0xcf,0x2b,0xff,0xff] // SICI: s_mov_b64 s[0:1], 0xffff2bcf ; encoding: [0xff,0x04,0x80,0xbe,0xcf,0x2b,0xff,0xff]
// GFX89: s_mov_b64 s[0:1], 0xffff2bcf ; encoding: [0xff,0x01,0x80,0xbe,0xcf,0x2b,0xff,0xff] // GFX89: s_mov_b64 s[0:1], 0xffff2bcf ; encoding: [0xff,0x01,0x80,0xbe,0xcf,0x2b,0xff,0xff]
s_mov_b64_e32 s[0:1], -54321 s_mov_b64_e32 s[0:1], -54321
// SICI: v_and_b32_e32 v0, 0xffff2bcf, v1 ; encoding: [0xff,0x02,0x00,0x36,0xcf,0x2b,0xff,0xff] // SICI: v_and_b32_e32 v0, 0xffff2bcf, v1 ; encoding: [0xff,0x02,0x00,0x36,0xcf,0x2b,0xff,0xff]
// GFX89: v_and_b32_e32 v0, 0xffff2bcf, v1 ; encoding: [0xff,0x02,0x00,0x26,0xcf,0x2b,0xff,0xff] // GFX89: v_and_b32_e32 v0, 0xffff2bcf, v1 ; encoding: [0xff,0x02,0x00,0x26,0xcf,0x2b,0xff,0xff]
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
// NOSICI: error: invalid operand for instruction // NOSICI: error: invalid operand for instruction
// NOGFX89: error: invalid operand for instruction // NOGFX89: error: invalid operand for instruction
v_trunc_f32_e64 v0, 0x3fc45f306dc9c882 v_trunc_f32_e64 v0, 0x3fc45f306dc9c882
// NOSICI: error: invalid operand for instruction // NOSICI: error: invalid operand for instruction
// GFX89: v_fract_f64_e64 v[0:1], 0.15915494309189532 ; encoding: [0x00,0x00,0x72,0xd1,0xf8,0x00,0x00,0x00] // GFX89: v_fract_f64_e64 v[0:1], 0.15915494309189532 ; encoding: [0x00,0x00,0x72,0xd1,0xf8,0x00,0x00,0x00]
v_fract_f64_e64 v[0:1], 0x3fc45f306dc9c882 v_fract_f64_e64 v[0:1], 0x3fc45f306dc9c882
// NOSICI: error: invalid literal operand // NOSICI: error: literal operands are not supported
// GFX89: v_trunc_f32_e64 v0, 0.15915494 ; encoding: [0x00,0x00,0x5c,0xd1,0xf8,0x00,0x00,0x00] // GFX89: v_trunc_f32_e64 v0, 0.15915494 ; encoding: [0x00,0x00,0x5c,0xd1,0xf8,0x00,0x00,0x00]
v_trunc_f32_e64 v0, 0x3e22f983 v_trunc_f32_e64 v0, 0x3e22f983
// NOSICI: error: invalid literal operand // NOSICI: error: literal operands are not supported
// NOGFX89: error: invalid literal operand // NOGFX89: error: literal operands are not supported
v_fract_f64_e64 v[0:1], 0x3e22f983 v_fract_f64_e64 v[0:1], 0x3e22f983
// NOSICI: error: invalid operand for instruction // NOSICI: error: invalid operand for instruction
// GFX89: s_mov_b64 s[0:1], 0.15915494309189532 ; encoding: [0xf8,0x01,0x80,0xbe] // GFX89: s_mov_b64 s[0:1], 0.15915494309189532 ; encoding: [0xf8,0x01,0x80,0xbe]
s_mov_b64_e32 s[0:1], 0.159154943091895317852646485335 s_mov_b64_e32 s[0:1], 0.159154943091895317852646485335
// SICI: v_and_b32_e32 v0, 0x3e22f983, v1 ; encoding: [0xff,0x02,0x00,0x36,0x83,0xf9,0x22,0x3e] // SICI: v_and_b32_e32 v0, 0x3e22f983, v1 ; encoding: [0xff,0x02,0x00,0x36,0x83,0xf9,0x22,0x3e]
// GFX89: v_and_b32_e32 v0, 0.15915494, v1 ; encoding: [0xf8,0x02,0x00,0x26] // GFX89: v_and_b32_e32 v0, 0.15915494, v1 ; encoding: [0xf8,0x02,0x00,0x26]
v_and_b32_e32 v0, 0.159154943091895317852646485335, v1 v_and_b32_e32 v0, 0.159154943091895317852646485335, v1
// NOSICI: error: invalid literal operand // NOSICI: error: literal operands are not supported
// GFX89: v_and_b32_e64 v0, 0.15915494, v1 ; encoding: [0x00,0x00,0x13,0xd1,0xf8,0x02,0x02,0x00] // GFX89: v_and_b32_e64 v0, 0.15915494, v1 ; encoding: [0x00,0x00,0x13,0xd1,0xf8,0x02,0x02,0x00]
v_and_b32_e64 v0, 0.159154943091895317852646485335, v1 v_and_b32_e64 v0, 0.159154943091895317852646485335, v1
// SICI: v_fract_f64_e32 v[0:1], 0x3fc45f30 ; encoding: [0xff,0x7c,0x00,0x7e,0x30,0x5f,0xc4,0x3f] // SICI: v_fract_f64_e32 v[0:1], 0x3fc45f30 ; encoding: [0xff,0x7c,0x00,0x7e,0x30,0x5f,0xc4,0x3f]
// GFX89: v_fract_f64_e32 v[0:1], 0.15915494309189532 ; encoding: [0xf8,0x64,0x00,0x7e] // GFX89: v_fract_f64_e32 v[0:1], 0.15915494309189532 ; encoding: [0xf8,0x64,0x00,0x7e]
v_fract_f64 v[0:1], 0.159154943091895317852646485335 v_fract_f64 v[0:1], 0.159154943091895317852646485335
// SICI: v_trunc_f32_e32 v0, 0x3e22f983 ; encoding: [0xff,0x42,0x00,0x7e,0x83,0xf9,0x22,0x3e] // SICI: v_trunc_f32_e32 v0, 0x3e22f983 ; encoding: [0xff,0x42,0x00,0x7e,0x83,0xf9,0x22,0x3e]
▲ Show 20 Lines • Show All 386 Lines • Show Last 20 Lines

llvm/test/MC/AMDGPU/literalv216-err.s

// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck -check-prefix=GFX9 --implicit-check-not=error: %s // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck -check-prefix=GFX9 --implicit-check-not=error: %s
// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1010 %s 2>&1 | FileCheck -check-prefix=GFX10 --implicit-check-not=error: %s // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1010 %s 2>&1 | FileCheck -check-prefix=GFX10 --implicit-check-not=error: %s
v_pk_add_f16 v1, -17, v2 v_pk_add_f16 v1, -17, v2
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported
v_pk_add_f16 v1, 65, v2 v_pk_add_f16 v1, 65, v2
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported
v_pk_add_f16 v1, 64.0, v2 v_pk_add_f16 v1, 64.0, v2
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported
v_pk_add_f16 v1, -0.15915494, v2 v_pk_add_f16 v1, -0.15915494, v2
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported
v_pk_add_f16 v1, -0.0, v2 v_pk_add_f16 v1, -0.0, v2
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported
v_pk_add_f16 v1, -32768, v2 v_pk_add_f16 v1, -32768, v2
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported
v_pk_add_f16 v1, 32767, v2 v_pk_add_f16 v1, 32767, v2
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported
v_pk_add_f16 v1, 0xffffffffffff000f, v2 v_pk_add_f16 v1, 0xffffffffffff000f, v2
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported
v_pk_add_f16 v1, 0x1000ffff, v2 v_pk_add_f16 v1, 0x1000ffff, v2
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported
v_pk_mad_i16 v5, 0x3c00, 0x4000, 0x4400 v_pk_mad_i16 v5, 0x3c00, 0x4000, 0x4400
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported
// GFX10: error: invalid literal operand // GFX10: error: only one literal operand is allowed
v_pk_mad_i16 v5, 0x3c00, 0x4000, 2 v_pk_mad_i16 v5, 0x3c00, 0x4000, 2
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported
// GFX10: error: invalid literal operand // GFX10: error: only one literal operand is allowed
v_pk_mad_i16 v5, 0x3c00, 3, 2 v_pk_mad_i16 v5, 0x3c00, 3, 2
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported
v_pk_mad_i16 v5, 3, 0x3c00, 2 v_pk_mad_i16 v5, 3, 0x3c00, 2
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported
v_pk_mad_i16 v5, 3, 2, 0x3c00 v_pk_mad_i16 v5, 3, 2, 0x3c00
// GFX9: error: invalid literal operand // GFX9: error: literal operands are not supported

llvm/test/MC/AMDGPU/literalv216.s

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines
// GFX9: v_pk_add_f16 v1, -1, v2 ; encoding: [0x01,0x00,0x8f,0xd3,0xc1,0x04,0x02,0x18] // GFX9: v_pk_add_f16 v1, -1, v2 ; encoding: [0x01,0x00,0x8f,0xd3,0xc1,0x04,0x02,0x18]
// GFX10: v_pk_add_f16 v1, -1, v2 ; encoding: [0x01,0x00,0x0f,0xcc,0xc1,0x04,0x02,0x18] // GFX10: v_pk_add_f16 v1, -1, v2 ; encoding: [0x01,0x00,0x0f,0xcc,0xc1,0x04,0x02,0x18]
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Integer literals // Integer literals
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
v_pk_add_f16 v5, v1, 0x12345678 v_pk_add_f16 v5, v1, 0x12345678
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_add_f16 v5, v1, 0x12345678 ; encoding: [0x05,0x00,0x0f,0xcc,0x01,0xff,0x01,0x18,0x78,0x56,0x34,0x12] // GFX10: v_pk_add_f16 v5, v1, 0x12345678 ; encoding: [0x05,0x00,0x0f,0xcc,0x01,0xff,0x01,0x18,0x78,0x56,0x34,0x12]
v_pk_add_f16 v5, 0x12345678, v2 v_pk_add_f16 v5, 0x12345678, v2
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_add_f16 v5, 0x12345678, v2 ; encoding: [0x05,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x78,0x56,0x34,0x12] // GFX10: v_pk_add_f16 v5, 0x12345678, v2 ; encoding: [0x05,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x78,0x56,0x34,0x12]
v_pk_add_f16 v5, -256, v2 v_pk_add_f16 v5, -256, v2
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_add_f16 v5, 0xffffff00, v2 ; encoding: [0x05,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x00,0xff,0xff,0xff] // GFX10: v_pk_add_f16 v5, 0xffffff00, v2 ; encoding: [0x05,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x00,0xff,0xff,0xff]
v_pk_add_f16 v5, v1, 256 v_pk_add_f16 v5, v1, 256
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_add_f16 v5, v1, 0x100 ; encoding: [0x05,0x00,0x0f,0xcc,0x01,0xff,0x01,0x18,0x00,0x01,0x00,0x00] // GFX10: v_pk_add_f16 v5, v1, 0x100 ; encoding: [0x05,0x00,0x0f,0xcc,0x01,0xff,0x01,0x18,0x00,0x01,0x00,0x00]
v_pk_add_u16 v5, v1, 0x12345678 v_pk_add_u16 v5, v1, 0x12345678
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_add_u16 v5, v1, 0x12345678 ; encoding: [0x05,0x00,0x0a,0xcc,0x01,0xff,0x01,0x18,0x78,0x56,0x34,0x12] // GFX10: v_pk_add_u16 v5, v1, 0x12345678 ; encoding: [0x05,0x00,0x0a,0xcc,0x01,0xff,0x01,0x18,0x78,0x56,0x34,0x12]
v_pk_add_u16 v5, 0x12345678, v2 v_pk_add_u16 v5, 0x12345678, v2
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_add_u16 v5, 0x12345678, v2 ; encoding: [0x05,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x78,0x56,0x34,0x12] // GFX10: v_pk_add_u16 v5, 0x12345678, v2 ; encoding: [0x05,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x78,0x56,0x34,0x12]
v_pk_add_u16 v5, -256, v2 v_pk_add_u16 v5, -256, v2
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_add_u16 v5, 0xffffff00, v2 ; encoding: [0x05,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x00,0xff,0xff,0xff] // GFX10: v_pk_add_u16 v5, 0xffffff00, v2 ; encoding: [0x05,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x00,0xff,0xff,0xff]
v_pk_add_u16 v5, v1, 256 v_pk_add_u16 v5, v1, 256
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_add_u16 v5, v1, 0x100 ; encoding: [0x05,0x00,0x0a,0xcc,0x01,0xff,0x01,0x18,0x00,0x01,0x00,0x00] // GFX10: v_pk_add_u16 v5, v1, 0x100 ; encoding: [0x05,0x00,0x0a,0xcc,0x01,0xff,0x01,0x18,0x00,0x01,0x00,0x00]
v_pk_add_f16 v5, v1, 0x123456780 v_pk_add_f16 v5, v1, 0x123456780
// NOGFX9: error: invalid operand for instruction // NOGFX9: error: invalid operand for instruction
// NOGFX10: error: invalid operand for instruction // NOGFX10: error: invalid operand for instruction
v_pk_add_u16 v5, v1, 0x123456780 v_pk_add_u16 v5, v1, 0x123456780
// NOGFX9: error: invalid operand for instruction // NOGFX9: error: invalid operand for instruction
// NOGFX10: error: invalid operand for instruction // NOGFX10: error: invalid operand for instruction
v_pk_fma_f16 v5, 0xaf123456, v2, v3 v_pk_fma_f16 v5, 0xaf123456, v2, v3
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_fma_f16 v5, 0xaf123456, v2, v3 ; encoding: [0x05,0x40,0x0e,0xcc,0xff,0x04,0x0e,0x1c,0x56,0x34,0x12,0xaf] // GFX10: v_pk_fma_f16 v5, 0xaf123456, v2, v3 ; encoding: [0x05,0x40,0x0e,0xcc,0xff,0x04,0x0e,0x1c,0x56,0x34,0x12,0xaf]
v_pk_fma_f16 v5, v1, 0xaf123456, v3 v_pk_fma_f16 v5, v1, 0xaf123456, v3
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_fma_f16 v5, v1, 0xaf123456, v3 ; encoding: [0x05,0x40,0x0e,0xcc,0x01,0xff,0x0d,0x1c,0x56,0x34,0x12,0xaf] // GFX10: v_pk_fma_f16 v5, v1, 0xaf123456, v3 ; encoding: [0x05,0x40,0x0e,0xcc,0x01,0xff,0x0d,0x1c,0x56,0x34,0x12,0xaf]
v_pk_fma_f16 v5, v1, v2, 0xaf123456 v_pk_fma_f16 v5, v1, v2, 0xaf123456
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_fma_f16 v5, v1, v2, 0xaf123456 ; encoding: [0x05,0x40,0x0e,0xcc,0x01,0x05,0xfe,0x1b,0x56,0x34,0x12,0xaf] // GFX10: v_pk_fma_f16 v5, v1, v2, 0xaf123456 ; encoding: [0x05,0x40,0x0e,0xcc,0x01,0x05,0xfe,0x1b,0x56,0x34,0x12,0xaf]
v_pk_mad_i16 v5, 0xaf123456, v2, v3 v_pk_mad_i16 v5, 0xaf123456, v2, v3
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_mad_i16 v5, 0xaf123456, v2, v3 ; encoding: [0x05,0x40,0x00,0xcc,0xff,0x04,0x0e,0x1c,0x56,0x34,0x12,0xaf] // GFX10: v_pk_mad_i16 v5, 0xaf123456, v2, v3 ; encoding: [0x05,0x40,0x00,0xcc,0xff,0x04,0x0e,0x1c,0x56,0x34,0x12,0xaf]
v_pk_mad_i16 v5, v1, 0xaf123456, v3 v_pk_mad_i16 v5, v1, 0xaf123456, v3
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_mad_i16 v5, v1, 0xaf123456, v3 ; encoding: [0x05,0x40,0x00,0xcc,0x01,0xff,0x0d,0x1c,0x56,0x34,0x12,0xaf] // GFX10: v_pk_mad_i16 v5, v1, 0xaf123456, v3 ; encoding: [0x05,0x40,0x00,0xcc,0x01,0xff,0x0d,0x1c,0x56,0x34,0x12,0xaf]
v_pk_mad_i16 v5, v1, v2, 0xaf123456 v_pk_mad_i16 v5, v1, v2, 0xaf123456
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_mad_i16 v5, v1, v2, 0xaf123456 ; encoding: [0x05,0x40,0x00,0xcc,0x01,0x05,0xfe,0x1b,0x56,0x34,0x12,0xaf] // GFX10: v_pk_mad_i16 v5, v1, v2, 0xaf123456 ; encoding: [0x05,0x40,0x00,0xcc,0x01,0x05,0xfe,0x1b,0x56,0x34,0x12,0xaf]
v_pk_ashrrev_i16 v5, 0x12345678, v2 v_pk_ashrrev_i16 v5, 0x12345678, v2
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_ashrrev_i16 v5, 0x12345678, v2 ; encoding: [0x05,0x00,0x06,0xcc,0xff,0x04,0x02,0x18,0x78,0x56,0x34,0x12] // GFX10: v_pk_ashrrev_i16 v5, 0x12345678, v2 ; encoding: [0x05,0x00,0x06,0xcc,0xff,0x04,0x02,0x18,0x78,0x56,0x34,0x12]
v_pk_ashrrev_i16 v5, v1, 0x12345678 v_pk_ashrrev_i16 v5, v1, 0x12345678
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_ashrrev_i16 v5, v1, 0x12345678 ; encoding: [0x05,0x00,0x06,0xcc,0x01,0xff,0x01,0x18,0x78,0x56,0x34,0x12] // GFX10: v_pk_ashrrev_i16 v5, v1, 0x12345678 ; encoding: [0x05,0x00,0x06,0xcc,0x01,0xff,0x01,0x18,0x78,0x56,0x34,0x12]
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Floating-point literals (allowed if lossless conversion to f16 is possible) // Floating-point literals (allowed if lossless conversion to f16 is possible)
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
v_pk_add_f16 v5, v1, 0.1234 v_pk_add_f16 v5, v1, 0.1234
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_add_f16 v5, v1, 0x2fe6 ; encoding: [0x05,0x00,0x0f,0xcc,0x01,0xff,0x01,0x18,0xe6,0x2f,0x00,0x00] // GFX10: v_pk_add_f16 v5, v1, 0x2fe6 ; encoding: [0x05,0x00,0x0f,0xcc,0x01,0xff,0x01,0x18,0xe6,0x2f,0x00,0x00]
v_pk_add_u16 v5, v1, 0.1234 v_pk_add_u16 v5, v1, 0.1234
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_add_u16 v5, v1, 0x2fe6 ; encoding: [0x05,0x00,0x0a,0xcc,0x01,0xff,0x01,0x18,0xe6,0x2f,0x00,0x00] // GFX10: v_pk_add_u16 v5, v1, 0x2fe6 ; encoding: [0x05,0x00,0x0a,0xcc,0x01,0xff,0x01,0x18,0xe6,0x2f,0x00,0x00]
v_pk_fma_f16 v5, 0.1234, v2, v3 v_pk_fma_f16 v5, 0.1234, v2, v3
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_fma_f16 v5, 0x2fe6, v2, v3 ; encoding: [0x05,0x40,0x0e,0xcc,0xff,0x04,0x0e,0x1c,0xe6,0x2f,0x00,0x00] // GFX10: v_pk_fma_f16 v5, 0x2fe6, v2, v3 ; encoding: [0x05,0x40,0x0e,0xcc,0xff,0x04,0x0e,0x1c,0xe6,0x2f,0x00,0x00]
v_pk_fma_f16 v5, v1, 0.1234, v3 v_pk_fma_f16 v5, v1, 0.1234, v3
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_fma_f16 v5, v1, 0x2fe6, v3 ; encoding: [0x05,0x40,0x0e,0xcc,0x01,0xff,0x0d,0x1c,0xe6,0x2f,0x00,0x00] // GFX10: v_pk_fma_f16 v5, v1, 0x2fe6, v3 ; encoding: [0x05,0x40,0x0e,0xcc,0x01,0xff,0x0d,0x1c,0xe6,0x2f,0x00,0x00]
v_pk_fma_f16 v5, v1, v2, 0.1234 v_pk_fma_f16 v5, v1, v2, 0.1234
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_fma_f16 v5, v1, v2, 0x2fe6 ; encoding: [0x05,0x40,0x0e,0xcc,0x01,0x05,0xfe,0x1b,0xe6,0x2f,0x00,0x00] // GFX10: v_pk_fma_f16 v5, v1, v2, 0x2fe6 ; encoding: [0x05,0x40,0x0e,0xcc,0x01,0x05,0xfe,0x1b,0xe6,0x2f,0x00,0x00]
v_pk_mad_i16 v5, 0.1234, v2, v3 v_pk_mad_i16 v5, 0.1234, v2, v3
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_mad_i16 v5, 0x2fe6, v2, v3 ; encoding: [0x05,0x40,0x00,0xcc,0xff,0x04,0x0e,0x1c,0xe6,0x2f,0x00,0x00] // GFX10: v_pk_mad_i16 v5, 0x2fe6, v2, v3 ; encoding: [0x05,0x40,0x00,0xcc,0xff,0x04,0x0e,0x1c,0xe6,0x2f,0x00,0x00]
v_pk_mad_i16 v5, v1, 0.1234, v3 v_pk_mad_i16 v5, v1, 0.1234, v3
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_mad_i16 v5, v1, 0x2fe6, v3 ; encoding: [0x05,0x40,0x00,0xcc,0x01,0xff,0x0d,0x1c,0xe6,0x2f,0x00,0x00] // GFX10: v_pk_mad_i16 v5, v1, 0x2fe6, v3 ; encoding: [0x05,0x40,0x00,0xcc,0x01,0xff,0x0d,0x1c,0xe6,0x2f,0x00,0x00]
v_pk_mad_i16 v5, v1, v2, 0.1234 v_pk_mad_i16 v5, v1, v2, 0.1234
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// GFX10: v_pk_mad_i16 v5, v1, v2, 0x2fe6 ; encoding: [0x05,0x40,0x00,0xcc,0x01,0x05,0xfe,0x1b,0xe6,0x2f,0x00,0x00] // GFX10: v_pk_mad_i16 v5, v1, v2, 0x2fe6 ; encoding: [0x05,0x40,0x00,0xcc,0x01,0x05,0xfe,0x1b,0xe6,0x2f,0x00,0x00]
v_pk_add_f16 v5, v1, 123456.0 v_pk_add_f16 v5, v1, 123456.0
// NOGFX9: error: invalid operand for instruction // NOGFX9: error: invalid operand for instruction
// NOGFX10: error: invalid operand for instruction // NOGFX10: error: invalid operand for instruction
v_pk_add_u16 v5, v1, 123456.0 v_pk_add_u16 v5, v1, 123456.0
// NOGFX9: error: invalid operand for instruction // NOGFX9: error: invalid operand for instruction
Show All 10 Lines

llvm/test/MC/AMDGPU/mai-err.s

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x1f32 a[0:31], v0, v1, 65 v_mfma_f32_32x32x1f32 a[0:31], v0, v1, 65
// GFX908: error: invalid operand for instruction // GFX908: error: invalid operand for instruction
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x1f32 a[0:31], v0, v1, 0 v_mfma_f32_32x32x1f32 a[0:31], v0, v1, 0
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
v_mfma_f32_32x32x1f32 a[0:31], v0, v1, -2.0 v_mfma_f32_32x32x1f32 a[0:31], v0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x1f32 a[0:31], v0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x1f32 a[0:31], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x1f32 a[0:31], v0, a1, -2.0 v_mfma_f32_32x32x1f32 a[0:31], v0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x1f32 a[0:31], v0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x1f32 a[0:31], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x1f32 a[0:31], a0, v1, -2.0 v_mfma_f32_32x32x1f32 a[0:31], a0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x1f32 a[0:31], a0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x1f32 a[0:31], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x1f32 a[0:31], a0, a1, -2.0 v_mfma_f32_32x32x1f32 a[0:31], a0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x1f32 a[0:31], a0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x1f32 a[0:31], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x1f32 a[0:15], v0, v1, -2.0 v_mfma_f32_16x16x1f32 a[0:15], v0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x1f32 a[0:15], v0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x1f32 a[0:15], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x1f32 a[0:15], v0, a1, -2.0 v_mfma_f32_16x16x1f32 a[0:15], v0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x1f32 a[0:15], v0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x1f32 a[0:15], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x1f32 a[0:15], a0, v1, -2.0 v_mfma_f32_16x16x1f32 a[0:15], a0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x1f32 a[0:15], a0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x1f32 a[0:15], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x1f32 a[0:15], a0, a1, -2.0 v_mfma_f32_16x16x1f32 a[0:15], a0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x1f32 a[0:15], a0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x1f32 a[0:15], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x1f32 a[0:3], v0, v1, -2.0 v_mfma_f32_4x4x1f32 a[0:3], v0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x1f32 a[0:3], v0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_4x4x1f32 a[0:3], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x1f32 a[0:3], v0, a1, -2.0 v_mfma_f32_4x4x1f32 a[0:3], v0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x1f32 a[0:3], v0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_4x4x1f32 a[0:3], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x1f32 a[0:3], a0, v1, -2.0 v_mfma_f32_4x4x1f32 a[0:3], a0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x1f32 a[0:3], a0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_4x4x1f32 a[0:3], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x1f32 a[0:3], a0, a1, -2.0 v_mfma_f32_4x4x1f32 a[0:3], a0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x1f32 a[0:3], a0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_4x4x1f32 a[0:3], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2f32 a[0:15], v0, v1, -2.0 v_mfma_f32_32x32x2f32 a[0:15], v0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2f32 a[0:15], v0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x2f32 a[0:15], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2f32 a[0:15], v0, a1, -2.0 v_mfma_f32_32x32x2f32 a[0:15], v0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2f32 a[0:15], v0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x2f32 a[0:15], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2f32 a[0:15], a0, v1, -2.0 v_mfma_f32_32x32x2f32 a[0:15], a0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2f32 a[0:15], a0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x2f32 a[0:15], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2f32 a[0:15], a0, a1, -2.0 v_mfma_f32_32x32x2f32 a[0:15], a0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2f32 a[0:15], a0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x2f32 a[0:15], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f32 a[0:3], v0, v1, -2.0 v_mfma_f32_16x16x4f32 a[0:3], v0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f32 a[0:3], v0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x4f32 a[0:3], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f32 a[0:3], v0, a1, -2.0 v_mfma_f32_16x16x4f32 a[0:3], v0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f32 a[0:3], v0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x4f32 a[0:3], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f32 a[0:3], a0, v1, -2.0 v_mfma_f32_16x16x4f32 a[0:3], a0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f32 a[0:3], a0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x4f32 a[0:3], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f32 a[0:3], a0, a1, -2.0 v_mfma_f32_16x16x4f32 a[0:3], a0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f32 a[0:3], a0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x4f32 a[0:3], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4f16 a[0:31], v[0:1], v[1:2], -2.0 v_mfma_f32_32x32x4f16 a[0:31], v[0:1], v[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4f16 a[0:31], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x4f16 a[0:31], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4f16 a[0:31], v[0:1], a[1:2], -2.0 v_mfma_f32_32x32x4f16 a[0:31], v[0:1], a[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4f16 a[0:31], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x4f16 a[0:31], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4f16 a[0:31], a[0:1], v[1:2], -2.0 v_mfma_f32_32x32x4f16 a[0:31], a[0:1], v[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4f16 a[0:31], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x4f16 a[0:31], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4f16 a[0:31], a[0:1], a[1:2], -2.0 v_mfma_f32_32x32x4f16 a[0:31], a[0:1], a[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4f16 a[0:31], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x4f16 a[0:31], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f16 a[0:15], v[0:1], v[1:2], -2.0 v_mfma_f32_16x16x4f16 a[0:15], v[0:1], v[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f16 a[0:15], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x4f16 a[0:15], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f16 a[0:15], v[0:1], a[1:2], -2.0 v_mfma_f32_16x16x4f16 a[0:15], v[0:1], a[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f16 a[0:15], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x4f16 a[0:15], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f16 a[0:15], a[0:1], v[1:2], -2.0 v_mfma_f32_16x16x4f16 a[0:15], a[0:1], v[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f16 a[0:15], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x4f16 a[0:15], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f16 a[0:15], a[0:1], a[1:2], -2.0 v_mfma_f32_16x16x4f16 a[0:15], a[0:1], a[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x4f16 a[0:15], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x4f16 a[0:15], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x4f16 a[0:3], v[0:1], v[1:2], -2.0 v_mfma_f32_4x4x4f16 a[0:3], v[0:1], v[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x4f16 a[0:3], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_4x4x4f16 a[0:3], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x4f16 a[0:3], v[0:1], a[1:2], -2.0 v_mfma_f32_4x4x4f16 a[0:3], v[0:1], a[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x4f16 a[0:3], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_4x4x4f16 a[0:3], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x4f16 a[0:3], a[0:1], v[1:2], -2.0 v_mfma_f32_4x4x4f16 a[0:3], a[0:1], v[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x4f16 a[0:3], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_4x4x4f16 a[0:3], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x4f16 a[0:3], a[0:1], a[1:2], -2.0 v_mfma_f32_4x4x4f16 a[0:3], a[0:1], a[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x4f16 a[0:3], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_4x4x4f16 a[0:3], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x8f16 a[0:15], v[0:1], v[1:2], -2.0 v_mfma_f32_32x32x8f16 a[0:15], v[0:1], v[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x8f16 a[0:15], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x8f16 a[0:15], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x8f16 a[0:15], v[0:1], a[1:2], -2.0 v_mfma_f32_32x32x8f16 a[0:15], v[0:1], a[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x8f16 a[0:15], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x8f16 a[0:15], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x8f16 a[0:15], a[0:1], v[1:2], -2.0 v_mfma_f32_32x32x8f16 a[0:15], a[0:1], v[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x8f16 a[0:15], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x8f16 a[0:15], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x8f16 a[0:15], a[0:1], a[1:2], -2.0 v_mfma_f32_32x32x8f16 a[0:15], a[0:1], a[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x8f16 a[0:15], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x8f16 a[0:15], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x16f16 a[0:3], v[0:1], v[1:2], -2.0 v_mfma_f32_16x16x16f16 a[0:3], v[0:1], v[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x16f16 a[0:3], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x16f16 a[0:3], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x16f16 a[0:3], v[0:1], a[1:2], -2.0 v_mfma_f32_16x16x16f16 a[0:3], v[0:1], a[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x16f16 a[0:3], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x16f16 a[0:3], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x16f16 a[0:3], a[0:1], v[1:2], -2.0 v_mfma_f32_16x16x16f16 a[0:3], a[0:1], v[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x16f16 a[0:3], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x16f16 a[0:3], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x16f16 a[0:3], a[0:1], a[1:2], -2.0 v_mfma_f32_16x16x16f16 a[0:3], a[0:1], a[1:2], -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x16f16 a[0:3], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x16f16 a[0:3], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x4i8 a[0:31], v0, v1, 2 v_mfma_i32_32x32x4i8 a[0:31], v0, v1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x4i8 a[0:31], v0, v1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_32x32x4i8 a[0:31], v0, v1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x4i8 a[0:31], v0, a1, 2 v_mfma_i32_32x32x4i8 a[0:31], v0, a1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x4i8 a[0:31], v0, a1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_32x32x4i8 a[0:31], v0, a1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x4i8 a[0:31], a0, v1, 2 v_mfma_i32_32x32x4i8 a[0:31], a0, v1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x4i8 a[0:31], a0, v1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_32x32x4i8 a[0:31], a0, v1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x4i8 a[0:31], a0, a1, 2 v_mfma_i32_32x32x4i8 a[0:31], a0, a1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x4i8 a[0:31], a0, a1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_32x32x4i8 a[0:31], a0, a1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x4i8 a[0:15], v0, v1, 2 v_mfma_i32_16x16x4i8 a[0:15], v0, v1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x4i8 a[0:15], v0, v1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_16x16x4i8 a[0:15], v0, v1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x4i8 a[0:15], v0, a1, 2 v_mfma_i32_16x16x4i8 a[0:15], v0, a1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x4i8 a[0:15], v0, a1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_16x16x4i8 a[0:15], v0, a1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x4i8 a[0:15], a0, v1, 2 v_mfma_i32_16x16x4i8 a[0:15], a0, v1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x4i8 a[0:15], a0, v1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_16x16x4i8 a[0:15], a0, v1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x4i8 a[0:15], a0, a1, 2 v_mfma_i32_16x16x4i8 a[0:15], a0, a1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x4i8 a[0:15], a0, a1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_16x16x4i8 a[0:15], a0, a1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_4x4x4i8 a[0:3], v0, v1, 2 v_mfma_i32_4x4x4i8 a[0:3], v0, v1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_4x4x4i8 a[0:3], v0, v1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_4x4x4i8 a[0:3], v0, v1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_4x4x4i8 a[0:3], v0, a1, 2 v_mfma_i32_4x4x4i8 a[0:3], v0, a1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_4x4x4i8 a[0:3], v0, a1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_4x4x4i8 a[0:3], v0, a1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_4x4x4i8 a[0:3], a0, v1, 2 v_mfma_i32_4x4x4i8 a[0:3], a0, v1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_4x4x4i8 a[0:3], a0, v1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_4x4x4i8 a[0:3], a0, v1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_4x4x4i8 a[0:3], a0, a1, 2 v_mfma_i32_4x4x4i8 a[0:3], a0, a1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_4x4x4i8 a[0:3], a0, a1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_4x4x4i8 a[0:3], a0, a1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x8i8 a[0:15], v0, v1, 2 v_mfma_i32_32x32x8i8 a[0:15], v0, v1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x8i8 a[0:15], v0, v1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_32x32x8i8 a[0:15], v0, v1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x8i8 a[0:15], v0, a1, 2 v_mfma_i32_32x32x8i8 a[0:15], v0, a1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x8i8 a[0:15], v0, a1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_32x32x8i8 a[0:15], v0, a1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x8i8 a[0:15], a0, v1, 2 v_mfma_i32_32x32x8i8 a[0:15], a0, v1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x8i8 a[0:15], a0, v1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_32x32x8i8 a[0:15], a0, v1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x8i8 a[0:15], a0, a1, 2 v_mfma_i32_32x32x8i8 a[0:15], a0, a1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_32x32x8i8 a[0:15], a0, a1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_32x32x8i8 a[0:15], a0, a1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x16i8 a[0:3], v0, v1, 2 v_mfma_i32_16x16x16i8 a[0:3], v0, v1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x16i8 a[0:3], v0, v1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_16x16x16i8 a[0:3], v0, v1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x16i8 a[0:3], v0, a1, 2 v_mfma_i32_16x16x16i8 a[0:3], v0, a1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x16i8 a[0:3], v0, a1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_16x16x16i8 a[0:3], v0, a1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x16i8 a[0:3], a0, v1, 2 v_mfma_i32_16x16x16i8 a[0:3], a0, v1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x16i8 a[0:3], a0, v1, 2 cbsz:3 abid:2 blgp:7 v_mfma_i32_16x16x16i8 a[0:3], a0, v1, 2 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_i32_16x16x16i8 a[0:3], a0, a1, 2 v_mfma_i32_16x16x16i8 a[0:3], a0, a1, 2
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2bf16 a[0:31], v0, v1, -2.0 v_mfma_f32_32x32x2bf16 a[0:31], v0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2bf16 a[0:31], v0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x2bf16 a[0:31], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2bf16 a[0:31], v0, a1, -2.0 v_mfma_f32_32x32x2bf16 a[0:31], v0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2bf16 a[0:31], v0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x2bf16 a[0:31], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2bf16 a[0:31], a0, v1, -2.0 v_mfma_f32_32x32x2bf16 a[0:31], a0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2bf16 a[0:31], a0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x2bf16 a[0:31], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2bf16 a[0:31], a0, a1, -2.0 v_mfma_f32_32x32x2bf16 a[0:31], a0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x2bf16 a[0:31], a0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x2bf16 a[0:31], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x2bf16 a[0:15], v0, v1, -2.0 v_mfma_f32_16x16x2bf16 a[0:15], v0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x2bf16 a[0:15], v0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x2bf16 a[0:15], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x2bf16 a[0:15], v0, a1, -2.0 v_mfma_f32_16x16x2bf16 a[0:15], v0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x2bf16 a[0:15], v0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x2bf16 a[0:15], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x2bf16 a[0:15], a0, v1, -2.0 v_mfma_f32_16x16x2bf16 a[0:15], a0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x2bf16 a[0:15], a0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x2bf16 a[0:15], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x2bf16 a[0:15], a0, a1, -2.0 v_mfma_f32_16x16x2bf16 a[0:15], a0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x2bf16 a[0:15], a0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x2bf16 a[0:15], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x2bf16 a[0:3], v0, v1, -2.0 v_mfma_f32_4x4x2bf16 a[0:3], v0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x2bf16 a[0:3], v0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_4x4x2bf16 a[0:3], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x2bf16 a[0:3], v0, a1, -2.0 v_mfma_f32_4x4x2bf16 a[0:3], v0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x2bf16 a[0:3], v0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_4x4x2bf16 a[0:3], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x2bf16 a[0:3], a0, v1, -2.0 v_mfma_f32_4x4x2bf16 a[0:3], a0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x2bf16 a[0:3], a0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_4x4x2bf16 a[0:3], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x2bf16 a[0:3], a0, a1, -2.0 v_mfma_f32_4x4x2bf16 a[0:3], a0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_4x4x2bf16 a[0:3], a0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_4x4x2bf16 a[0:3], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4bf16 a[0:15], v0, v1, -2.0 v_mfma_f32_32x32x4bf16 a[0:15], v0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4bf16 a[0:15], v0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x4bf16 a[0:15], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4bf16 a[0:15], v0, a1, -2.0 v_mfma_f32_32x32x4bf16 a[0:15], v0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4bf16 a[0:15], v0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x4bf16 a[0:15], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4bf16 a[0:15], a0, v1, -2.0 v_mfma_f32_32x32x4bf16 a[0:15], a0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4bf16 a[0:15], a0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x4bf16 a[0:15], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4bf16 a[0:15], a0, a1, -2.0 v_mfma_f32_32x32x4bf16 a[0:15], a0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_32x32x4bf16 a[0:15], a0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_32x32x4bf16 a[0:15], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x8bf16 a[0:3], v0, v1, -2.0 v_mfma_f32_16x16x8bf16 a[0:3], v0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x8bf16 a[0:3], v0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x8bf16 a[0:3], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x8bf16 a[0:3], v0, a1, -2.0 v_mfma_f32_16x16x8bf16 a[0:3], v0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x8bf16 a[0:3], v0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x8bf16 a[0:3], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x8bf16 a[0:3], a0, v1, -2.0 v_mfma_f32_16x16x8bf16 a[0:3], a0, v1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x8bf16 a[0:3], a0, v1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x8bf16 a[0:3], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x8bf16 a[0:3], a0, a1, -2.0 v_mfma_f32_16x16x8bf16 a[0:3], a0, a1, -2.0
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU
v_mfma_f32_16x16x8bf16 a[0:3], a0, a1, -2.0 cbsz:3 abid:2 blgp:7 v_mfma_f32_16x16x8bf16 a[0:3], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
// GFX908: error: invalid literal operand // GFX908: error: inline constants are not allowed for this operand
// GFX900: error: instruction not supported on this GPU // GFX900: error: instruction not supported on this GPU

llvm/test/MC/AMDGPU/vop2-err.s

// RUN: not llvm-mc -arch=amdgcn %s 2>&1 | FileCheck --implicit-check-not=error: %s // RUN: not llvm-mc -arch=amdgcn %s 2>&1 | FileCheck --implicit-check-not=error: %s
// RUN: not llvm-mc -arch=amdgcn -mcpu=tahiti %s 2>&1 | FileCheck --implicit-check-not=error: %s // RUN: not llvm-mc -arch=amdgcn -mcpu=tahiti %s 2>&1 | FileCheck --implicit-check-not=error: %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Generic checks // Generic checks
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
v_mul_i32_i24 v1, v2, 100 v_mul_i32_i24 v1, v2, 100
// CHECK: error: invalid literal operand // CHECK: error: literal operands are not supported
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// _e32 checks // _e32 checks
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Immediate src1 // Immediate src1
v_mul_i32_i24_e32 v1, v2, 100 v_mul_i32_i24_e32 v1, v2, 100
// CHECK: error: invalid operand for instruction // CHECK: error: invalid operand for instruction
// sgpr src1 // sgpr src1
v_mul_i32_i24_e32 v1, v2, s3 v_mul_i32_i24_e32 v1, v2, s3
// CHECK: error: invalid operand for instruction // CHECK: error: invalid operand for instruction
v_cndmask_b32_e32 v1, v2, v3, s[0:1] v_cndmask_b32_e32 v1, v2, v3, s[0:1]
// CHECK: error: invalid operand for instruction // CHECK: error: invalid operand for instruction
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// _e64 checks // _e64 checks
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Immediate src0 // Immediate src0
v_mul_i32_i24_e64 v1, 100, v3 v_mul_i32_i24_e64 v1, 100, v3
// CHECK: error: invalid literal operand // CHECK: error: literal operands are not supported
// Immediate src1 // Immediate src1
v_mul_i32_i24_e64 v1, v2, 100 v_mul_i32_i24_e64 v1, v2, 100
// CHECK: error: invalid literal operand // CHECK: error: literal operands are not supported
v_add_i32_e32 v1, s[0:1], v2, v3 v_add_i32_e32 v1, s[0:1], v2, v3
// CHECK: error: invalid operand for instruction // CHECK: error: invalid operand for instruction
v_addc_u32_e32 v1, vcc, v2, v3, s[2:3] v_addc_u32_e32 v1, vcc, v2, v3, s[2:3]
// CHECK: error: invalid operand for instruction // CHECK: error: invalid operand for instruction
v_addc_u32_e32 v1, s[0:1], v2, v3, s[2:3] v_addc_u32_e32 v1, s[0:1], v2, v3, s[2:3]
Show All 21 Lines

llvm/test/MC/AMDGPU/vop3-errs.s

// RUN: not llvm-mc -arch=amdgcn %s 2>&1 | FileCheck %s --check-prefix=GFX67 --check-prefix=GCN --implicit-check-not=error: // RUN: not llvm-mc -arch=amdgcn %s 2>&1 | FileCheck %s --check-prefix=GFX67 --check-prefix=GCN --implicit-check-not=error:
// RUN: not llvm-mc -arch=amdgcn -mcpu=tahiti %s 2>&1 | FileCheck %s --check-prefix=GFX67 --check-prefix=GCN --implicit-check-not=error: // RUN: not llvm-mc -arch=amdgcn -mcpu=tahiti %s 2>&1 | FileCheck %s --check-prefix=GFX67 --check-prefix=GCN --implicit-check-not=error:
// RUN: not llvm-mc -arch=amdgcn -mcpu=fiji %s 2>&1 | FileCheck %s --check-prefix=GFX89 --check-prefix=GCN --implicit-check-not=error: // RUN: not llvm-mc -arch=amdgcn -mcpu=fiji %s 2>&1 | FileCheck %s --check-prefix=GFX89 --check-prefix=GCN --implicit-check-not=error:
// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck %s --check-prefix=GFX89 --check-prefix=GCN --implicit-check-not=error: // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck %s --check-prefix=GFX89 --check-prefix=GCN --implicit-check-not=error:
v_add_f32_e64 v0, v1 v_add_f32_e64 v0, v1
// GCN: error: too few operands for instruction // GCN: error: too few operands for instruction
v_div_scale_f32 v24, vcc, v22, 1.1, v22 v_div_scale_f32 v24, vcc, v22, 1.1, v22
// GCN: error: invalid literal operand // GCN: error: literal operands are not supported
v_mqsad_u32_u8 v[0:3], s[2:3], v4, v[0:3] v_mqsad_u32_u8 v[0:3], s[2:3], v4, v[0:3]
// GFX67: error: instruction not supported on this GPU // GFX67: error: instruction not supported on this GPU
// GFX89: error: destination must be different than all sources // GFX89: error: destination must be different than all sources
v_mqsad_pk_u16_u8 v[0:1], v[1:2], v9, v[4:5] v_mqsad_pk_u16_u8 v[0:1], v[1:2], v9, v[4:5]
// GCN: error: destination must be different than all sources // GCN: error: destination must be different than all sources
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/MC/AMDGPU/vop3-gfx9.s

Show First 20 Lines • Show All 420 Lines • ▼ Show 20 Lines
// VI: v_mad_i16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0xec,0xd1,0x80,0x04,0x0e,0x04] // VI: v_mad_i16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0xec,0xd1,0x80,0x04,0x0e,0x04]
v_mad_i16 v5, v1, -1, v3 v_mad_i16 v5, v1, -1, v3
// GFX9: v_mad_i16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0x05,0xd2,0x01,0x83,0x0d,0x04] // GFX9: v_mad_i16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0x05,0xd2,0x01,0x83,0x0d,0x04]
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
// VI: v_mad_i16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0xec,0xd1,0x01,0x83,0x0d,0x04] // VI: v_mad_i16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0xec,0xd1,0x01,0x83,0x0d,0x04]
v_mad_i16 v5, v1, v2, -4.0 v_mad_i16 v5, v1, v2, -4.0
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
// NOVI: error: invalid literal operand // NOVI: error: literal operands are not supported
v_mad_i16 v5, v1, v2, v3 clamp v_mad_i16 v5, v1, v2, v3 clamp
// GFX9: v_mad_i16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0x05,0xd2,0x01,0x05,0x0e,0x04] // GFX9: v_mad_i16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0x05,0xd2,0x01,0x05,0x0e,0x04]
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
// VI: v_mad_i16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0xec,0xd1,0x01,0x05,0x0e,0x04] // VI: v_mad_i16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0xec,0xd1,0x01,0x05,0x0e,0x04]
v_mad_i16 v5, v1, v2, v3 op_sel:[0,0,0,1] v_mad_i16 v5, v1, v2, v3 op_sel:[0,0,0,1]
// GFX9: v_mad_i16 v5, v1, v2, v3 op_sel:[0,0,0,1] ; encoding: [0x05,0x40,0x05,0xd2,0x01,0x05,0x0e,0x04] // GFX9: v_mad_i16 v5, v1, v2, v3 op_sel:[0,0,0,1] ; encoding: [0x05,0x40,0x05,0xd2,0x01,0x05,0x0e,0x04]
Show All 33 Lines
// GFX9: v_mad_legacy_i16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0xec,0xd1,0x80,0x04,0x0e,0x04] // GFX9: v_mad_legacy_i16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0xec,0xd1,0x80,0x04,0x0e,0x04]
// NOGCN: error: instruction not supported on this GPU // NOGCN: error: instruction not supported on this GPU
v_mad_legacy_i16 v5, v1, -1, v3 v_mad_legacy_i16 v5, v1, -1, v3
// GFX9: v_mad_legacy_i16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0xec,0xd1,0x01,0x83,0x0d,0x04] // GFX9: v_mad_legacy_i16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0xec,0xd1,0x01,0x83,0x0d,0x04]
// NOGCN: error: instruction not supported on this GPU // NOGCN: error: instruction not supported on this GPU
v_mad_legacy_i16 v5, v1, v2, -4.0 v_mad_legacy_i16 v5, v1, v2, -4.0
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// NOGCN: error: instruction not supported on this GPU // NOGCN: error: instruction not supported on this GPU
v_mad_legacy_i16 v5, v1, v2, -4.0 clamp v_mad_legacy_i16 v5, v1, v2, -4.0 clamp
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// NOGCN: error: instruction not supported on this GPU // NOGCN: error: instruction not supported on this GPU
v_mad_legacy_u16_e64 v5, 0, v2, v3 v_mad_legacy_u16_e64 v5, 0, v2, v3
// GFX9: v_mad_legacy_u16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x80,0x04,0x0e,0x04] // GFX9: v_mad_legacy_u16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x80,0x04,0x0e,0x04]
// NOGCN: error: instruction not supported on this GPU // NOGCN: error: instruction not supported on this GPU
v_mad_legacy_u16 v5, v1, -1, v3 v_mad_legacy_u16 v5, v1, -1, v3
// GFX9: v_mad_legacy_u16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x01,0x83,0x0d,0x04] // GFX9: v_mad_legacy_u16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x01,0x83,0x0d,0x04]
// NOGCN: error: instruction not supported on this GPU // NOGCN: error: instruction not supported on this GPU
v_mad_legacy_u16 v5, v1, v2, -4.0 v_mad_legacy_u16 v5, v1, v2, -4.0
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// NOGCN: error: instruction not supported on this GPU // NOGCN: error: instruction not supported on this GPU
v_mad_legacy_u16 v5, v1, v2, -4.0 clamp v_mad_legacy_u16 v5, v1, v2, -4.0 clamp
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// NOGCN: error: instruction not supported on this GPU // NOGCN: error: instruction not supported on this GPU
v_mad_u16_e64 v5, 0, v2, v3 v_mad_u16_e64 v5, 0, v2, v3
// GFX9: v_mad_u16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0x04,0xd2,0x80,0x04,0x0e,0x04] // GFX9: v_mad_u16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0x04,0xd2,0x80,0x04,0x0e,0x04]
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
// VI: v_mad_u16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x80,0x04,0x0e,0x04] // VI: v_mad_u16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x80,0x04,0x0e,0x04]
v_mad_u16 v5, v1, -1, v3 v_mad_u16 v5, v1, -1, v3
// GFX9: v_mad_u16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0x04,0xd2,0x01,0x83,0x0d,0x04] // GFX9: v_mad_u16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0x04,0xd2,0x01,0x83,0x0d,0x04]
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
// VI: v_mad_u16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x01,0x83,0x0d,0x04] // VI: v_mad_u16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x01,0x83,0x0d,0x04]
v_mad_u16 v5, v1, v2, -4.0 v_mad_u16 v5, v1, v2, -4.0
// NOGFX9: error: invalid literal operand // NOGFX9: error: literal operands are not supported
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
// NOVI: error: invalid literal operand // NOVI: error: literal operands are not supported
v_mad_u16 v5, v1, v2, v3 clamp v_mad_u16 v5, v1, v2, v3 clamp
// GFX9: v_mad_u16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0x04,0xd2,0x01,0x05,0x0e,0x04] // GFX9: v_mad_u16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0x04,0xd2,0x01,0x05,0x0e,0x04]
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
// VI: v_mad_u16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0xeb,0xd1,0x01,0x05,0x0e,0x04] // VI: v_mad_u16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0xeb,0xd1,0x01,0x05,0x0e,0x04]
v_mad_u16 v5, v1, v2, v3 op_sel:[1,0,0,0] v_mad_u16 v5, v1, v2, v3 op_sel:[1,0,0,0]
// GFX9: v_mad_u16 v5, v1, v2, v3 op_sel:[1,0,0,0] ; encoding: [0x05,0x08,0x04,0xd2,0x01,0x05,0x0e,0x04] // GFX9: v_mad_u16 v5, v1, v2, v3 op_sel:[1,0,0,0] ; encoding: [0x05,0x08,0x04,0xd2,0x01,0x05,0x0e,0x04]
▲ Show 20 Lines • Show All 276 Lines • Show Last 20 Lines

llvm/test/MC/AMDGPU/vop3-literal.s

// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1010 -mattr=-wavefrontsize32,+wavefrontsize64 -show-encoding %s | FileCheck -check-prefix=GFX10 %s // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1010 -mattr=-wavefrontsize32,+wavefrontsize64 -show-encoding %s | FileCheck -check-prefix=GFX10 %s
// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 -show-encoding %s | FileCheck -check-prefix=GFX9 %s // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 -show-encoding %s | FileCheck -check-prefix=GFX9 %s
// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1010 -mattr=-wavefrontsize32,+wavefrontsize64 %s 2>&1 | FileCheck -check-prefix=GFX10-ERR --implicit-check-not=error: %s // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1010 -mattr=-wavefrontsize32,+wavefrontsize64 %s 2>&1 | FileCheck -check-prefix=GFX10-ERR --implicit-check-not=error: %s
// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck -check-prefix=GFX9-ERR --implicit-check-not=error: %s // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck -check-prefix=GFX9-ERR --implicit-check-not=error: %s
v_bfe_u32 v0, 0x3039, v1, s1 v_bfe_u32 v0, 0x3039, v1, s1
// GFX10: v_bfe_u32 v0, 0x3039, v1, s1 ; encoding: [0x00,0x00,0x48,0xd5,0xff,0x02,0x06,0x00,0x39,0x30,0x00,0x00] // GFX10: v_bfe_u32 v0, 0x3039, v1, s1 ; encoding: [0x00,0x00,0x48,0xd5,0xff,0x02,0x06,0x00,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_bfe_u32 v0, v1, 0x3039, s1 v_bfe_u32 v0, v1, 0x3039, s1
// GFX10: v_bfe_u32 v0, v1, 0x3039, s1 ; encoding: [0x00,0x00,0x48,0xd5,0x01,0xff,0x05,0x00,0x39,0x30,0x00,0x00] // GFX10: v_bfe_u32 v0, v1, 0x3039, s1 ; encoding: [0x00,0x00,0x48,0xd5,0x01,0xff,0x05,0x00,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_bfe_u32 v0, v1, s1, 0x3039 v_bfe_u32 v0, v1, s1, 0x3039
// GFX10: v_bfe_u32 v0, v1, s1, 0x3039 ; encoding: [0x00,0x00,0x48,0xd5,0x01,0x03,0xfc,0x03,0x39,0x30,0x00,0x00] // GFX10: v_bfe_u32 v0, v1, s1, 0x3039 ; encoding: [0x00,0x00,0x48,0xd5,0x01,0x03,0xfc,0x03,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_bfe_u32 v0, 0x3039, 0x3039, s1 v_bfe_u32 v0, 0x3039, 0x3039, s1
// GFX10: v_bfe_u32 v0, 0x3039, 0x3039, s1 ; encoding: [0x00,0x00,0x48,0xd5,0xff,0xfe,0x05,0x00,0x39,0x30,0x00,0x00] // GFX10: v_bfe_u32 v0, 0x3039, 0x3039, s1 ; encoding: [0x00,0x00,0x48,0xd5,0xff,0xfe,0x05,0x00,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_bfe_u32 v0, 0x3039, s1, 0x3039 v_bfe_u32 v0, 0x3039, s1, 0x3039
// GFX10: v_bfe_u32 v0, 0x3039, s1, 0x3039 ; encoding: [0x00,0x00,0x48,0xd5,0xff,0x02,0xfc,0x03,0x39,0x30,0x00,0x00] // GFX10: v_bfe_u32 v0, 0x3039, s1, 0x3039 ; encoding: [0x00,0x00,0x48,0xd5,0xff,0x02,0xfc,0x03,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_bfe_u32 v0, v1, 0x3039, 0x3039 v_bfe_u32 v0, v1, 0x3039, 0x3039
// GFX10: v_bfe_u32 v0, v1, 0x3039, 0x3039 ; encoding: [0x00,0x00,0x48,0xd5,0x01,0xff,0xfd,0x03,0x39,0x30,0x00,0x00] // GFX10: v_bfe_u32 v0, v1, 0x3039, 0x3039 ; encoding: [0x00,0x00,0x48,0xd5,0x01,0xff,0xfd,0x03,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_bfe_u32 v0, 0x3039, 0x3039, 0x3039 v_bfe_u32 v0, 0x3039, 0x3039, 0x3039
// GFX10: v_bfe_u32 v0, 0x3039, 0x3039, 0x3039 ; encoding: [0x00,0x00,0x48,0xd5,0xff,0xfe,0xfd,0x03,0x39,0x30,0x00,0x00] // GFX10: v_bfe_u32 v0, 0x3039, 0x3039, 0x3039 ; encoding: [0x00,0x00,0x48,0xd5,0xff,0xfe,0xfd,0x03,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_bfe_u32 v0, 0x3039, s1, 0x3038 v_bfe_u32 v0, 0x3039, s1, 0x3038
// GFX10-ERR: error: invalid literal operand // GFX10-ERR: error: only one literal operand is allowed
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_bfe_u32 v0, 0x3039, v1, v2 v_bfe_u32 v0, 0x3039, v1, v2
// GFX10: v_bfe_u32 v0, 0x3039, v1, v2 ; encoding: [0x00,0x00,0x48,0xd5,0xff,0x02,0x0a,0x04,0x39,0x30,0x00,0x00] // GFX10: v_bfe_u32 v0, 0x3039, v1, v2 ; encoding: [0x00,0x00,0x48,0xd5,0xff,0x02,0x0a,0x04,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_bfe_u32 v0, 0x3039, 0x12345, v2 v_bfe_u32 v0, 0x3039, 0x12345, v2
// GFX10-ERR: error: invalid literal operand // GFX10-ERR: error: only one literal operand is allowed
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_bfe_u32 v0, s1, 0x3039, s1 v_bfe_u32 v0, s1, 0x3039, s1
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
// GFX10: v_bfe_u32 v0, s1, 0x3039, s1 ; encoding: [0x00,0x00,0x48,0xd5,0x01,0xfe,0x05,0x00,0x39,0x30,0x00,0x00] // GFX10: v_bfe_u32 v0, s1, 0x3039, s1 ; encoding: [0x00,0x00,0x48,0xd5,0x01,0xfe,0x05,0x00,0x39,0x30,0x00,0x00]
v_bfe_u32 v0, s1, 0x3039, s2 v_bfe_u32 v0, s1, 0x3039, s2
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
// GFX10-ERR: error: invalid operand (violates constant bus restrictions) // GFX10-ERR: error: invalid operand (violates constant bus restrictions)
v_bfm_b32_e64 v0, 0x3039, s1 v_bfm_b32_e64 v0, 0x3039, s1
// GFX10: v_bfm_b32_e64 v0, 0x3039, s1 ; encoding: [0x00,0x00,0x63,0xd7,0xff,0x02,0x00,0x00,0x39,0x30,0x00,0x00] // GFX10: v_bfm_b32_e64 v0, 0x3039, s1 ; encoding: [0x00,0x00,0x63,0xd7,0xff,0x02,0x00,0x00,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_bfm_b32_e64 v0, 0x3039, v1 v_bfm_b32_e64 v0, 0x3039, v1
// GFX10: v_bfm_b32_e64 v0, 0x3039, v1 ; encoding: [0x00,0x00,0x63,0xd7,0xff,0x02,0x02,0x00,0x39,0x30,0x00,0x00] // GFX10: v_bfm_b32_e64 v0, 0x3039, v1 ; encoding: [0x00,0x00,0x63,0xd7,0xff,0x02,0x02,0x00,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_bfm_b32_e64 v0, 0x3039, 0x3039 v_bfm_b32_e64 v0, 0x3039, 0x3039
// GFX10: v_bfm_b32_e64 v0, 0x3039, 0x3039 ; encoding: [0x00,0x00,0x63,0xd7,0xff,0xfe,0x01,0x00,0x39,0x30,0x00,0x00] // GFX10: v_bfm_b32_e64 v0, 0x3039, 0x3039 ; encoding: [0x00,0x00,0x63,0xd7,0xff,0xfe,0x01,0x00,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_bfm_b32_e64 v0, 0x3039, 0x3038 v_bfm_b32_e64 v0, 0x3039, 0x3038
// GFX10-ERR: error: invalid literal operand // GFX10-ERR: error: only one literal operand is allowed
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_f16 v1, 25.0, v2 v_pk_add_f16 v1, 25.0, v2
// GFX10: v_pk_add_f16 v1, 0x4e40, v2 ; encoding: [0x01,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x40,0x4e,0x00,0x00] // GFX10: v_pk_add_f16 v1, 0x4e40, v2 ; encoding: [0x01,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x40,0x4e,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_f16 v1, 123456, v2 v_pk_add_f16 v1, 123456, v2
// GFX10: v_pk_add_f16 v1, 0x1e240, v2 ; encoding: [0x01,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x40,0xe2,0x01,0x00] // GFX10: v_pk_add_f16 v1, 0x1e240, v2 ; encoding: [0x01,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x40,0xe2,0x01,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_f16 v1, -200, v2 v_pk_add_f16 v1, -200, v2
// GFX10: v_pk_add_f16 v1, 0xffffff38, v2 ; encoding: [0x01,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x38,0xff,0xff,0xff] // GFX10: v_pk_add_f16 v1, 0xffffff38, v2 ; encoding: [0x01,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x38,0xff,0xff,0xff]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_f16 v1, 25.0, 25.0 v_pk_add_f16 v1, 25.0, 25.0
// GFX10: v_pk_add_f16 v1, 0x4e40, 0x4e40 ; encoding: [0x01,0x00,0x0f,0xcc,0xff,0xfe,0x01,0x18,0x40,0x4e,0x00,0x00] // GFX10: v_pk_add_f16 v1, 0x4e40, 0x4e40 ; encoding: [0x01,0x00,0x0f,0xcc,0xff,0xfe,0x01,0x18,0x40,0x4e,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_f16 v1, 25.0, 25.1 v_pk_add_f16 v1, 25.0, 25.1
// GFX10-ERR: error: invalid literal operand // GFX10-ERR: error: only one literal operand is allowed
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_u16 v1, -200, v2 v_pk_add_u16 v1, -200, v2
// GFX10: v_pk_add_u16 v1, 0xffffff38, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x38,0xff,0xff,0xff] // GFX10: v_pk_add_u16 v1, 0xffffff38, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x38,0xff,0xff,0xff]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_u16 v1, 64, v2 v_pk_add_u16 v1, 64, v2
// GFX10: v_pk_add_u16 v1, 64, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xc0,0x04,0x02,0x18] // GFX10: v_pk_add_u16 v1, 64, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xc0,0x04,0x02,0x18]
// GFX9: v_pk_add_u16 v1, 64, v2 ; encoding: [0x01,0x00,0x8a,0xd3,0xc0,0x04,0x02,0x18] // GFX9: v_pk_add_u16 v1, 64, v2 ; encoding: [0x01,0x00,0x8a,0xd3,0xc0,0x04,0x02,0x18]
v_pk_add_u16 v1, 65, v2 v_pk_add_u16 v1, 65, v2
// GFX10: v_pk_add_u16 v1, 0x41, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x41,0x00,0x00,0x00] // GFX10: v_pk_add_u16 v1, 0x41, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x41,0x00,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_u16 v1, -1, v2 v_pk_add_u16 v1, -1, v2
// GFX10: v_pk_add_u16 v1, -1, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xc1,0x04,0x02,0x18] // GFX10: v_pk_add_u16 v1, -1, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xc1,0x04,0x02,0x18]
// GFX9: v_pk_add_u16 v1, -1, v2 ; encoding: [0x01,0x00,0x8a,0xd3,0xc1,0x04,0x02,0x18] // GFX9: v_pk_add_u16 v1, -1, v2 ; encoding: [0x01,0x00,0x8a,0xd3,0xc1,0x04,0x02,0x18]
v_pk_add_u16 v1, -5, v2 v_pk_add_u16 v1, -5, v2
// GFX10: v_pk_add_u16 v1, -5, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xc5,0x04,0x02,0x18] // GFX10: v_pk_add_u16 v1, -5, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xc5,0x04,0x02,0x18]
// GFX9: v_pk_add_u16 v1, -5, v2 ; encoding: [0x01,0x00,0x8a,0xd3,0xc5,0x04,0x02,0x18] // GFX9: v_pk_add_u16 v1, -5, v2 ; encoding: [0x01,0x00,0x8a,0xd3,0xc5,0x04,0x02,0x18]
v_pk_add_u16 v1, -100, v2 v_pk_add_u16 v1, -100, v2
// GFX10: v_pk_add_u16 v1, 0xffffff9c, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x9c,0xff,0xff,0xff] // GFX10: v_pk_add_u16 v1, 0xffffff9c, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x9c,0xff,0xff,0xff]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_u16 v1, -100, -100 v_pk_add_u16 v1, -100, -100
// GFX10: v_pk_add_u16 v1, 0xffffff9c, 0xffffff9c ; encoding: [0x01,0x00,0x0a,0xcc,0xff,0xfe,0x01,0x18,0x9c,0xff,0xff,0xff] // GFX10: v_pk_add_u16 v1, 0xffffff9c, 0xffffff9c ; encoding: [0x01,0x00,0x0a,0xcc,0xff,0xfe,0x01,0x18,0x9c,0xff,0xff,0xff]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_add_f32_e64 v1, neg(abs(0x123)), v3 v_add_f32_e64 v1, neg(abs(0x123)), v3
// GFX10: v_add_f32_e64 v1, -|0x123|, v3 ; encoding: [0x01,0x01,0x03,0xd5,0xff,0x06,0x02,0x20,0x23,0x01,0x00,0x00] // GFX10: v_add_f32_e64 v1, -|0x123|, v3 ; encoding: [0x01,0x01,0x03,0xd5,0xff,0x06,0x02,0x20,0x23,0x01,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_add_f32_e64 v1, v3, neg(0x123) v_add_f32_e64 v1, v3, neg(0x123)
// GFX10: v_add_f32_e64 v1, v3, neg(0x123) ; encoding: [0x01,0x00,0x03,0xd5,0x03,0xff,0x01,0x40,0x23,0x01,0x00,0x00] // GFX10: v_add_f32_e64 v1, v3, neg(0x123) ; encoding: [0x01,0x00,0x03,0xd5,0x03,0xff,0x01,0x40,0x23,0x01,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_add_f32_e64 v1, neg(abs(0x12345678)), neg(0x12345678) v_add_f32_e64 v1, neg(abs(0x12345678)), neg(0x12345678)
// GFX10: v_add_f32_e64 v1, -|0x12345678|, neg(0x12345678) ; encoding: [0x01,0x01,0x03,0xd5,0xff,0xfe,0x01,0x60,0x78,0x56,0x34,0x12] // GFX10: v_add_f32_e64 v1, -|0x12345678|, neg(0x12345678) ; encoding: [0x01,0x01,0x03,0xd5,0xff,0xfe,0x01,0x60,0x78,0x56,0x34,0x12]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_add_f16_e64 v0, v0, 0xfe0b v_add_f16_e64 v0, v0, 0xfe0b
// GFX10: v_add_f16_e64 v0, v0, 0xfe0b ; encoding: [0x00,0x00,0x32,0xd5,0x00,0xff,0x01,0x00,0x0b,0xfe,0x00,0x00] // GFX10: v_add_f16_e64 v0, v0, 0xfe0b ; encoding: [0x00,0x00,0x32,0xd5,0x00,0xff,0x01,0x00,0x0b,0xfe,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_add_f16_e64 v0, v0, neg(0xfe0b) v_add_f16_e64 v0, v0, neg(0xfe0b)
// GFX10: v_add_f16_e64 v0, v0, neg(0xfe0b) ; encoding: [0x00,0x00,0x32,0xd5,0x00,0xff,0x01,0x40,0x0b,0xfe,0x00,0x00] // GFX10: v_add_f16_e64 v0, v0, neg(0xfe0b) ; encoding: [0x00,0x00,0x32,0xd5,0x00,0xff,0x01,0x40,0x0b,0xfe,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_add_f16_e64 v0, 0x3456, v0 v_add_f16_e64 v0, 0x3456, v0
// GFX10: v_add_f16_e64 v0, 0x3456, v0 ; encoding: [0x00,0x00,0x32,0xd5,0xff,0x00,0x02,0x00,0x56,0x34,0x00,0x00] // GFX10: v_add_f16_e64 v0, 0x3456, v0 ; encoding: [0x00,0x00,0x32,0xd5,0xff,0x00,0x02,0x00,0x56,0x34,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_add_f16_e64 v0, 0xfe0b, neg(0xfe0b) v_add_f16_e64 v0, 0xfe0b, neg(0xfe0b)
// GFX10: v_add_f16_e64 v0, 0xfe0b, neg(0xfe0b) ; encoding: [0x00,0x00,0x32,0xd5,0xff,0xfe,0x01,0x40,0x0b,0xfe,0x00,0x00] // GFX10: v_add_f16_e64 v0, 0xfe0b, neg(0xfe0b) ; encoding: [0x00,0x00,0x32,0xd5,0xff,0xfe,0x01,0x40,0x0b,0xfe,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_add_f64 v[0:1], 1.23456, v[0:1] v_add_f64 v[0:1], 1.23456, v[0:1]
// GFX10: v_add_f64 v[0:1], 0x3ff3c0c1, v[0:1] ; encoding: [0x00,0x00,0x64,0xd5,0xff,0x00,0x02,0x00,0xc1,0xc0,0xf3,0x3f] // GFX10: v_add_f64 v[0:1], 0x3ff3c0c1, v[0:1] ; encoding: [0x00,0x00,0x64,0xd5,0xff,0x00,0x02,0x00,0xc1,0xc0,0xf3,0x3f]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_add_f64 v[0:1], v[0:1], -abs(1.23456) v_add_f64 v[0:1], v[0:1], -abs(1.23456)
// GFX10: v_add_f64 v[0:1], v[0:1], -|0x3ff3c0c1| ; encoding: [0x00,0x02,0x64,0xd5,0x00,0xff,0x01,0x40,0xc1,0xc0,0xf3,0x3f] // GFX10: v_add_f64 v[0:1], v[0:1], -|0x3ff3c0c1| ; encoding: [0x00,0x02,0x64,0xd5,0x00,0xff,0x01,0x40,0xc1,0xc0,0xf3,0x3f]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_add_f64 v[0:1], 1.23456, -abs(1.23456) v_add_f64 v[0:1], 1.23456, -abs(1.23456)
// GFX10: v_add_f64 v[0:1], 0x3ff3c0c1, -|0x3ff3c0c1| ; encoding: [0x00,0x02,0x64,0xd5,0xff,0xfe,0x01,0x40,0xc1,0xc0,0xf3,0x3f] // GFX10: v_add_f64 v[0:1], 0x3ff3c0c1, -|0x3ff3c0c1| ; encoding: [0x00,0x02,0x64,0xd5,0xff,0xfe,0x01,0x40,0xc1,0xc0,0xf3,0x3f]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_add_f64 v[0:1], 1.23456, -abs(1.2345) v_add_f64 v[0:1], 1.23456, -abs(1.2345)
// GFX10-ERR: error: invalid literal operand // GFX10-ERR: error: only one literal operand is allowed
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_max_i16_e64 v5, 0xfe0b, v2 v_max_i16_e64 v5, 0xfe0b, v2
// GFX10: v_max_i16_e64 v5, 0xfe0b, v2 ; encoding: [0x05,0x00,0x0a,0xd7,0xff,0x04,0x02,0x00,0x0b,0xfe,0x00,0x00] // GFX10: v_max_i16_e64 v5, 0xfe0b, v2 ; encoding: [0x05,0x00,0x0a,0xd7,0xff,0x04,0x02,0x00,0x0b,0xfe,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_max_i16_e64 v5, v1, 0x123 v_max_i16_e64 v5, v1, 0x123
// GFX10: v_max_i16_e64 v5, v1, 0x123 ; encoding: [0x05,0x00,0x0a,0xd7,0x01,0xff,0x01,0x00,0x23,0x01,0x00,0x00] // GFX10: v_max_i16_e64 v5, v1, 0x123 ; encoding: [0x05,0x00,0x0a,0xd7,0x01,0xff,0x01,0x00,0x23,0x01,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_max_i16_e64 v5, 0x1234, 0x1234 v_max_i16_e64 v5, 0x1234, 0x1234
// GFX10: v_max_i16_e64 v5, 0x1234, 0x1234 ; encoding: [0x05,0x00,0x0a,0xd7,0xff,0xfe,0x01,0x00,0x34,0x12,0x00,0x00] // GFX10: v_max_i16_e64 v5, 0x1234, 0x1234 ; encoding: [0x05,0x00,0x0a,0xd7,0xff,0xfe,0x01,0x00,0x34,0x12,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_min3_i16 v5, 0xfe0b, v2, v3 v_min3_i16 v5, 0xfe0b, v2, v3
// GFX10: v_min3_i16 v5, 0xfe0b, v2, v3 ; encoding: [0x05,0x00,0x52,0xd7,0xff,0x04,0x0e,0x04,0x0b,0xfe,0x00,0x00] // GFX10: v_min3_i16 v5, 0xfe0b, v2, v3 ; encoding: [0x05,0x00,0x52,0xd7,0xff,0x04,0x0e,0x04,0x0b,0xfe,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_min3_i16 v5, v1, 0x1234, v3 v_min3_i16 v5, v1, 0x1234, v3
// GFX10: v_min3_i16 v5, v1, 0x1234, v3 ; encoding: [0x05,0x00,0x52,0xd7,0x01,0xff,0x0d,0x04,0x34,0x12,0x00,0x00] // GFX10: v_min3_i16 v5, v1, 0x1234, v3 ; encoding: [0x05,0x00,0x52,0xd7,0x01,0xff,0x0d,0x04,0x34,0x12,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_min3_i16 v5, v1, v2, 0x5678 v_min3_i16 v5, v1, v2, 0x5678
// GFX10: v_min3_i16 v5, v1, v2, 0x5678 ; encoding: [0x05,0x00,0x52,0xd7,0x01,0x05,0xfe,0x03,0x78,0x56,0x00,0x00] // GFX10: v_min3_i16 v5, v1, v2, 0x5678 ; encoding: [0x05,0x00,0x52,0xd7,0x01,0x05,0xfe,0x03,0x78,0x56,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_min3_i16 v5, 0x5678, 0x5678, 0x5678 v_min3_i16 v5, 0x5678, 0x5678, 0x5678
// GFX10: v_min3_i16 v5, 0x5678, 0x5678, 0x5678 ; encoding: [0x05,0x00,0x52,0xd7,0xff,0xfe,0xfd,0x03,0x78,0x56,0x00,0x00] // GFX10: v_min3_i16 v5, 0x5678, 0x5678, 0x5678 ; encoding: [0x05,0x00,0x52,0xd7,0xff,0xfe,0xfd,0x03,0x78,0x56,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_min3_i16 v5, 0x5678, 0x5679, 0x5678 v_min3_i16 v5, 0x5678, 0x5679, 0x5678
// GFX10-ERR: error: invalid literal operand // GFX10-ERR: error: only one literal operand is allowed
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_min3_i16 v5, 0x5678, 0x5678, 0x5679 v_min3_i16 v5, 0x5678, 0x5678, 0x5679
// GFX10-ERR: error: invalid literal operand // GFX10-ERR: error: only one literal operand is allowed
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_add_nc_u16 v5, 0xfe0b, v2 v_add_nc_u16 v5, 0xfe0b, v2
// GFX10: v_add_nc_u16_e64 v5, 0xfe0b, v2 ; encoding: [0x05,0x00,0x03,0xd7,0xff,0x04,0x02,0x00,0x0b,0xfe,0x00,0x00] // GFX10: v_add_nc_u16_e64 v5, 0xfe0b, v2 ; encoding: [0x05,0x00,0x03,0xd7,0xff,0x04,0x02,0x00,0x0b,0xfe,0x00,0x00]
// GFX9-ERR: error: instruction not supported on this GPU // GFX9-ERR: error: instruction not supported on this GPU
v_add_nc_u16 v5, v1, 0x1234 v_add_nc_u16 v5, v1, 0x1234
// GFX10: v_add_nc_u16_e64 v5, v1, 0x1234 ; encoding: [0x05,0x00,0x03,0xd7,0x01,0xff,0x01,0x00,0x34,0x12,0x00,0x00] // GFX10: v_add_nc_u16_e64 v5, v1, 0x1234 ; encoding: [0x05,0x00,0x03,0xd7,0x01,0xff,0x01,0x00,0x34,0x12,0x00,0x00]
// GFX9-ERR: error: instruction not supported on this GPU // GFX9-ERR: error: instruction not supported on this GPU
v_add_nc_u16 v5, 0x1234, 0x1234 v_add_nc_u16 v5, 0x1234, 0x1234
// GFX10: v_add_nc_u16_e64 v5, 0x1234, 0x1234 ; encoding: [0x05,0x00,0x03,0xd7,0xff,0xfe,0x01,0x00,0x34,0x12,0x00,0x00] // GFX10: v_add_nc_u16_e64 v5, 0x1234, 0x1234 ; encoding: [0x05,0x00,0x03,0xd7,0xff,0xfe,0x01,0x00,0x34,0x12,0x00,0x00]
// GFX9-ERR: error: instruction not supported on this GPU // GFX9-ERR: error: instruction not supported on this GPU
v_ashrrev_i16_e64 v5, 0x3456, v2 v_ashrrev_i16_e64 v5, 0x3456, v2
// GFX10: v_ashrrev_i16_e64 v5, 0x3456, v2 ; encoding: [0x05,0x00,0x08,0xd7,0xff,0x04,0x02,0x00,0x56,0x34,0x00,0x00] // GFX10: v_ashrrev_i16_e64 v5, 0x3456, v2 ; encoding: [0x05,0x00,0x08,0xd7,0xff,0x04,0x02,0x00,0x56,0x34,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_mad_u16 v5, 0xfe0b, v2, v3 v_mad_u16 v5, 0xfe0b, v2, v3
// GFX10: v_mad_u16 v5, 0xfe0b, v2, v3 ; encoding: [0x05,0x00,0x40,0xd7,0xff,0x04,0x0e,0x04,0x0b,0xfe,0x00,0x00] // GFX10: v_mad_u16 v5, 0xfe0b, v2, v3 ; encoding: [0x05,0x00,0x40,0xd7,0xff,0x04,0x0e,0x04,0x0b,0xfe,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_mad_u16 v5, v1, 0x1234, v3 v_mad_u16 v5, v1, 0x1234, v3
// GFX10: v_mad_u16 v5, v1, 0x1234, v3 ; encoding: [0x05,0x00,0x40,0xd7,0x01,0xff,0x0d,0x04,0x34,0x12,0x00,0x00] // GFX10: v_mad_u16 v5, v1, 0x1234, v3 ; encoding: [0x05,0x00,0x40,0xd7,0x01,0xff,0x0d,0x04,0x34,0x12,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_mad_u16 v5, v1, v2, 0x5678 v_mad_u16 v5, v1, v2, 0x5678
// GFX10: v_mad_u16 v5, v1, v2, 0x5678 ; encoding: [0x05,0x00,0x40,0xd7,0x01,0x05,0xfe,0x03,0x78,0x56,0x00,0x00] // GFX10: v_mad_u16 v5, v1, v2, 0x5678 ; encoding: [0x05,0x00,0x40,0xd7,0x01,0x05,0xfe,0x03,0x78,0x56,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_mad_u16 v5, 0x5678, 0x5678, 0x5678 v_mad_u16 v5, 0x5678, 0x5678, 0x5678
// GFX10: v_mad_u16 v5, 0x5678, 0x5678, 0x5678 ; encoding: [0x05,0x00,0x40,0xd7,0xff,0xfe,0xfd,0x03,0x78,0x56,0x00,0x00] // GFX10: v_mad_u16 v5, 0x5678, 0x5678, 0x5678 ; encoding: [0x05,0x00,0x40,0xd7,0xff,0xfe,0xfd,0x03,0x78,0x56,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_mad_legacy_f32 v5, 0xaf123456, v2, v3 v_mad_legacy_f32 v5, 0xaf123456, v2, v3
// GFX10: v_mad_legacy_f32 v5, 0xaf123456, v2, v3 ; encoding: [0x05,0x00,0x40,0xd5,0xff,0x04,0x0e,0x04,0x56,0x34,0x12,0xaf] // GFX10: v_mad_legacy_f32 v5, 0xaf123456, v2, v3 ; encoding: [0x05,0x00,0x40,0xd5,0xff,0x04,0x0e,0x04,0x56,0x34,0x12,0xaf]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_mad_legacy_f32 v5, v1, 0xaf123456, v3 v_mad_legacy_f32 v5, v1, 0xaf123456, v3
// GFX10: v_mad_legacy_f32 v5, v1, 0xaf123456, v3 ; encoding: [0x05,0x00,0x40,0xd5,0x01,0xff,0x0d,0x04,0x56,0x34,0x12,0xaf] // GFX10: v_mad_legacy_f32 v5, v1, 0xaf123456, v3 ; encoding: [0x05,0x00,0x40,0xd5,0x01,0xff,0x0d,0x04,0x56,0x34,0x12,0xaf]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_mad_legacy_f32 v5, v1, v2, 0xaf123456 v_mad_legacy_f32 v5, v1, v2, 0xaf123456
// GFX10: v_mad_legacy_f32 v5, v1, v2, 0xaf123456 ; encoding: [0x05,0x00,0x40,0xd5,0x01,0x05,0xfe,0x03,0x56,0x34,0x12,0xaf] // GFX10: v_mad_legacy_f32 v5, v1, v2, 0xaf123456 ; encoding: [0x05,0x00,0x40,0xd5,0x01,0x05,0xfe,0x03,0x56,0x34,0x12,0xaf]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_mad_legacy_f32 v5, 0xaf123456, 0xaf123456, 0xaf123456 v_mad_legacy_f32 v5, 0xaf123456, 0xaf123456, 0xaf123456
// GFX10: v_mad_legacy_f32 v5, 0xaf123456, 0xaf123456, 0xaf123456 ; encoding: [0x05,0x00,0x40,0xd5,0xff,0xfe,0xfd,0x03,0x56,0x34,0x12,0xaf] // GFX10: v_mad_legacy_f32 v5, 0xaf123456, 0xaf123456, 0xaf123456 ; encoding: [0x05,0x00,0x40,0xd5,0xff,0xfe,0xfd,0x03,0x56,0x34,0x12,0xaf]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_cmp_f_i32_e64 s[10:11], 0xaf123456, v2 v_cmp_f_i32_e64 s[10:11], 0xaf123456, v2
// GFX10: v_cmp_f_i32_e64 s[10:11], 0xaf123456, v2 ; encoding: [0x0a,0x00,0x80,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x12,0xaf] // GFX10: v_cmp_f_i32_e64 s[10:11], 0xaf123456, v2 ; encoding: [0x0a,0x00,0x80,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x12,0xaf]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_cmp_f_i32_e64 s[10:11], v1, 0xaf123456 v_cmp_f_i32_e64 s[10:11], v1, 0xaf123456
// GFX10: v_cmp_f_i32_e64 s[10:11], v1, 0xaf123456 ; encoding: [0x0a,0x00,0x80,0xd4,0x01,0xff,0x01,0x00,0x56,0x34,0x12,0xaf] // GFX10: v_cmp_f_i32_e64 s[10:11], v1, 0xaf123456 ; encoding: [0x0a,0x00,0x80,0xd4,0x01,0xff,0x01,0x00,0x56,0x34,0x12,0xaf]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_cmp_f_i32_e64 s[10:11], 0xaf123456, 0xaf123456 v_cmp_f_i32_e64 s[10:11], 0xaf123456, 0xaf123456
// GFX10: v_cmp_f_i32_e64 s[10:11], 0xaf123456, 0xaf123456 ; encoding: [0x0a,0x00,0x80,0xd4,0xff,0xfe,0x01,0x00,0x56,0x34,0x12,0xaf] // GFX10: v_cmp_f_i32_e64 s[10:11], 0xaf123456, 0xaf123456 ; encoding: [0x0a,0x00,0x80,0xd4,0xff,0xfe,0x01,0x00,0x56,0x34,0x12,0xaf]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_cmp_f_i32_e64 s[10:11], 0xaf123456, 0xaf123455 v_cmp_f_i32_e64 s[10:11], 0xaf123456, 0xaf123455
// GFX10-ERR: error: invalid literal operand // GFX10-ERR: error: only one literal operand is allowed
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_cmp_f_u64_e64 s[10:11], 0xaf123456, v[2:3] v_cmp_f_u64_e64 s[10:11], 0xaf123456, v[2:3]
// GFX10: v_cmp_f_u64_e64 s[10:11], 0xaf123456, v[2:3] ; encoding: [0x0a,0x00,0xe0,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x12,0xaf] // GFX10: v_cmp_f_u64_e64 s[10:11], 0xaf123456, v[2:3] ; encoding: [0x0a,0x00,0xe0,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x12,0xaf]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_cmp_f_u64_e64 s[10:11], v[1:2], 0x3f717273 v_cmp_f_u64_e64 s[10:11], v[1:2], 0x3f717273
// GFX10: v_cmp_f_u64_e64 s[10:11], v[1:2], 0x3f717273 ; encoding: [0x0a,0x00,0xe0,0xd4,0x01,0xff,0x01,0x00,0x73,0x72,0x71,0x3f] // GFX10: v_cmp_f_u64_e64 s[10:11], v[1:2], 0x3f717273 ; encoding: [0x0a,0x00,0xe0,0xd4,0x01,0xff,0x01,0x00,0x73,0x72,0x71,0x3f]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_cmp_f_u64_e64 s[10:11], 0x3f717273, 0x3f717273 v_cmp_f_u64_e64 s[10:11], 0x3f717273, 0x3f717273
// GFX10: v_cmp_f_u64_e64 s[10:11], 0x3f717273, 0x3f717273 ; encoding: [0x0a,0x00,0xe0,0xd4,0xff,0xfe,0x01,0x00,0x73,0x72,0x71,0x3f] // GFX10: v_cmp_f_u64_e64 s[10:11], 0x3f717273, 0x3f717273 ; encoding: [0x0a,0x00,0xe0,0xd4,0xff,0xfe,0x01,0x00,0x73,0x72,0x71,0x3f]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_cmpx_class_f32_e64 0xaf123456, v2 v_cmpx_class_f32_e64 0xaf123456, v2
// GFX10: v_cmpx_class_f32_e64 0xaf123456, v2 ; encoding: [0x00,0x00,0x98,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x12,0xaf] // GFX10: v_cmpx_class_f32_e64 0xaf123456, v2 ; encoding: [0x00,0x00,0x98,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x12,0xaf]
// GFX9-ERR: error: operands are not valid for this GPU or mode // GFX9-ERR: error: operands are not valid for this GPU or mode
v_cmpx_class_f32_e64 v1, 0xaf123456 v_cmpx_class_f32_e64 v1, 0xaf123456
// GFX10: v_cmpx_class_f32_e64 v1, 0xaf123456 ; encoding: [0x00,0x00,0x98,0xd4,0x01,0xff,0x01,0x00,0x56,0x34,0x12,0xaf] // GFX10: v_cmpx_class_f32_e64 v1, 0xaf123456 ; encoding: [0x00,0x00,0x98,0xd4,0x01,0xff,0x01,0x00,0x56,0x34,0x12,0xaf]
// GFX9-ERR: error: operands are not valid for this GPU or mode // GFX9-ERR: error: operands are not valid for this GPU or mode
v_cmpx_class_f32_e64 0xaf123456, 0xaf123456 v_cmpx_class_f32_e64 0xaf123456, 0xaf123456
// GFX10: v_cmpx_class_f32_e64 0xaf123456, 0xaf123456 ; encoding: [0x00,0x00,0x98,0xd4,0xff,0xfe,0x01,0x00,0x56,0x34,0x12,0xaf] // GFX10: v_cmpx_class_f32_e64 0xaf123456, 0xaf123456 ; encoding: [0x00,0x00,0x98,0xd4,0xff,0xfe,0x01,0x00,0x56,0x34,0x12,0xaf]
// GFX9-ERR: error: operands are not valid for this GPU or mode // GFX9-ERR: error: operands are not valid for this GPU or mode
v_cmpx_class_f32_e64 0xaf123456, 0xaf123455 v_cmpx_class_f32_e64 0xaf123456, 0xaf123455
// GFX10-ERR: error: invalid literal operand // GFX10-ERR: error: only one literal operand is allowed
// GFX9-ERR: error: operands are not valid for this GPU or mode // GFX9-ERR: error: operands are not valid for this GPU or mode
v_cmpx_lt_i16_e64 v1, 0x3456 v_cmpx_lt_i16_e64 v1, 0x3456
// GFX10: v_cmpx_lt_i16_e64 v1, 0x3456 ; encoding: [0x00,0x00,0x99,0xd4,0x01,0xff,0x01,0x00,0x56,0x34,0x00,0x00] // GFX10: v_cmpx_lt_i16_e64 v1, 0x3456 ; encoding: [0x00,0x00,0x99,0xd4,0x01,0xff,0x01,0x00,0x56,0x34,0x00,0x00]
// GFX9-ERR: error: operands are not valid for this GPU or mode // GFX9-ERR: error: operands are not valid for this GPU or mode
v_cmpx_lt_i16_e64 0x3456, v2 v_cmpx_lt_i16_e64 0x3456, v2
// GFX10: v_cmpx_lt_i16_e64 0x3456, v2 ; encoding: [0x00,0x00,0x99,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x00,0x00] // GFX10: v_cmpx_lt_i16_e64 0x3456, v2 ; encoding: [0x00,0x00,0x99,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x00,0x00]
Show All 12 Lines
// GFX9-ERR: error: operands are not valid for this GPU or mode // GFX9-ERR: error: operands are not valid for this GPU or mode
v_cmpx_f_i64_e64 0x3f717273, 0x3f717273 v_cmpx_f_i64_e64 0x3f717273, 0x3f717273
// GFX10: v_cmpx_f_i64_e64 0x3f717273, 0x3f717273 ; encoding: [0x00,0x00,0xb0,0xd4,0xff,0xfe,0x01,0x00,0x73,0x72,0x71,0x3f] // GFX10: v_cmpx_f_i64_e64 0x3f717273, 0x3f717273 ; encoding: [0x00,0x00,0xb0,0xd4,0xff,0xfe,0x01,0x00,0x73,0x72,0x71,0x3f]
// GFX9-ERR: error: operands are not valid for this GPU or mode // GFX9-ERR: error: operands are not valid for this GPU or mode
v_lshlrev_b64 v[5:6], 0xaf123456, v[2:3] v_lshlrev_b64 v[5:6], 0xaf123456, v[2:3]
// GFX10: v_lshlrev_b64 v[5:6], 0xaf123456, v[2:3] ; encoding: [0x05,0x00,0xff,0xd6,0xff,0x04,0x02,0x00,0x56,0x34,0x12,0xaf] // GFX10: v_lshlrev_b64 v[5:6], 0xaf123456, v[2:3] ; encoding: [0x05,0x00,0xff,0xd6,0xff,0x04,0x02,0x00,0x56,0x34,0x12,0xaf]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_lshlrev_b64 v[5:6], v1, 0x3f717273 v_lshlrev_b64 v[5:6], v1, 0x3f717273
// GFX10: v_lshlrev_b64 v[5:6], v1, 0x3f717273 ; encoding: [0x05,0x00,0xff,0xd6,0x01,0xff,0x01,0x00,0x73,0x72,0x71,0x3f] // GFX10: v_lshlrev_b64 v[5:6], v1, 0x3f717273 ; encoding: [0x05,0x00,0xff,0xd6,0x01,0xff,0x01,0x00,0x73,0x72,0x71,0x3f]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_fma_mix_f32 v5, 0x123, v2, v3 v_fma_mix_f32 v5, 0x123, v2, v3
// GFX10: v_fma_mix_f32 v5, 0x123, v2, v3 ; encoding: [0x05,0x00,0x20,0xcc,0xff,0x04,0x0e,0x04,0x23,0x01,0x00,0x00] // GFX10: v_fma_mix_f32 v5, 0x123, v2, v3 ; encoding: [0x05,0x00,0x20,0xcc,0xff,0x04,0x0e,0x04,0x23,0x01,0x00,0x00]
// GFX9-ERR: error: instruction not supported on this GPU // GFX9-ERR: error: instruction not supported on this GPU
v_fma_mix_f32 v5, v1, 0x7b, v3 v_fma_mix_f32 v5, v1, 0x7b, v3
// GFX10: v_fma_mix_f32 v5, v1, 0x7b, v3 ; encoding: [0x05,0x00,0x20,0xcc,0x01,0xff,0x0d,0x04,0x7b,0x00,0x00,0x00] // GFX10: v_fma_mix_f32 v5, v1, 0x7b, v3 ; encoding: [0x05,0x00,0x20,0xcc,0x01,0xff,0x0d,0x04,0x7b,0x00,0x00,0x00]
// GFX9-ERR: error: instruction not supported on this GPU // GFX9-ERR: error: instruction not supported on this GPU
v_fma_mix_f32 v5, v1, v2, 0x1c8 v_fma_mix_f32 v5, v1, v2, 0x1c8
// GFX10: v_fma_mix_f32 v5, v1, v2, 0x1c8 ; encoding: [0x05,0x00,0x20,0xcc,0x01,0x05,0xfe,0x03,0xc8,0x01,0x00,0x00] // GFX10: v_fma_mix_f32 v5, v1, v2, 0x1c8 ; encoding: [0x05,0x00,0x20,0xcc,0x01,0x05,0xfe,0x03,0xc8,0x01,0x00,0x00]
// GFX9-ERR: error: instruction not supported on this GPU // GFX9-ERR: error: instruction not supported on this GPU
v_fma_mix_f32 v5, 0x1c8a, v2, 0x1c8a v_fma_mix_f32 v5, 0x1c8a, v2, 0x1c8a
// GFX10: v_fma_mix_f32 v5, 0x1c8a, v2, 0x1c8a ; encoding: [0x05,0x00,0x20,0xcc,0xff,0x04,0xfe,0x03,0x8a,0x1c,0x00,0x00] // GFX10: v_fma_mix_f32 v5, 0x1c8a, v2, 0x1c8a ; encoding: [0x05,0x00,0x20,0xcc,0xff,0x04,0xfe,0x03,0x8a,0x1c,0x00,0x00]
// GFX9-ERR: error: instruction not supported on this GPU // GFX9-ERR: error: instruction not supported on this GPU
v_fma_mix_f32 v5, 0x1c8a, 0x1c8a, 0x1c8a v_fma_mix_f32 v5, 0x1c8a, 0x1c8a, 0x1c8a
// GFX10: v_fma_mix_f32 v5, 0x1c8a, 0x1c8a, 0x1c8a ; encoding: [0x05,0x00,0x20,0xcc,0xff,0xfe,0xfd,0x03,0x8a,0x1c,0x00,0x00] // GFX10: v_fma_mix_f32 v5, 0x1c8a, 0x1c8a, 0x1c8a ; encoding: [0x05,0x00,0x20,0xcc,0xff,0xfe,0xfd,0x03,0x8a,0x1c,0x00,0x00]
// GFX9-ERR: error: instruction not supported on this GPU // GFX9-ERR: error: instruction not supported on this GPU
v_pk_add_f16 v5, 0xaf123456, v2 v_pk_add_f16 v5, 0xaf123456, v2
// GFX10: v_pk_add_f16 v5, 0xaf123456, v2 ; encoding: [0x05,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x56,0x34,0x12,0xaf] // GFX10: v_pk_add_f16 v5, 0xaf123456, v2 ; encoding: [0x05,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x56,0x34,0x12,0xaf]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_f16 v5, v1, 0x3f717273 v_pk_add_f16 v5, v1, 0x3f717273
// GFX10: v_pk_add_f16 v5, v1, 0x3f717273 ; encoding: [0x05,0x00,0x0f,0xcc,0x01,0xff,0x01,0x18,0x73,0x72,0x71,0x3f] // GFX10: v_pk_add_f16 v5, v1, 0x3f717273 ; encoding: [0x05,0x00,0x0f,0xcc,0x01,0xff,0x01,0x18,0x73,0x72,0x71,0x3f]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_f16 v5, 0x3f717273, 0x3f717273 v_pk_add_f16 v5, 0x3f717273, 0x3f717273
// GFX10: v_pk_add_f16 v5, 0x3f717273, 0x3f717273 ; encoding: [0x05,0x00,0x0f,0xcc,0xff,0xfe,0x01,0x18,0x73,0x72,0x71,0x3f] // GFX10: v_pk_add_f16 v5, 0x3f717273, 0x3f717273 ; encoding: [0x05,0x00,0x0f,0xcc,0xff,0xfe,0x01,0x18,0x73,0x72,0x71,0x3f]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_i16 v5, 0x7b, v2 v_pk_add_i16 v5, 0x7b, v2
// GFX10: v_pk_add_i16 v5, 0x7b, v2 ; encoding: [0x05,0x00,0x02,0xcc,0xff,0x04,0x02,0x18,0x7b,0x00,0x00,0x00] // GFX10: v_pk_add_i16 v5, 0x7b, v2 ; encoding: [0x05,0x00,0x02,0xcc,0xff,0x04,0x02,0x18,0x7b,0x00,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_i16 v5, v1, 0x7b v_pk_add_i16 v5, v1, 0x7b
// GFX10: v_pk_add_i16 v5, v1, 0x7b ; encoding: [0x05,0x00,0x02,0xcc,0x01,0xff,0x01,0x18,0x7b,0x00,0x00,0x00] // GFX10: v_pk_add_i16 v5, v1, 0x7b ; encoding: [0x05,0x00,0x02,0xcc,0x01,0xff,0x01,0x18,0x7b,0x00,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_i16 v5, 0xab7b, 0xab7b v_pk_add_i16 v5, 0xab7b, 0xab7b
// GFX10: v_pk_add_i16 v5, 0xab7b, 0xab7b ; encoding: [0x05,0x00,0x02,0xcc,0xff,0xfe,0x01,0x18,0x7b,0xab,0x00,0x00] // GFX10: v_pk_add_i16 v5, 0xab7b, 0xab7b ; encoding: [0x05,0x00,0x02,0xcc,0xff,0xfe,0x01,0x18,0x7b,0xab,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_pk_add_i16 v5, 0xab7b, 0xab7a v_pk_add_i16 v5, 0xab7b, 0xab7a
// GFX10-ERR: error: invalid literal operand // GFX10-ERR: error: only one literal operand is allowed
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_div_fmas_f32 v5, v1, 0x123, v3 v_div_fmas_f32 v5, v1, 0x123, v3
// GFX10: v_div_fmas_f32 v5, v1, 0x123, v3 ; encoding: [0x05,0x00,0x6f,0xd5,0x01,0xff,0x0d,0x04,0x23,0x01,0x00,0x00] // GFX10: v_div_fmas_f32 v5, v1, 0x123, v3 ; encoding: [0x05,0x00,0x6f,0xd5,0x01,0xff,0x0d,0x04,0x23,0x01,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_div_fmas_f32 v5, v1, 0x123, 0x123 v_div_fmas_f32 v5, v1, 0x123, 0x123
// GFX10: v_div_fmas_f32 v5, v1, 0x123, 0x123 ; encoding: [0x05,0x00,0x6f,0xd5,0x01,0xff,0xfd,0x03,0x23,0x01,0x00,0x00] // GFX10: v_div_fmas_f32 v5, v1, 0x123, 0x123 ; encoding: [0x05,0x00,0x6f,0xd5,0x01,0xff,0xfd,0x03,0x23,0x01,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_div_fmas_f32 v5, 0x123, 0x123, 0x123 v_div_fmas_f32 v5, 0x123, 0x123, 0x123
// GFX10: v_div_fmas_f32 v5, 0x123, 0x123, 0x123 ; encoding: [0x05,0x00,0x6f,0xd5,0xff,0xfe,0xfd,0x03,0x23,0x01,0x00,0x00] // GFX10: v_div_fmas_f32 v5, 0x123, 0x123, 0x123 ; encoding: [0x05,0x00,0x6f,0xd5,0xff,0xfe,0xfd,0x03,0x23,0x01,0x00,0x00]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_div_fmas_f64 v[5:6], 0x12345678, v[2:3], v[3:4] v_div_fmas_f64 v[5:6], 0x12345678, v[2:3], v[3:4]
// GFX10: v_div_fmas_f64 v[5:6], 0x12345678, v[2:3], v[3:4] ; encoding: [0x05,0x00,0x70,0xd5,0xff,0x04,0x0e,0x04,0x78,0x56,0x34,0x12] // GFX10: v_div_fmas_f64 v[5:6], 0x12345678, v[2:3], v[3:4] ; encoding: [0x05,0x00,0x70,0xd5,0xff,0x04,0x0e,0x04,0x78,0x56,0x34,0x12]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_div_fmas_f64 v[5:6], 0x12345678, 0x12345678, 0x12345678 v_div_fmas_f64 v[5:6], 0x12345678, 0x12345678, 0x12345678
// GFX10: v_div_fmas_f64 v[5:6], 0x12345678, 0x12345678, 0x12345678 ; encoding: [0x05,0x00,0x70,0xd5,0xff,0xfe,0xfd,0x03,0x78,0x56,0x34,0x12] // GFX10: v_div_fmas_f64 v[5:6], 0x12345678, 0x12345678, 0x12345678 ; encoding: [0x05,0x00,0x70,0xd5,0xff,0xfe,0xfd,0x03,0x78,0x56,0x34,0x12]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_div_fmas_f64 v[5:6], v[1:2], 0x123457, 0x123456 v_div_fmas_f64 v[5:6], v[1:2], 0x123457, 0x123456
// GFX10-ERR: error: invalid literal operand // GFX10-ERR: error: only one literal operand is allowed
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_ldexp_f64 v[5:6], 0.12345, v2 v_ldexp_f64 v[5:6], 0.12345, v2
// GFX10: v_ldexp_f64 v[5:6], 0x3fbf9a6b, v2 ; encoding: [0x05,0x00,0x68,0xd5,0xff,0x04,0x02,0x00,0x6b,0x9a,0xbf,0x3f] // GFX10: v_ldexp_f64 v[5:6], 0x3fbf9a6b, v2 ; encoding: [0x05,0x00,0x68,0xd5,0xff,0x04,0x02,0x00,0x6b,0x9a,0xbf,0x3f]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_ldexp_f64 v[5:6], 0.12345, 0x3fbf9a6b v_ldexp_f64 v[5:6], 0.12345, 0x3fbf9a6b
// GFX10: v_ldexp_f64 v[5:6], 0x3fbf9a6b, 0x3fbf9a6b ; encoding: [0x05,0x00,0x68,0xd5,0xff,0xfe,0x01,0x00,0x6b,0x9a,0xbf,0x3f] // GFX10: v_ldexp_f64 v[5:6], 0x3fbf9a6b, 0x3fbf9a6b ; encoding: [0x05,0x00,0x68,0xd5,0xff,0xfe,0x01,0x00,0x6b,0x9a,0xbf,0x3f]
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported
v_ldexp_f64 v[5:6], 0.12345, 0x3fbf9a6c v_ldexp_f64 v[5:6], 0.12345, 0x3fbf9a6c
// GFX10-ERR: error: invalid literal operand // GFX10-ERR: error: only one literal operand is allowed
// GFX9-ERR: error: invalid literal operand // GFX9-ERR: error: literal operands are not supported

llvm/test/MC/AMDGPU/vop3.s

Show First 20 Lines • Show All 593 Lines • ▼ Show 20 Lines
// VI: v_mad_f16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0xea,0xd1,0x01,0x05,0x0e,0x04] // VI: v_mad_f16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0xea,0xd1,0x01,0x05,0x0e,0x04]
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
v_mad_i16_e64 v5, -1, v2, v3 v_mad_i16_e64 v5, -1, v2, v3
// VI: v_mad_i16 v5, -1, v2, v3 ; encoding: [0x05,0x00,0xec,0xd1,0xc1,0x04,0x0e,0x04] // VI: v_mad_i16 v5, -1, v2, v3 ; encoding: [0x05,0x00,0xec,0xd1,0xc1,0x04,0x0e,0x04]
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
v_mad_i16 v5, v1, -4.0, v3 v_mad_i16 v5, v1, -4.0, v3
// NOVI: error: invalid literal operand // NOVI: error: literal operands are not supported
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
v_mad_i16 v5, v1, v2, 0 v_mad_i16 v5, v1, v2, 0
// VI: v_mad_i16 v5, v1, v2, 0 ; encoding: [0x05,0x00,0xec,0xd1,0x01,0x05,0x02,0x02] // VI: v_mad_i16 v5, v1, v2, 0 ; encoding: [0x05,0x00,0xec,0xd1,0x01,0x05,0x02,0x02]
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
v_mad_u16_e64 v5, -1, v2, v3 v_mad_u16_e64 v5, -1, v2, v3
// VI: v_mad_u16 v5, -1, v2, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0xc1,0x04,0x0e,0x04] // VI: v_mad_u16 v5, -1, v2, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0xc1,0x04,0x0e,0x04]
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
v_mad_u16 v5, v1, 0, v3 v_mad_u16 v5, v1, 0, v3
// VI: v_mad_u16 v5, v1, 0, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x01,0x01,0x0d,0x04] // VI: v_mad_u16 v5, v1, 0, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x01,0x01,0x0d,0x04]
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
v_mad_u16 v5, v1, v2, -4.0 v_mad_u16 v5, v1, v2, -4.0
// NOVI: error: invalid literal operand // NOVI: error: literal operands are not supported
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
///===---------------------------------------------------------------------===// ///===---------------------------------------------------------------------===//
// VOP3 with Integer Clamp // VOP3 with Integer Clamp
///===---------------------------------------------------------------------===// ///===---------------------------------------------------------------------===//
v_mad_i32_i24 v5, v1, v2, v3 clamp v_mad_i32_i24 v5, v1, v2, v3 clamp
// NOSICI: error: integer clamping is not supported on this GPU // NOSICI: error: integer clamping is not supported on this GPU
▲ Show 20 Lines • Show All 252 Lines • Show Last 20 Lines