This is an archive of the discontinued LLVM Phabricator instance.

Differential D134028

[AMDGPU][MC][NFC] Correct error message
ClosedPublic

Authored by dp on Sep 16 2022, 3:24 AM.

Details

Reviewers
foad
Joe_Nash
Commits
rGef8feb63590d: [AMDGPU][MC][NFC] Correct error message
Summary

Correct wording to say "only one unique literal operand is allowed".

Diff Detail

Event Timeline

dp created this revision.Sep 16 2022, 3:24 AM
Herald added a project: Restricted Project. · View Herald TranscriptSep 16 2022, 3:24 AM
Herald added subscribers: kosarev, kerbowa, hiraditya and 8 others. · View Herald Transcript
dp requested review of this revision.Sep 16 2022, 3:24 AM
Herald added a project: Restricted Project. · View Herald TranscriptSep 16 2022, 3:24 AM
Herald added subscribers: llvm-commits, wdng. · View Herald Transcript
Harbormaster completed remote builds in B187098: Diff 460693.Sep 16 2022, 4:47 AM
Joe_Nash accepted this revision.Sep 16 2022, 6:51 AM

LGTM

This revision is now accepted and ready to land.Sep 16 2022, 6:51 AM
This revision was landed with ongoing or failed builds.Sep 16 2022, 8:22 AM
Closed by commit rGef8feb63590d: [AMDGPU][MC][NFC] Correct error message (authored by dp). · Explain Why
This revision was automatically updated to reflect the committed changes.
dp added a commit: rGef8feb63590d: [AMDGPU][MC][NFC] Correct error message.

Revision Contents

PathSize
llvm/
lib/
Target/
AMDGPU/
AsmParser/
4 lines
test/
MC/
AMDGPU/
12 lines
6 lines
8 lines
20 lines
22 lines
8 lines
4 lines
4 lines
4 lines
24 lines

