Skip to content

Commit 0f261db

Browse files
kosarevkosarev
committed
[AMDGPU][MC] Avoid creating lit64() operands unless asked or needed.
There should normally be no need to generate implicit lit64() modifiers on the assembler side. It's the encoder's responsibility to recognise literals that are implicitly 64 bits wide. The exceptions are where we rewrite floating-point operand values as integer ones, which would not be assembled back to the original values unless wrapped into lit64(). Respect explicit lit() modifiers for non-inline values as necessary to avoid regressions in MC tests. This change still doesn't prevent use of inline constants where lit()/lit64 is specified; subject to a separate patch. On disassembling, only create lit64() operands where necessary for correct round-tripping. Add round-tripping tests where useful and feasible.
1 parent bf8c2f2 commit 0f261db

24 files changed

+428
-387
lines changed

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

Lines changed: 47 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -2331,6 +2331,7 @@ void AMDGPUOperand::addLiteralImmOperand(MCInst &Inst, int64_t Val, bool ApplyMo
23312331
bool CanUse64BitLiterals =
23322332
AsmParser->has64BitLiterals() &&
23332333
!(InstDesc.TSFlags & (SIInstrFlags::VOP3 | SIInstrFlags::VOP3P));
2334+
LitModifier Lit = getModifiers().Lit;
23342335
MCContext &Ctx = AsmParser->getContext();
23352336

23362337
if (Imm.IsFPImm) { // We got fp literal token
@@ -2364,10 +2365,23 @@ void AMDGPUOperand::addLiteralImmOperand(MCInst &Inst, int64_t Val, bool ApplyMo
23642365

23652366
if ((OpTy == AMDGPU::OPERAND_REG_IMM_FP64 ||
23662367
OpTy == AMDGPU::OPERAND_REG_INLINE_C_FP64 ||
2367-
OpTy == AMDGPU::OPERAND_REG_INLINE_AC_FP64) &&
2368-
CanUse64BitLiterals && Lo_32(Val) != 0) {
2369-
Inst.addOperand(MCOperand::createExpr(
2370-
AMDGPUMCExpr::createLit(LitModifier::Lit64, Val, Ctx)));
2368+
OpTy == AMDGPU::OPERAND_REG_INLINE_AC_FP64)) {
2369+
if (CanUse64BitLiterals && Lit == LitModifier::None &&
2370+
(isInt<32>(Val) || isUInt<32>(Val))) {
2371+
// The floating-point operand will be verbalized as an
2372+
// integer one. If that integer happens to fit 32 bits, on
2373+
// re-assembling it will be intepreted as the high half of
2374+
// the actual value, so we have to wrap it into lit64().
2375+
Lit = LitModifier::Lit64;
2376+
} else if (Lit == LitModifier::Lit) {
2377+
// For FP64 operands lit() specifies the high half of the value.
2378+
Val = Hi_32(Val);
2379+
}
2380+
}
2381+
2382+
if (Lit != LitModifier::None) {
2383+
Inst.addOperand(
2384+
MCOperand::createExpr(AMDGPUMCExpr::createLit(Lit, Val, Ctx)));
23712385
} else {
23722386
Inst.addOperand(MCOperand::createImm(Val));
23732387
}
@@ -2380,9 +2394,13 @@ void AMDGPUOperand::addLiteralImmOperand(MCInst &Inst, int64_t Val, bool ApplyMo
23802394
llvm_unreachable("fp literal in 64-bit integer instruction.");
23812395

23822396
case AMDGPU::OPERAND_KIMM64:
2383-
if (CanUse64BitLiterals && Lo_32(Val) != 0) {
2384-
Inst.addOperand(MCOperand::createExpr(
2385-
AMDGPUMCExpr::createLit(LitModifier::Lit64, Val, Ctx)));
2397+
if (CanUse64BitLiterals && Lit == LitModifier::None &&
2398+
(isInt<32>(Val) || isUInt<32>(Val)))
2399+
Lit = LitModifier::Lit64;
2400+
2401+
if (Lit != LitModifier::None) {
2402+
Inst.addOperand(
2403+
MCOperand::createExpr(AMDGPUMCExpr::createLit(Lit, Val, Ctx)));
23862404
} else {
23872405
Inst.addOperand(MCOperand::createImm(Val));
23882406
}
@@ -2471,13 +2489,12 @@ void AMDGPUOperand::addLiteralImmOperand(MCInst &Inst, int64_t Val, bool ApplyMo
24712489
// truncated to uint32_t), if the target doesn't support 64-bit literals, or
24722490
// the lit modifier is explicitly used, we need to truncate it to the 32
24732491
// LSBs.
2474-
if (!AsmParser->has64BitLiterals() ||
2475-
getModifiers().Lit == LitModifier::Lit)
2492+
if (!AsmParser->has64BitLiterals() || Lit == LitModifier::Lit)
24762493
Val = Lo_32(Val);
24772494

2478-
if (CanUse64BitLiterals && (!isInt<32>(Val) || !isUInt<32>(Val))) {
2479-
Inst.addOperand(MCOperand::createExpr(
2480-
AMDGPUMCExpr::createLit(LitModifier::Lit64, Val, Ctx)));
2495+
if (Lit != LitModifier::None) {
2496+
Inst.addOperand(
2497+
MCOperand::createExpr(AMDGPUMCExpr::createLit(Lit, Val, Ctx)));
24812498
} else {
24822499
Inst.addOperand(MCOperand::createImm(Val));
24832500
}
@@ -2501,15 +2518,18 @@ void AMDGPUOperand::addLiteralImmOperand(MCInst &Inst, int64_t Val, bool ApplyMo
25012518
// 1) explicitly forced by using lit modifier;
25022519
// 2) the value is a valid 32-bit representation (signed or unsigned),
25032520
// meanwhile not forced by lit64 modifier.
2504-
if (getModifiers().Lit == LitModifier::Lit ||
2505-
(getModifiers().Lit != LitModifier::Lit64 &&
2506-
(isInt<32>(Val) || isUInt<32>(Val))))
2521+
if (Lit == LitModifier::Lit ||
2522+
(Lit != LitModifier::Lit64 && (isInt<32>(Val) || isUInt<32>(Val))))
25072523
Val = static_cast<uint64_t>(Val) << 32;
25082524
}
25092525

2510-
if (CanUse64BitLiterals && Lo_32(Val) != 0) {
2511-
Inst.addOperand(MCOperand::createExpr(
2512-
AMDGPUMCExpr::createLit(LitModifier::Lit64, Val, Ctx)));
2526+
// For FP64 operands lit() specifies the high half of the value.
2527+
if (Lit == LitModifier::Lit)
2528+
Val = Hi_32(Val);
2529+
2530+
if (Lit != LitModifier::None) {
2531+
Inst.addOperand(
2532+
MCOperand::createExpr(AMDGPUMCExpr::createLit(Lit, Val, Ctx)));
25132533
} else {
25142534
Inst.addOperand(MCOperand::createImm(Val));
25152535
}
@@ -2530,13 +2550,12 @@ void AMDGPUOperand::addLiteralImmOperand(MCInst &Inst, int64_t Val, bool ApplyMo
25302550
return;
25312551

25322552
case AMDGPU::OPERAND_KIMM64:
2533-
if ((isInt<32>(Val) || isUInt<32>(Val)) &&
2534-
getModifiers().Lit != LitModifier::Lit64)
2553+
if ((isInt<32>(Val) || isUInt<32>(Val)) && Lit != LitModifier::Lit64)
25352554
Val <<= 32;
25362555

2537-
if (CanUse64BitLiterals && Lo_32(Val) != 0) {
2538-
Inst.addOperand(MCOperand::createExpr(
2539-
AMDGPUMCExpr::createLit(LitModifier::Lit64, Val, Ctx)));
2556+
if (Lit != LitModifier::None) {
2557+
Inst.addOperand(
2558+
MCOperand::createExpr(AMDGPUMCExpr::createLit(Lit, Val, Ctx)));
25402559
} else {
25412560
Inst.addOperand(MCOperand::createImm(Val));
25422561
}
@@ -4814,12 +4833,15 @@ bool AMDGPUAsmParser::validateSOPLiteral(const MCInst &Inst,
48144833
const MCOperand &MO = Inst.getOperand(OpIdx);
48154834
// Exclude special imm operands (like that used by s_set_gpr_idx_on)
48164835
if (AMDGPU::isSISrcOperand(Desc, OpIdx)) {
4836+
bool IsLit = false;
48174837
std::optional<int64_t> Imm;
48184838
if (MO.isImm()) {
48194839
Imm = MO.getImm();
48204840
} else if (MO.isExpr()) {
4821-
if (isLitExpr(MO.getExpr()))
4841+
if (isLitExpr(MO.getExpr())) {
4842+
IsLit = true;
48224843
Imm = getLitValue(MO.getExpr());
4844+
}
48234845
} else {
48244846
continue;
48254847
}
@@ -4829,7 +4851,7 @@ bool AMDGPUAsmParser::validateSOPLiteral(const MCInst &Inst,
48294851
} else if (!isInlineConstant(Inst, OpIdx)) {
48304852
auto OpType = static_cast<AMDGPU::OperandType>(
48314853
Desc.operands()[OpIdx].OperandType);
4832-
int64_t Value = encode32BitLiteral(*Imm, OpType);
4854+
int64_t Value = encode32BitLiteral(*Imm, OpType, IsLit);
48334855
if (NumLiterals == 0 || LiteralValue != Value) {
48344856
LiteralValue = Value;
48354857
++NumLiterals;

‎llvm/lib/Target/AMDGPU/Disassembler/AMDGPUDisassembler.cpp‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1545,7 +1545,7 @@ AMDGPUDisassembler::decodeMandatoryLiteral64Constant(uint64_t Val) const {
15451545
HasLiteral = true;
15461546
Literal = Literal64 = Val;
15471547

1548-
bool UseLit64 = Lo_32(Literal64) != 0;
1548+
bool UseLit64 = Hi_32(Literal64) == 0;
15491549
return UseLit64 ? MCOperand::createExpr(AMDGPUMCExpr::createLit(
15501550
LitModifier::Lit64, Literal64, getContext()))
15511551
: MCOperand::createImm(Literal64);
@@ -1578,11 +1578,11 @@ MCOperand AMDGPUDisassembler::decodeLiteralConstant(const MCInstrDesc &Desc,
15781578
if (CanUse64BitLiterals) {
15791579
if (OpDesc.OperandType == AMDGPU::OPERAND_REG_IMM_INT64 ||
15801580
OpDesc.OperandType == AMDGPU::OPERAND_REG_INLINE_C_INT64)
1581-
UseLit64 = !isInt<32>(Val) || !isUInt<32>(Val);
1581+
UseLit64 = false;
15821582
else if (OpDesc.OperandType == AMDGPU::OPERAND_REG_IMM_FP64 ||
15831583
OpDesc.OperandType == AMDGPU::OPERAND_REG_INLINE_C_FP64 ||
15841584
OpDesc.OperandType == AMDGPU::OPERAND_REG_INLINE_AC_FP64)
1585-
UseLit64 = Lo_32(Val) != 0;
1585+
UseLit64 = Hi_32(Literal64) == 0;
15861586
}
15871587

15881588
return UseLit64 ? MCOperand::createExpr(AMDGPUMCExpr::createLit(
@@ -1608,12 +1608,12 @@ AMDGPUDisassembler::decodeLiteral64Constant(const MCInst &Inst) const {
16081608
const MCOperandInfo &OpDesc = Desc.operands()[Inst.getNumOperands()];
16091609
if (OpDesc.OperandType == AMDGPU::OPERAND_REG_IMM_INT64 ||
16101610
OpDesc.OperandType == AMDGPU::OPERAND_REG_INLINE_C_INT64) {
1611-
UseLit64 = !isInt<32>(Literal64) || !isUInt<32>(Literal64);
1611+
UseLit64 = false;
16121612
} else {
16131613
assert(OpDesc.OperandType == AMDGPU::OPERAND_REG_IMM_FP64 ||
16141614
OpDesc.OperandType == AMDGPU::OPERAND_REG_INLINE_C_FP64 ||
16151615
OpDesc.OperandType == AMDGPU::OPERAND_REG_INLINE_AC_FP64);
1616-
UseLit64 = Lo_32(Literal64) != 0;
1616+
UseLit64 = Hi_32(Literal64) == 0;
16171617
}
16181618

16191619
return UseLit64 ? MCOperand::createExpr(AMDGPUMCExpr::createLit(

‎llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCCodeEmitter.cpp‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -452,13 +452,16 @@ void AMDGPUMCCodeEmitter::encodeInstruction(const MCInst &MI,
452452
// Yes! Encode it
453453
int64_t Imm = 0;
454454

455+
bool IsLit = false;
455456
if (Op.isImm())
456457
Imm = Op.getImm();
457458
else if (Op.isExpr()) {
458-
if (const auto *C = dyn_cast<MCConstantExpr>(Op.getExpr()))
459+
if (const auto *C = dyn_cast<MCConstantExpr>(Op.getExpr())) {
459460
Imm = C->getValue();
460-
else if (AMDGPU::isLitExpr(Op.getExpr()))
461+
} else if (AMDGPU::isLitExpr(Op.getExpr())) {
462+
IsLit = true;
461463
Imm = AMDGPU::getLitValue(Op.getExpr());
464+
}
462465
} else // Exprs will be replaced with a fixup value.
463466
llvm_unreachable("Must be immediate or expr");
464467

@@ -468,7 +471,7 @@ void AMDGPUMCCodeEmitter::encodeInstruction(const MCInst &MI,
468471
} else {
469472
auto OpType =
470473
static_cast<AMDGPU::OperandType>(Desc.operands()[i].OperandType);
471-
Imm = AMDGPU::encode32BitLiteral(Imm, OpType);
474+
Imm = AMDGPU::encode32BitLiteral(Imm, OpType, IsLit);
472475
support::endian::write<uint32_t>(CB, Imm, llvm::endianness::little);
473476
}
474477

‎llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3149,7 +3149,7 @@ bool isValid32BitLiteral(uint64_t Val, bool IsFP64) {
31493149
return isUInt<32>(Val) || isInt<32>(Val);
31503150
}
31513151

3152-
int64_t encode32BitLiteral(int64_t Imm, OperandType Type) {
3152+
int64_t encode32BitLiteral(int64_t Imm, OperandType Type, bool IsLit) {
31533153
switch (Type) {
31543154
default:
31553155
break;
@@ -3172,7 +3172,7 @@ int64_t encode32BitLiteral(int64_t Imm, OperandType Type) {
31723172
case OPERAND_REG_INLINE_C_INT32:
31733173
return Lo_32(Imm);
31743174
case OPERAND_REG_IMM_FP64:
3175-
return Hi_32(Imm);
3175+
return IsLit ? Imm : Hi_32(Imm);
31763176
}
31773177
return Imm;
31783178
}

‎llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1724,7 +1724,7 @@ LLVM_READNONE
17241724
bool isValid32BitLiteral(uint64_t Val, bool IsFP64);
17251725

17261726
LLVM_READNONE
1727-
int64_t encode32BitLiteral(int64_t Imm, OperandType Type);
1727+
int64_t encode32BitLiteral(int64_t Imm, OperandType Type, bool IsLit);
17281728

17291729
bool isArgPassedInSGPR(const Argument *Arg);
17301730

‎llvm/test/MC/AMDGPU/gfx1250_asm_salu_lit64.s‎

Lines changed: 28 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,64 +1,70 @@
1-
// RUN: llvm-mc -triple=amdgcn -show-encoding -mcpu=gfx1250 %s | FileCheck --check-prefix=GFX1250 %s
1+
// NOTE: Assertions have been autogenerated by utils/update_mc_test_checks.py UTC_ARGS: --version 5
2+
// RUN: llvm-mc -triple=amdgcn -show-encoding -mcpu=gfx1250 %s | FileCheck --check-prefixes=GFX1250,GFX1250-ASM %s
3+
// RUN: llvm-mc -triple=amdgcn -mcpu=gfx1250 -show-encoding %s | %extract-encodings | llvm-mc -triple=amdgcn -mcpu=gfx1250 -disassemble -show-encoding | FileCheck --check-prefixes=GFX1250,GFX1250-DIS %s
24

35
s_mov_b64 s[2:3], 0x10abcdef12345678
4-
// GFX1250: s_mov_b64 s[2:3], lit64(0x10abcdef12345678) ; encoding: [0xfe,0x01,0x82,0xbe,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
6+
// GFX1250: s_mov_b64 s[2:3], 0x10abcdef12345678 ; encoding: [0xfe,0x01,0x82,0xbe,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
57

68
s_add_nc_u64 s[2:3], s[4:5], 0x10abcdef12345678
7-
// GFX1250: s_add_nc_u64 s[2:3], s[4:5], lit64(0x10abcdef12345678) ; encoding: [0x04,0xfe,0x82,0xa9,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
9+
// GFX1250: s_add_nc_u64 s[2:3], s[4:5], 0x10abcdef12345678 ; encoding: [0x04,0xfe,0x82,0xa9,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
810

911
s_mul_u64 s[2:3], 0x10abcdef12345678, s[4:5]
10-
// GFX1250: s_mul_u64 s[2:3], lit64(0x10abcdef12345678), s[4:5] ; encoding: [0xfe,0x04,0x82,0xaa,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
12+
// GFX1250: s_mul_u64 s[2:3], 0x10abcdef12345678, s[4:5] ; encoding: [0xfe,0x04,0x82,0xaa,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
1113

1214
s_and_b64 s[2:3], 0x10abcdef12345678, s[4:5]
13-
// GFX1250: s_and_b64 s[2:3], lit64(0x10abcdef12345678), s[4:5] ; encoding: [0xfe,0x04,0x82,0x8b,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
15+
// GFX1250: s_and_b64 s[2:3], 0x10abcdef12345678, s[4:5] ; encoding: [0xfe,0x04,0x82,0x8b,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
1416

1517
s_or_b64 s[2:3], s[4:5], 0x10abcdef12345678
16-
// GFX1250: s_or_b64 s[2:3], s[4:5], lit64(0x10abcdef12345678) ; encoding: [0x04,0xfe,0x82,0x8c,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
18+
// GFX1250: s_or_b64 s[2:3], s[4:5], 0x10abcdef12345678 ; encoding: [0x04,0xfe,0x82,0x8c,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
1719

1820
s_xor_b64 s[2:3], 0x10abcdef12345678, s[4:5]
19-
// GFX1250: s_xor_b64 s[2:3], lit64(0x10abcdef12345678), s[4:5] ; encoding: [0xfe,0x04,0x82,0x8d,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
21+
// GFX1250: s_xor_b64 s[2:3], 0x10abcdef12345678, s[4:5] ; encoding: [0xfe,0x04,0x82,0x8d,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
2022

2123
s_and_not1_b64 s[2:3], 0x10abcdef12345678, 0x10abcdef12345678
22-
// GFX1250: s_and_not1_b64 s[2:3], lit64(0x10abcdef12345678), lit64(0x10abcdef12345678) ; encoding: [0xfe,0xfe,0x82,0x91,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
24+
// GFX1250: s_and_not1_b64 s[2:3], 0x10abcdef12345678, 0x10abcdef12345678 ; encoding: [0xfe,0xfe,0x82,0x91,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
2325

2426
s_or_not1_b64 s[2:3], s[4:5], 0x10abcdef12345678
25-
// GFX1250: s_or_not1_b64 s[2:3], s[4:5], lit64(0x10abcdef12345678) ; encoding: [0x04,0xfe,0x82,0x92,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
27+
// GFX1250: s_or_not1_b64 s[2:3], s[4:5], 0x10abcdef12345678 ; encoding: [0x04,0xfe,0x82,0x92,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
2628

2729
s_andn2_b64 s[2:3], 0x10abcdef12345678, s[4:5]
28-
// GFX1250: s_and_not1_b64 s[2:3], lit64(0x10abcdef12345678), s[4:5] ; encoding: [0xfe,0x04,0x82,0x91,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
30+
// GFX1250: s_and_not1_b64 s[2:3], 0x10abcdef12345678, s[4:5] ; encoding: [0xfe,0x04,0x82,0x91,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
2931

3032
s_orn2_b64 s[2:3], s[4:5], 0x10abcdef12345678
31-
// GFX1250: s_or_not1_b64 s[2:3], s[4:5], lit64(0x10abcdef12345678) ; encoding: [0x04,0xfe,0x82,0x92,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
33+
// GFX1250: s_or_not1_b64 s[2:3], s[4:5], 0x10abcdef12345678 ; encoding: [0x04,0xfe,0x82,0x92,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
3234

3335
s_nand_b64 s[2:3], s[4:5], 0x10abcdef12345678
34-
// GFX1250: s_nand_b64 s[2:3], s[4:5], lit64(0x10abcdef12345678) ; encoding: [0x04,0xfe,0x82,0x8e,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
36+
// GFX1250: s_nand_b64 s[2:3], s[4:5], 0x10abcdef12345678 ; encoding: [0x04,0xfe,0x82,0x8e,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
3537

3638
s_nor_b64 s[2:3], s[4:5], 0x10abcdef12345678
37-
// GFX1250: s_nor_b64 s[2:3], s[4:5], lit64(0x10abcdef12345678) ; encoding: [0x04,0xfe,0x82,0x8f,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
39+
// GFX1250: s_nor_b64 s[2:3], s[4:5], 0x10abcdef12345678 ; encoding: [0x04,0xfe,0x82,0x8f,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
3840

3941
s_xnor_b64 s[2:3], s[4:5], 0x10abcdef12345678
40-
// GFX1250: s_xnor_b64 s[2:3], s[4:5], lit64(0x10abcdef12345678) ; encoding: [0x04,0xfe,0x82,0x90,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
42+
// GFX1250: s_xnor_b64 s[2:3], s[4:5], 0x10abcdef12345678 ; encoding: [0x04,0xfe,0x82,0x90,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
4143

4244
s_lshl_b64 s[2:3], 0x10abcdef12345678, s4
43-
// GFX1250: s_lshl_b64 s[2:3], lit64(0x10abcdef12345678), s4 ; encoding: [0xfe,0x04,0x82,0x84,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
45+
// GFX1250: s_lshl_b64 s[2:3], 0x10abcdef12345678, s4 ; encoding: [0xfe,0x04,0x82,0x84,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
4446

4547
s_lshr_b64 s[2:3], 0x10abcdef12345678, s4
46-
// GFX1250: s_lshr_b64 s[2:3], lit64(0x10abcdef12345678), s4 ; encoding: [0xfe,0x04,0x82,0x85,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
48+
// GFX1250: s_lshr_b64 s[2:3], 0x10abcdef12345678, s4 ; encoding: [0xfe,0x04,0x82,0x85,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
4749

4850
s_ashr_i64 s[2:3], 0x10abcdef12345678, s4
49-
// GFX1250: s_ashr_i64 s[2:3], lit64(0x10abcdef12345678), s4 ; encoding: [0xfe,0x04,0x82,0x86,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
51+
// GFX1250: s_ashr_i64 s[2:3], 0x10abcdef12345678, s4 ; encoding: [0xfe,0x04,0x82,0x86,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
5052

5153
s_bfe_u64 s[2:3], 0x10abcdef12345678, 5
52-
// GFX1250: s_bfe_u64 s[2:3], lit64(0x10abcdef12345678), 5 ; encoding: [0xfe,0x85,0x02,0x94,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
54+
// GFX1250: s_bfe_u64 s[2:3], 0x10abcdef12345678, 5 ; encoding: [0xfe,0x85,0x02,0x94,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
5355

5456
s_bfe_i64 s[2:3], 0x80abcdef12345678, 5
55-
// GFX1250: s_bfe_i64 s[2:3], lit64(0x80abcdef12345678), 5 ; encoding: [0xfe,0x85,0x82,0x94,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x80]
57+
// GFX1250: s_bfe_i64 s[2:3], 0x80abcdef12345678, 5 ; encoding: [0xfe,0x85,0x82,0x94,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x80]
5658

5759
s_cselect_b64 s[2:3], s[4:5], 0x10abcdef12345678
58-
// GFX1250: s_cselect_b64 s[2:3], s[4:5], lit64(0x10abcdef12345678) ; encoding: [0x04,0xfe,0x82,0x98,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
60+
// GFX1250: s_cselect_b64 s[2:3], s[4:5], 0x10abcdef12345678 ; encoding: [0x04,0xfe,0x82,0x98,0x78,0x56,0x34,0x12,0xef,0xcd,0xab,0x10]
5961

6062
s_mov_b64 s[2:3], 0xffffffff01234567
61-
// GFX1250: s_mov_b64 s[2:3], lit64(0xffffffff01234567) ; encoding: [0xfe,0x01,0x82,0xbe,0x67,0x45,0x23,0x01,0xff,0xff,0xff,0xff]
63+
// GFX1250: s_mov_b64 s[2:3], 0xffffffff01234567 ; encoding: [0xfe,0x01,0x82,0xbe,0x67,0x45,0x23,0x01,0xff,0xff,0xff,0xff]
6264

6365
s_mov_b64 s[2:3], lit64(0x777)
64-
// GFX1250: s_mov_b64 s[2:3], 0x777 ; encoding: [0xff,0x01,0x82,0xbe,0x77,0x07,0x00,0x00]
66+
// GFX1250-ASM: s_mov_b64 s[2:3], lit64(0x777) ; encoding: [0xff,0x01,0x82,0xbe,0x77,0x07,0x00,0x00]
67+
// GFX1250-DIS: s_mov_b64 s[2:3], 0x777 ; encoding: [0xff,0x01,0x82,0xbe,0x77,0x07,0x00,0x00]
68+
69+
s_mov_b64 s[2:3], 0x777
70+
// GFX1250: s_mov_b64 s[2:3], 0x777 ; encoding: [0xff,0x01,0x82,0xbe,0x77,0x07,0x00,0x00]

0 commit comments

Comments
 (0)