Diff 460693

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

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,347 Lines • ▼ Show 20 Lines if (!NumLiterals)
return true; return true;
if (!HasMandatoryLiteral && !getFeatureBits()[FeatureVOP3Literal]) { if (!HasMandatoryLiteral && !getFeatureBits()[FeatureVOP3Literal]) {
Error(getLitLoc(Operands), "literal operands are not supported"); Error(getLitLoc(Operands), "literal operands are not supported");
return false; return false;
} }
if (NumLiterals > 1) { if (NumLiterals > 1) {
Error(getLitLoc(Operands, true), "only one literal operand is allowed"); Error(getLitLoc(Operands, true), "only one unique literal operand is allowed");
return false; return false;
} }
return true; return true;
} }
// Returns -1 if not a register, 0 if VGPR and 1 if AGPR. // Returns -1 if not a register, 0 if VGPR and 1 if AGPR.
static int IsAGPROperand(const MCInst &Inst, uint16_t NameIdx, static int IsAGPROperand(const MCInst &Inst, uint16_t NameIdx,
▲ Show 20 Lines • Show All 243 Lines • ▼ Show 20 Linesbool AMDGPUAsmParser::validateInstruction(const MCInst &Inst,
const SMLoc &IDLoc, const SMLoc &IDLoc,
const OperandVector &Operands) { const OperandVector &Operands) {
if (auto ErrMsg = validateLdsDirect(Inst)) { if (auto ErrMsg = validateLdsDirect(Inst)) {
Error(getRegLoc(LDS_DIRECT, Operands), *ErrMsg); Error(getRegLoc(LDS_DIRECT, Operands), *ErrMsg);
return false; return false;
} }
if (!validateSOPLiteral(Inst)) { if (!validateSOPLiteral(Inst)) {
Error(getLitLoc(Operands), Error(getLitLoc(Operands),
"only one literal operand is allowed"); "only one unique literal operand is allowed");
return false; return false;
} }
if (!validateVOPLiteral(Inst, Operands)) { if (!validateVOPLiteral(Inst, Operands)) {
return false; return false;
} }
if (!validateConstantBusLimitations(Inst, Operands)) { if (!validateConstantBusLimitations(Inst, Operands)) {
return false; return false;
} }
▲ Show 20 Lines • Show All 4,724 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
// GFX10-NEXT: ; fixup A - offset: 8, value: u-1, kind: FK_Data_4 // GFX10-NEXT: ; fixup A - offset: 8, value: u-1, kind: FK_Data_4
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Instructions can use only one literal. // Instructions can use only one literal.
// Relocatable expressions are counted as literals. // Relocatable expressions are counted as literals.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
s_sub_u32 s0, 123, u s_sub_u32 s0, 123, u
// NOGFX10: error: only one literal operand is allowed // NOGFX10: error: only one unique literal operand is allowed
s_sub_u32 s0, u, u s_sub_u32 s0, u, u
// NOGFX10: error: only one literal operand is allowed // NOGFX10: error: only one unique 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 unique literal operand is allowed
v_bfe_u32 v0, v2, 123, u v_bfe_u32 v0, v2, 123, u
// NOGFX10: error: only one literal operand is allowed // NOGFX10: error: only one unique literal operand is allowed
v_bfe_u32 v0, v2, u, u v_bfe_u32 v0, v2, u, u
// NOGFX10: error: only one literal operand is allowed // NOGFX10: error: only one unique literal operand is allowed
v_bfe_u32 v0, v2, u, u1 v_bfe_u32 v0, v2, u, u1
// NOGFX10: error: only one literal operand is allowed // NOGFX10: error: only one unique literal operand is allowed

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

// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 -show-encoding %s | FileCheck %s --check-prefix=GFX9 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 -show-encoding %s | FileCheck %s --check-prefix=GFX9
// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck %s --check-prefix=NOGFX9 --implicit-check-not=error: // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck %s --check-prefix=NOGFX9 --implicit-check-not=error:
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Relocatable expressions cannot be used with SDWA modifiers. // Relocatable expressions cannot be used with SDWA modifiers.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
v_mov_b32_sdwa v1, sext(u) v_mov_b32_sdwa v1, sext(u)
// NOGFX9: error: expected an absolute expression // NOGFX9: error: expected an absolute expression
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Instructions can use only one literal. // Instructions can use only one literal.
// Relocatable expressions are counted as literals. // Relocatable expressions are counted as literals.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
s_sub_u32 s0, 123, u s_sub_u32 s0, 123, u
// NOGFX9: error: only one literal operand is allowed // NOGFX9: error: only one unique literal operand is allowed
s_sub_u32 s0, u, u s_sub_u32 s0, u, u
// NOGFX9: error: only one literal operand is allowed // NOGFX9: error: only one unique 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 unique literal operand is allowed
v_bfe_u32 v0, v2, v3, u v_bfe_u32 v0, v2, v3, u
// NOGFX9: error: literal operands are not supported // NOGFX9: error: literal operands are not supported
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Constant expressions may be used with 'sext' modifier // Constant expressions may be used with 'sext' modifier
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 17 Lines

llvm/test/MC/AMDGPU/gfx10_asm_err.s

Show First 20 Lines • Show All 274 Lines • ▼ Show 20 Lines
// GFX8-9: error: not a valid operand // GFX8-9: error: not a valid operand
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// VOP2 // VOP2
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
v_fmaak_f32 v0, 0xff32ff, v0, 0x11213141 v_fmaak_f32 v0, 0xff32ff, v0, 0x11213141
// GFX6-9: error: instruction not supported on this GPU // GFX6-9: error: instruction not supported on this GPU
// GFX10: error: only one literal operand is allowed // GFX10: error: only one unique literal operand is allowed
v_fmamk_f32 v0, 0xff32ff, 0x11213141, v0 v_fmamk_f32 v0, 0xff32ff, 0x11213141, v0
// GFX6-9: error: instruction not supported on this GPU // GFX6-9: error: instruction not supported on this GPU
// GFX10: error: only one literal operand is allowed // GFX10: error: only one unique literal operand is allowed
v_fmaak_f32 v0, 0xff32, v0, 0x1122 v_fmaak_f32 v0, 0xff32, v0, 0x1122
// GFX6-9: error: instruction not supported on this GPU // GFX6-9: error: instruction not supported on this GPU
// GFX10: error: only one literal operand is allowed // GFX10: error: only one unique literal operand is allowed
v_fmamk_f32 v0, 0xff32, 0x1122, v0 v_fmamk_f32 v0, 0xff32, 0x1122, v0
// GFX6-9: error: instruction not supported on this GPU // GFX6-9: error: instruction not supported on this GPU
// GFX10: error: only one literal operand is allowed // GFX10: error: only one unique literal operand is allowed
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// VOP2 E64. // VOP2 E64.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
v_add_co_ci_u32 v5, 0, v1, v2, vcc v_add_co_ci_u32 v5, 0, v1, v2, vcc
// GFX6-7: error: instruction not supported on this GPU // GFX6-7: error: instruction not supported on this GPU
// GFX8-9: error: instruction not supported on this GPU // GFX8-9: error: instruction not supported on this GPU
Show All 16 Lines

llvm/test/MC/AMDGPU/gfx10_err_pos.s

Show First 20 Lines • Show All 1,031 Lines • ▼ Show 20 Lines
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
v_mov_b32 v0, v0 row_bcast:0 v_mov_b32 v0, v0 row_bcast:0
// CHECK: error: not a valid operand. // CHECK: error: not a valid operand.
// CHECK-NEXT:{{^}}v_mov_b32 v0, v0 row_bcast:0 // CHECK-NEXT:{{^}}v_mov_b32 v0, v0 row_bcast:0
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
//============================================================================== //==============================================================================
// only one literal operand is allowed // only one unique 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 unique 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) v_add_f64 v[0:1], 1.23456, -abs(1.2345)
// CHECK: error: only one literal operand is allowed // CHECK: error: only one unique literal operand is allowed
// CHECK-NEXT:{{^}}v_add_f64 v[0:1], 1.23456, -abs(1.2345) // CHECK-NEXT:{{^}}v_add_f64 v[0:1], 1.23456, -abs(1.2345)
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
v_min3_i16 v5, 0x5678, 0x5678, 0x5679 v_min3_i16 v5, 0x5678, 0x5678, 0x5679
// CHECK: error: only one literal operand is allowed // CHECK: error: only one unique literal operand is allowed
// CHECK-NEXT:{{^}}v_min3_i16 v5, 0x5678, 0x5678, 0x5679 // CHECK-NEXT:{{^}}v_min3_i16 v5, 0x5678, 0x5678, 0x5679
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
v_pk_add_f16 v1, 25.0, 25.1 v_pk_add_f16 v1, 25.0, 25.1
// CHECK: error: only one literal operand is allowed // CHECK: error: only one unique literal operand is allowed
// CHECK-NEXT:{{^}}v_pk_add_f16 v1, 25.0, 25.1 // CHECK-NEXT:{{^}}v_pk_add_f16 v1, 25.0, 25.1
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
v_fma_mix_f32 v5, 0x7c, 0x7b, 1 v_fma_mix_f32 v5, 0x7c, 0x7b, 1
// CHECK: error: only one literal operand is allowed // CHECK: error: only one unique literal operand is allowed
// CHECK-NEXT:{{^}}v_fma_mix_f32 v5, 0x7c, 0x7b, 1 // CHECK-NEXT:{{^}}v_fma_mix_f32 v5, 0x7c, 0x7b, 1
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
v_pk_add_i16 v5, 0x7c, 0x4000 v_pk_add_i16 v5, 0x7c, 0x4000
// CHECK: error: only one literal operand is allowed // CHECK: error: only one unique literal operand is allowed
// CHECK-NEXT:{{^}}v_pk_add_i16 v5, 0x7c, 0x4000 // CHECK-NEXT:{{^}}v_pk_add_i16 v5, 0x7c, 0x4000
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
v_pk_add_i16 v5, 0x4400, 0x4000 v_pk_add_i16 v5, 0x4400, 0x4000
// CHECK: error: only one literal operand is allowed // CHECK: error: only one unique literal operand is allowed
// CHECK-NEXT:{{^}}v_pk_add_i16 v5, 0x4400, 0x4000 // CHECK-NEXT:{{^}}v_pk_add_i16 v5, 0x4400, 0x4000
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
v_bfe_u32 v0, v2, 123, undef v_bfe_u32 v0, v2, 123, undef
// CHECK: error: only one literal operand is allowed // CHECK: error: only one unique literal operand is allowed
// CHECK-NEXT:{{^}}v_bfe_u32 v0, v2, 123, undef // CHECK-NEXT:{{^}}v_bfe_u32 v0, v2, 123, undef
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
v_bfe_u32 v0, v2, undef, 123 v_bfe_u32 v0, v2, undef, 123
// CHECK: error: only one literal operand is allowed // CHECK: error: only one unique literal operand is allowed
// CHECK-NEXT:{{^}}v_bfe_u32 v0, v2, undef, 123 // CHECK-NEXT:{{^}}v_bfe_u32 v0, v2, undef, 123
// CHECK-NEXT:{{^}} ^ // CHECK-NEXT:{{^}} ^
//============================================================================== //==============================================================================
// out of bounds interpolation attribute number // out of bounds interpolation attribute number
v_interp_p1_f32 v0, v1, attr64.w v_interp_p1_f32 v0, v1, attr64.w
// CHECK: error: out of bounds interpolation attribute number // CHECK: error: out of bounds interpolation attribute number
▲ Show 20 Lines • Show All 278 Lines • Show Last 20 Lines

llvm/test/MC/AMDGPU/gfx11_asm_vopd_errs.s

// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1100 %s 2>&1 | FileCheck %s -check-prefix=GFX11 --implicit-check-not=error: --strict-whitespace // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1100 %s 2>&1 | FileCheck %s -check-prefix=GFX11 --implicit-check-not=error: --strict-whitespace
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// A VOPD instruction can use only one literal. // A VOPD instruction can use only one literal.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
v_dual_mul_f32 v11, 0x24681357, v2 :: v_dual_mul_f32 v10, 0xbabe, v5 v_dual_mul_f32 v11, 0x24681357, v2 :: v_dual_mul_f32 v10, 0xbabe, v5
// GFX11: error: only one literal operand is allowed // GFX11: error: only one unique literal operand is allowed
// GFX11-NEXT:{{^}}v_dual_mul_f32 v11, 0x24681357, v2 :: v_dual_mul_f32 v10, 0xbabe, v5 // GFX11-NEXT:{{^}}v_dual_mul_f32 v11, 0x24681357, v2 :: v_dual_mul_f32 v10, 0xbabe, v5
// GFX11-NEXT:{{^}} ^ // GFX11-NEXT:{{^}} ^
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// When 2 different literals are specified, show the location // When 2 different literals are specified, show the location
// of the last literal which is not a KImm, if any. // of the last literal which is not a KImm, if any.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
v_dual_fmamk_f32 v122, v74, 0xa0172923, v161 :: v_dual_lshlrev_b32 v247, 0xbabe, v99 v_dual_fmamk_f32 v122, v74, 0xa0172923, v161 :: v_dual_lshlrev_b32 v247, 0xbabe, v99
// GFX11: error: only one literal operand is allowed // GFX11: error: only one unique literal operand is allowed
// GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, v74, 0xa0172923, v161 :: v_dual_lshlrev_b32 v247, 0xbabe, v99 // GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, v74, 0xa0172923, v161 :: v_dual_lshlrev_b32 v247, 0xbabe, v99
// GFX11-NEXT:{{^}} ^ // GFX11-NEXT:{{^}} ^
v_dual_add_f32 v5, 0xaf123456, v2 :: v_dual_fmaak_f32 v6, v3, v1, 0xbabe v_dual_add_f32 v5, 0xaf123456, v2 :: v_dual_fmaak_f32 v6, v3, v1, 0xbabe
// GFX11: error: only one literal operand is allowed // GFX11: error: only one unique literal operand is allowed
// GFX11-NEXT:{{^}}v_dual_add_f32 v5, 0xaf123456, v2 :: v_dual_fmaak_f32 v6, v3, v1, 0xbabe // GFX11-NEXT:{{^}}v_dual_add_f32 v5, 0xaf123456, v2 :: v_dual_fmaak_f32 v6, v3, v1, 0xbabe
// GFX11-NEXT:{{^}} ^ // GFX11-NEXT:{{^}} ^
v_dual_add_f32 v5, 0xaf123456, v2 :: v_dual_fmaak_f32 v6, 0xbabe, v1, 0xbabe v_dual_add_f32 v5, 0xaf123456, v2 :: v_dual_fmaak_f32 v6, 0xbabe, v1, 0xbabe
// GFX11: error: only one literal operand is allowed // GFX11: error: only one unique literal operand is allowed
// GFX11-NEXT:{{^}}v_dual_add_f32 v5, 0xaf123456, v2 :: v_dual_fmaak_f32 v6, 0xbabe, v1, 0xbabe // GFX11-NEXT:{{^}}v_dual_add_f32 v5, 0xaf123456, v2 :: v_dual_fmaak_f32 v6, 0xbabe, v1, 0xbabe
// GFX11-NEXT:{{^}} ^ // GFX11-NEXT:{{^}} ^
v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0x1234, v162 v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0x1234, v162
// GFX11: error: only one literal operand is allowed // GFX11: error: only one unique literal operand is allowed
// GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0x1234, v162 // GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0x1234, v162
// GFX11-NEXT:{{^}} ^ // GFX11-NEXT:{{^}} ^
v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, s0, 0x1234, v162 v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, s0, 0x1234, v162
// GFX11: error: only one literal operand is allowed // GFX11: error: only one unique literal operand is allowed
// GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, s0, 0x1234, v162 // GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, s0, 0x1234, v162
// GFX11-NEXT:{{^}} ^ // GFX11-NEXT:{{^}} ^
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Check that assembler detects a different literal regardless of its location. // Check that assembler detects a different literal regardless of its location.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0x1234, v162 v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0x1234, v162
// GFX11: error: only one literal operand is allowed // GFX11: error: only one unique literal operand is allowed
// GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0x1234, v162 // GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0x1234, v162
// GFX11-NEXT:{{^}} ^ // GFX11-NEXT:{{^}} ^
v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0x1234, 0xdeadbeef, v162 v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0x1234, 0xdeadbeef, v162
// GFX11: error: only one literal operand is allowed // GFX11: error: only one unique literal operand is allowed
// GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0x1234, 0xdeadbeef, v162 // GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, 0xdeadbeef, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0x1234, 0xdeadbeef, v162
// GFX11-NEXT:{{^}} ^ // GFX11-NEXT:{{^}} ^
v_dual_fmamk_f32 v122, 0xdeadbeef, 0x1234, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0xdeadbeef, v162 v_dual_fmamk_f32 v122, 0xdeadbeef, 0x1234, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0xdeadbeef, v162
// GFX11: error: only one literal operand is allowed // GFX11: error: only one unique literal operand is allowed
// GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, 0xdeadbeef, 0x1234, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0xdeadbeef, v162 // GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, 0xdeadbeef, 0x1234, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0xdeadbeef, v162
// GFX11-NEXT:{{^}} ^ // GFX11-NEXT:{{^}} ^
v_dual_fmamk_f32 v122, 0x1234, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0xdeadbeef, v162 v_dual_fmamk_f32 v122, 0x1234, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0xdeadbeef, v162
// GFX11: error: only one literal operand is allowed // GFX11: error: only one unique literal operand is allowed
// GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, 0x1234, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0xdeadbeef, v162 // GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, 0x1234, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, 0xdeadbeef, 0xdeadbeef, v162
// GFX11-NEXT:{{^}} ^ // GFX11-NEXT:{{^}} ^
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// When 2 different literals are specified and all literals are KImm, // When 2 different literals are specified and all literals are KImm,
// show the location of the last KImm literal. // show the location of the last KImm literal.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
v_dual_fmamk_f32 v122, s0, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, s0, 0x1234, v162 v_dual_fmamk_f32 v122, s0, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, s0, 0x1234, v162
// GFX11: error: only one literal operand is allowed // GFX11: error: only one unique literal operand is allowed
// GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, s0, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, s0, 0x1234, v162 // GFX11-NEXT:{{^}}v_dual_fmamk_f32 v122, s0, 0xdeadbeef, v161 :: v_dual_fmamk_f32 v123, s0, 0x1234, v162
// GFX11-NEXT:{{^}} ^ // GFX11-NEXT:{{^}} ^
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// A VOPD instruction cannot use more than 2 scalar operands // A VOPD instruction cannot use more than 2 scalar operands
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// 2 different SGPRs + LITERAL // 2 different SGPRs + LITERAL
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

llvm/test/MC/AMDGPU/literals.s

Show First 20 Lines • Show All 837 Lines • ▼ Show 20 Lines
// NOSICIVI: error: register not available on this GPU // NOSICIVI: error: register not available on this GPU
// NOGFX9: error: invalid operand (violates constant bus restrictions) // NOGFX9: error: invalid operand (violates constant bus restrictions)
v_madak_f32 v0, shared_base, v0, 0x11213141 v_madak_f32 v0, shared_base, v0, 0x11213141
// NOGCN: error: invalid operand (violates constant bus restrictions) // NOGCN: error: invalid operand (violates constant bus restrictions)
v_madak_f32 v0, scc, v0, 0x11213141 v_madak_f32 v0, scc, v0, 0x11213141
// NOGCN: error: only one literal operand is allowed // NOGCN: error: only one unique literal operand is allowed
v_madak_f32 v0, 0xff32ff, v0, 0x11213141 v_madak_f32 v0, 0xff32ff, v0, 0x11213141
// NOGCN: error: only one literal operand is allowed // NOGCN: error: only one unique literal operand is allowed
v_madmk_f32 v0, 0xff32ff, 0x11213141, v0 v_madmk_f32 v0, 0xff32ff, 0x11213141, v0
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
// NOGFX89: error: only one literal operand is allowed // NOGFX89: error: only one unique literal operand is allowed
v_madak_f16 v0, 0xff32, v0, 0x1122 v_madak_f16 v0, 0xff32, v0, 0x1122
// NOSICI: error: instruction not supported on this GPU // NOSICI: error: instruction not supported on this GPU
// NOGFX89: error: only one literal operand is allowed // NOGFX89: error: only one unique literal operand is allowed
v_madmk_f16 v0, 0xff32, 0x1122, v0 v_madmk_f16 v0, 0xff32, 0x1122, v0
// NOSICIVI: error: register not available on this GPU // NOSICIVI: error: register not available on this GPU
// NOGFX9: error: invalid operand (violates constant bus restrictions) // NOGFX9: error: invalid operand (violates constant bus restrictions)
v_cmp_eq_f32 s[0:1], private_base, private_limit v_cmp_eq_f32 s[0:1], private_base, private_limit
// NOSICIVI: error: register not available on this GPU // NOSICIVI: error: register not available on this GPU
// NOGFX9: error: invalid operand (violates constant bus restrictions) // NOGFX9: error: invalid operand (violates constant bus restrictions)
Show All 12 Lines

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

Show All 24 Lines
v_pk_add_f16 v1, 0xffffffffffff000f, v2 v_pk_add_f16 v1, 0xffffffffffff000f, v2
// GFX9: error: literal operands are not supported // GFX9: error: literal operands are not supported
v_pk_add_f16 v1, 0x1000ffff, v2 v_pk_add_f16 v1, 0x1000ffff, v2
// GFX9: error: literal operands are not supported // 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: literal operands are not supported // GFX9: error: literal operands are not supported
// GFX10: error: only one literal operand is allowed // GFX10: error: only one unique literal operand is allowed
v_pk_mad_i16 v5, 0x3c00, 0x4000, 2 v_pk_mad_i16 v5, 0x3c00, 0x4000, 2
// GFX9: error: literal operands are not supported // GFX9: error: literal operands are not supported
// GFX10: error: only one literal operand is allowed // GFX10: error: only one unique literal operand is allowed
v_pk_mad_i16 v5, 0x3c00, 3, 2 v_pk_mad_i16 v5, 0x3c00, 3, 2
// GFX9: error: literal operands are not supported // 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: literal operands are not supported // 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: literal operands are not supported // GFX9: error: literal operands are not supported

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

// RUN: not llvm-mc -arch=amdgcn %s 2>&1 | FileCheck -check-prefix=GCN --implicit-check-not=error: %s // RUN: not llvm-mc -arch=amdgcn %s 2>&1 | FileCheck -check-prefix=GCN --implicit-check-not=error: %s
s_cbranch_g_fork 100, s[6:7] s_cbranch_g_fork 100, s[6:7]
// GCN: error: invalid operand for instruction // GCN: error: invalid operand for instruction
s_cbranch_g_fork s[6:7], 100 s_cbranch_g_fork s[6:7], 100
// GCN: error: invalid operand for instruction // GCN: error: invalid operand for instruction
s_and_b32 s2, 0x12345678, 0x12345679 s_and_b32 s2, 0x12345678, 0x12345679
// GCN: error: only one literal operand is allowed // GCN: error: only one unique literal operand is allowed
s_and_b64 s[2:3], 0x12345678, 0x12345679 s_and_b64 s[2:3], 0x12345678, 0x12345679
// GCN: error: only one literal operand is allowed // GCN: error: only one unique literal operand is allowed

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

Show All 22 Lines
s_set_gpr_idx_on s0, gpr_idx(DST s_set_gpr_idx_on s0, gpr_idx(DST
// VI: error: expected a comma or a closing parenthesis // VI: error: expected a comma or a closing parenthesis
s_set_gpr_idx_on s0, gpr_idx(SRC0, s_set_gpr_idx_on s0, gpr_idx(SRC0,
// VI: error: expected a VGPR index mode // VI: error: expected a VGPR index mode
s_cmp_eq_i32 0x12345678, 0x12345679 s_cmp_eq_i32 0x12345678, 0x12345679
// GCN: error: only one literal operand is allowed // GCN: error: only one unique literal operand is allowed
s_cmp_eq_u64 0x12345678, 0x12345679 s_cmp_eq_u64 0x12345678, 0x12345679
// GCN: error: only one literal operand is allowed // GCN: error: only one unique literal operand is allowed

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

Show All 26 Lines
// 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: literal operands are not supported // 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: literal operands are not supported // 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: only one literal operand is allowed // GFX10-ERR: error: only one unique literal operand is allowed
// GFX9-ERR: error: literal operands are not supported // 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: literal operands are not supported // 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: only one literal operand is allowed // GFX10-ERR: error: only one unique literal operand is allowed
// GFX9-ERR: error: literal operands are not supported // 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: literal operands are not supported // 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: literal operands are not supported // 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 v0, 0x3039, s1 ; encoding: [0x00,0x00,0x63,0xd7,0xff,0x02,0x00,0x00,0x39,0x30,0x00,0x00] // GFX10: v_bfm_b32 v0, 0x3039, s1 ; encoding: [0x00,0x00,0x63,0xd7,0xff,0x02,0x00,0x00,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: literal operands are not supported // 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 v0, 0x3039, v1 ; encoding: [0x00,0x00,0x63,0xd7,0xff,0x02,0x02,0x00,0x39,0x30,0x00,0x00] // GFX10: v_bfm_b32 v0, 0x3039, v1 ; encoding: [0x00,0x00,0x63,0xd7,0xff,0x02,0x02,0x00,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: literal operands are not supported // 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 v0, 0x3039, 0x3039 ; encoding: [0x00,0x00,0x63,0xd7,0xff,0xfe,0x01,0x00,0x39,0x30,0x00,0x00] // GFX10: v_bfm_b32 v0, 0x3039, 0x3039 ; encoding: [0x00,0x00,0x63,0xd7,0xff,0xfe,0x01,0x00,0x39,0x30,0x00,0x00]
// GFX9-ERR: error: literal operands are not supported // 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: only one literal operand is allowed // GFX10-ERR: error: only one unique literal operand is allowed
// GFX9-ERR: error: literal operands are not supported // 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,0x40,0x0f,0xcc,0xff,0x04,0x02,0x18,0x40,0x4e,0x00,0x00] // GFX10: v_pk_add_f16 v1, 0x4e40, v2 ; encoding: [0x01,0x40,0x0f,0xcc,0xff,0x04,0x02,0x18,0x40,0x4e,0x00,0x00]
// GFX9-ERR: error: literal operands are not supported // 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,0x40,0x0f,0xcc,0xff,0x04,0x02,0x18,0x40,0xe2,0x01,0x00] // GFX10: v_pk_add_f16 v1, 0x1e240, v2 ; encoding: [0x01,0x40,0x0f,0xcc,0xff,0x04,0x02,0x18,0x40,0xe2,0x01,0x00]
// GFX9-ERR: error: literal operands are not supported // 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,0x40,0x0f,0xcc,0xff,0x04,0x02,0x18,0x38,0xff,0xff,0xff] // GFX10: v_pk_add_f16 v1, 0xffffff38, v2 ; encoding: [0x01,0x40,0x0f,0xcc,0xff,0x04,0x02,0x18,0x38,0xff,0xff,0xff]
// GFX9-ERR: error: literal operands are not supported // 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,0x40,0x0f,0xcc,0xff,0xfe,0x01,0x18,0x40,0x4e,0x00,0x00] // GFX10: v_pk_add_f16 v1, 0x4e40, 0x4e40 ; encoding: [0x01,0x40,0x0f,0xcc,0xff,0xfe,0x01,0x18,0x40,0x4e,0x00,0x00]
// GFX9-ERR: error: literal operands are not supported // 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: only one literal operand is allowed // GFX10-ERR: error: only one unique literal operand is allowed
// GFX9-ERR: error: literal operands are not supported // 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,0x40,0x0a,0xcc,0xff,0x04,0x02,0x18,0x38,0xff,0xff,0xff] // GFX10: v_pk_add_u16 v1, 0xffffff38, v2 ; encoding: [0x01,0x40,0x0a,0xcc,0xff,0x04,0x02,0x18,0x38,0xff,0xff,0xff]
// GFX9-ERR: error: literal operands are not supported // 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,0x40,0x0a,0xcc,0xc0,0x04,0x02,0x18] // GFX10: v_pk_add_u16 v1, 64, v2 ; encoding: [0x01,0x40,0x0a,0xcc,0xc0,0x04,0x02,0x18]
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
// 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: literal operands are not supported // 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: literal operands are not supported // 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: only one literal operand is allowed // GFX10-ERR: error: only one unique literal operand is allowed
// GFX9-ERR: error: literal operands are not supported // 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 v5, 0xfe0b, v2 ; encoding: [0x05,0x00,0x0a,0xd7,0xff,0x04,0x02,0x00,0x0b,0xfe,0x00,0x00] // GFX10: v_max_i16 v5, 0xfe0b, v2 ; encoding: [0x05,0x00,0x0a,0xd7,0xff,0x04,0x02,0x00,0x0b,0xfe,0x00,0x00]
// GFX9-ERR: error: literal operands are not supported // 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 v5, v1, 0x123 ; encoding: [0x05,0x00,0x0a,0xd7,0x01,0xff,0x01,0x00,0x23,0x01,0x00,0x00] // GFX10: v_max_i16 v5, v1, 0x123 ; encoding: [0x05,0x00,0x0a,0xd7,0x01,0xff,0x01,0x00,0x23,0x01,0x00,0x00]
Show All 15 Lines
// 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: literal operands are not supported // 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: literal operands are not supported // 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: only one literal operand is allowed // GFX10-ERR: error: only one unique literal operand is allowed
// GFX9-ERR: error: literal operands are not supported // 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: only one literal operand is allowed // GFX10-ERR: error: only one unique literal operand is allowed
// GFX9-ERR: error: literal operands are not supported // 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 v5, 0xfe0b, v2 ; encoding: [0x05,0x00,0x03,0xd7,0xff,0x04,0x02,0x00,0x0b,0xfe,0x00,0x00] // GFX10: v_add_nc_u16 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 v5, v1, 0x1234 ; encoding: [0x05,0x00,0x03,0xd7,0x01,0xff,0x01,0x00,0x34,0x12,0x00,0x00] // GFX10: v_add_nc_u16 v5, v1, 0x1234 ; encoding: [0x05,0x00,0x03,0xd7,0x01,0xff,0x01,0x00,0x34,0x12,0x00,0x00]
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
// 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: literal operands are not supported // 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: literal operands are not supported // 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: only one literal operand is allowed // GFX10-ERR: error: only one unique literal operand is allowed
// GFX9-ERR: error: literal operands are not supported // 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: literal operands are not supported // 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]
Show All 11 Lines
// GFX10: v_cmpx_class_f32_e64 v1, 0xaf123456 ; encoding: [0x7e,0x00,0x98,0xd4,0x01,0xff,0x01,0x00,0x56,0x34,0x12,0xaf] // GFX10: v_cmpx_class_f32_e64 v1, 0xaf123456 ; encoding: [0x7e,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: [0x7e,0x00,0x98,0xd4,0xff,0xfe,0x01,0x00,0x56,0x34,0x12,0xaf] // GFX10: v_cmpx_class_f32_e64 0xaf123456, 0xaf123456 ; encoding: [0x7e,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: only one literal operand is allowed // GFX10-ERR: error: only one unique 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: [0x7e,0x00,0x99,0xd4,0x01,0xff,0x01,0x00,0x56,0x34,0x00,0x00] // GFX10: v_cmpx_lt_i16_e64 v1, 0x3456 ; encoding: [0x7e,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: [0x7e,0x00,0x99,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x00,0x00] // GFX10: v_cmpx_lt_i16_e64 0x3456, v2 ; encoding: [0x7e,0x00,0x99,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x00,0x00]
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
// GFX10: v_pk_add_i16 v5, v1, 0x7b ; encoding: [0x05,0x40,0x02,0xcc,0x01,0xff,0x01,0x18,0x7b,0x00,0x00,0x00] // GFX10: v_pk_add_i16 v5, v1, 0x7b ; encoding: [0x05,0x40,0x02,0xcc,0x01,0xff,0x01,0x18,0x7b,0x00,0x00,0x00]
// GFX9-ERR: error: literal operands are not supported // 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,0x40,0x02,0xcc,0xff,0xfe,0x01,0x18,0x7b,0xab,0x00,0x00] // GFX10: v_pk_add_i16 v5, 0xab7b, 0xab7b ; encoding: [0x05,0x40,0x02,0xcc,0xff,0xfe,0x01,0x18,0x7b,0xab,0x00,0x00]
// GFX9-ERR: error: literal operands are not supported // 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: only one literal operand is allowed // GFX10-ERR: error: only one unique literal operand is allowed
// GFX9-ERR: error: literal operands are not supported // 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: literal operands are not supported // 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: literal operands are not supported // 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: literal operands are not supported // 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: literal operands are not supported // 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: literal operands are not supported // 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: only one literal operand is allowed // GFX10-ERR: error: only one unique literal operand is allowed
// GFX9-ERR: error: literal operands are not supported // 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: literal operands are not supported // 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: literal operands are not supported // 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: only one literal operand is allowed // GFX10-ERR: error: only one unique literal operand is allowed
// GFX9-ERR: error: literal operands are not supported // GFX9-ERR: error: literal operands are not supported