2021-06-09 17:54:53 +02:00
|
|
|
/*
|
|
|
|
|
* Copyright © 2018 Valve Corporation
|
|
|
|
|
*
|
2024-04-08 09:02:30 +02:00
|
|
|
* SPDX-License-Identifier: MIT
|
2021-06-09 17:54:53 +02:00
|
|
|
*/
|
|
|
|
|
|
2019-09-17 13:22:17 +02:00
|
|
|
#include "aco_builder.h"
|
2021-06-09 15:40:03 +02:00
|
|
|
#include "aco_ir.h"
|
2019-09-17 13:22:17 +02:00
|
|
|
|
2021-06-10 11:33:15 +02:00
|
|
|
#include "common/ac_shader_util.h"
|
|
|
|
|
#include "common/sid.h"
|
2019-09-17 13:22:17 +02:00
|
|
|
|
2020-11-26 22:06:22 -08:00
|
|
|
#include <array>
|
|
|
|
|
|
2019-09-17 13:22:17 +02:00
|
|
|
namespace aco {
|
|
|
|
|
|
2024-06-15 16:17:29 +02:00
|
|
|
namespace {
|
|
|
|
|
|
2020-11-26 22:06:22 -08:00
|
|
|
const std::array<const char*, num_reduce_ops> reduce_ops = []()
|
|
|
|
|
{
|
|
|
|
|
std::array<const char*, num_reduce_ops> ret{};
|
|
|
|
|
ret[iadd8] = "iadd8";
|
|
|
|
|
ret[iadd16] = "iadd16";
|
|
|
|
|
ret[iadd32] = "iadd32";
|
|
|
|
|
ret[iadd64] = "iadd64";
|
|
|
|
|
ret[imul8] = "imul8";
|
|
|
|
|
ret[imul16] = "imul16";
|
|
|
|
|
ret[imul32] = "imul32";
|
|
|
|
|
ret[imul64] = "imul64";
|
|
|
|
|
ret[fadd16] = "fadd16";
|
|
|
|
|
ret[fadd32] = "fadd32";
|
|
|
|
|
ret[fadd64] = "fadd64";
|
|
|
|
|
ret[fmul16] = "fmul16";
|
|
|
|
|
ret[fmul32] = "fmul32";
|
|
|
|
|
ret[fmul64] = "fmul64";
|
|
|
|
|
ret[imin8] = "imin8";
|
|
|
|
|
ret[imin16] = "imin16";
|
|
|
|
|
ret[imin32] = "imin32";
|
|
|
|
|
ret[imin64] = "imin64";
|
|
|
|
|
ret[imax8] = "imax8";
|
|
|
|
|
ret[imax16] = "imax16";
|
|
|
|
|
ret[imax32] = "imax32";
|
|
|
|
|
ret[imax64] = "imax64";
|
|
|
|
|
ret[umin8] = "umin8";
|
|
|
|
|
ret[umin16] = "umin16";
|
|
|
|
|
ret[umin32] = "umin32";
|
|
|
|
|
ret[umin64] = "umin64";
|
|
|
|
|
ret[umax8] = "umax8";
|
|
|
|
|
ret[umax16] = "umax16";
|
|
|
|
|
ret[umax32] = "umax32";
|
|
|
|
|
ret[umax64] = "umax64";
|
|
|
|
|
ret[fmin16] = "fmin16";
|
|
|
|
|
ret[fmin32] = "fmin32";
|
|
|
|
|
ret[fmin64] = "fmin64";
|
|
|
|
|
ret[fmax16] = "fmax16";
|
|
|
|
|
ret[fmax32] = "fmax32";
|
|
|
|
|
ret[fmax64] = "fmax64";
|
|
|
|
|
ret[iand8] = "iand8";
|
|
|
|
|
ret[iand16] = "iand16";
|
|
|
|
|
ret[iand32] = "iand32";
|
|
|
|
|
ret[iand64] = "iand64";
|
|
|
|
|
ret[ior8] = "ior8";
|
|
|
|
|
ret[ior16] = "ior16";
|
|
|
|
|
ret[ior32] = "ior32";
|
|
|
|
|
ret[ior64] = "ior64";
|
|
|
|
|
ret[ixor8] = "ixor8";
|
|
|
|
|
ret[ixor16] = "ixor16";
|
|
|
|
|
ret[ixor32] = "ixor32";
|
|
|
|
|
ret[ixor64] = "ixor64";
|
|
|
|
|
return ret;
|
|
|
|
|
}();
|
2019-09-17 13:22:17 +02:00
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
print_reg_class(const RegClass rc, FILE* output)
|
|
|
|
|
{
|
2021-06-11 13:08:51 +01:00
|
|
|
if (rc.is_subdword()) {
|
|
|
|
|
fprintf(output, " v%ub: ", rc.bytes());
|
|
|
|
|
} else if (rc.type() == RegType::sgpr) {
|
|
|
|
|
fprintf(output, " s%u: ", rc.size());
|
|
|
|
|
} else if (rc.is_linear()) {
|
|
|
|
|
fprintf(output, " lv%u: ", rc.size());
|
|
|
|
|
} else {
|
|
|
|
|
fprintf(output, " v%u: ", rc.size());
|
2019-09-17 13:22:17 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-02-11 15:49:21 +00:00
|
|
|
void
|
|
|
|
|
print_physReg(PhysReg reg, unsigned bytes, FILE* output, unsigned flags)
|
2019-09-17 13:22:17 +02:00
|
|
|
{
|
2024-02-04 20:27:29 +01:00
|
|
|
if (reg == 106) {
|
|
|
|
|
fprintf(output, bytes > 4 ? "vcc" : "vcc_lo");
|
|
|
|
|
} else if (reg == 107) {
|
|
|
|
|
fprintf(output, "vcc_hi");
|
|
|
|
|
} else if (reg == 124) {
|
2021-02-11 15:49:21 +00:00
|
|
|
fprintf(output, "m0");
|
2022-07-21 15:13:46 +01:00
|
|
|
} else if (reg == 125) {
|
|
|
|
|
fprintf(output, "null");
|
2024-02-04 20:27:29 +01:00
|
|
|
} else if (reg == 126) {
|
|
|
|
|
fprintf(output, bytes > 4 ? "exec" : "exec_lo");
|
|
|
|
|
} else if (reg == 127) {
|
|
|
|
|
fprintf(output, "exec_hi");
|
|
|
|
|
} else if (reg == 253) {
|
|
|
|
|
fprintf(output, "scc");
|
2019-09-17 13:22:17 +02:00
|
|
|
} else {
|
|
|
|
|
bool is_vgpr = reg / 256;
|
2020-03-25 11:32:18 +01:00
|
|
|
unsigned r = reg % 256;
|
|
|
|
|
unsigned size = DIV_ROUND_UP(bytes, 4);
|
2021-02-11 15:49:21 +00:00
|
|
|
if (size == 1 && (flags & print_no_ssa)) {
|
|
|
|
|
fprintf(output, "%c%d", is_vgpr ? 'v' : 's', r);
|
|
|
|
|
} else {
|
|
|
|
|
fprintf(output, "%c[%d", is_vgpr ? 'v' : 's', r);
|
|
|
|
|
if (size > 1)
|
|
|
|
|
fprintf(output, "-%d]", r + size - 1);
|
|
|
|
|
else
|
|
|
|
|
fprintf(output, "]");
|
|
|
|
|
}
|
2020-03-25 11:32:18 +01:00
|
|
|
if (reg.byte() || bytes % 4)
|
|
|
|
|
fprintf(output, "[%d:%d]", reg.byte() * 8, (reg.byte() + bytes) * 8);
|
2019-09-17 13:22:17 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
print_constant(uint8_t reg, FILE* output)
|
|
|
|
|
{
|
|
|
|
|
if (reg >= 128 && reg <= 192) {
|
|
|
|
|
fprintf(output, "%d", reg - 128);
|
|
|
|
|
return;
|
|
|
|
|
} else if (reg >= 192 && reg <= 208) {
|
|
|
|
|
fprintf(output, "%d", 192 - reg);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (reg) {
|
|
|
|
|
case 240: fprintf(output, "0.5"); break;
|
|
|
|
|
case 241: fprintf(output, "-0.5"); break;
|
|
|
|
|
case 242: fprintf(output, "1.0"); break;
|
|
|
|
|
case 243: fprintf(output, "-1.0"); break;
|
|
|
|
|
case 244: fprintf(output, "2.0"); break;
|
|
|
|
|
case 245: fprintf(output, "-2.0"); break;
|
|
|
|
|
case 246: fprintf(output, "4.0"); break;
|
|
|
|
|
case 247: fprintf(output, "-4.0"); break;
|
|
|
|
|
case 248: fprintf(output, "1/(2*PI)"); break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-02-11 15:49:21 +00:00
|
|
|
static void
|
|
|
|
|
print_definition(const Definition* definition, FILE* output, unsigned flags)
|
2019-09-17 13:22:17 +02:00
|
|
|
{
|
2021-02-11 15:49:21 +00:00
|
|
|
if (!(flags & print_no_ssa))
|
|
|
|
|
print_reg_class(definition->regClass(), output);
|
2020-05-15 13:58:20 +01:00
|
|
|
if (definition->isPrecise())
|
|
|
|
|
fprintf(output, "(precise)");
|
2024-09-13 19:53:13 +02:00
|
|
|
if (definition->isInfPreserve() || definition->isNaNPreserve() || definition->isSZPreserve()) {
|
|
|
|
|
fprintf(output, "(");
|
|
|
|
|
if (definition->isSZPreserve())
|
|
|
|
|
fprintf(output, "Sz");
|
|
|
|
|
if (definition->isInfPreserve())
|
|
|
|
|
fprintf(output, "Inf");
|
|
|
|
|
if (definition->isNaNPreserve())
|
|
|
|
|
fprintf(output, "NaN");
|
|
|
|
|
fprintf(output, "Preserve)");
|
|
|
|
|
}
|
2019-10-15 17:25:57 +01:00
|
|
|
if (definition->isNUW())
|
|
|
|
|
fprintf(output, "(nuw)");
|
2020-11-23 12:51:15 +00:00
|
|
|
if (definition->isNoCSE())
|
|
|
|
|
fprintf(output, "(noCSE)");
|
2021-03-15 14:08:33 +00:00
|
|
|
if ((flags & print_kill) && definition->isKill())
|
|
|
|
|
fprintf(output, "(kill)");
|
2021-02-11 15:49:21 +00:00
|
|
|
if (!(flags & print_no_ssa))
|
|
|
|
|
fprintf(output, "%%%d%s", definition->tempId(), definition->isFixed() ? ":" : "");
|
2019-09-17 13:22:17 +02:00
|
|
|
|
|
|
|
|
if (definition->isFixed())
|
2021-02-11 15:49:21 +00:00
|
|
|
print_physReg(definition->physReg(), definition->bytes(), output, flags);
|
2019-09-17 13:22:17 +02:00
|
|
|
}
|
|
|
|
|
|
2020-06-26 15:54:22 +01:00
|
|
|
static void
|
|
|
|
|
print_storage(storage_class storage, FILE* output)
|
2019-09-17 13:22:17 +02:00
|
|
|
{
|
2020-06-26 15:54:22 +01:00
|
|
|
fprintf(output, " storage:");
|
|
|
|
|
int printed = 0;
|
|
|
|
|
if (storage & storage_buffer)
|
|
|
|
|
printed += fprintf(output, "%sbuffer", printed ? "," : "");
|
2022-10-27 14:49:31 +01:00
|
|
|
if (storage & storage_gds)
|
|
|
|
|
printed += fprintf(output, "%sgds", printed ? "," : "");
|
2020-06-26 15:54:22 +01:00
|
|
|
if (storage & storage_image)
|
|
|
|
|
printed += fprintf(output, "%simage", printed ? "," : "");
|
|
|
|
|
if (storage & storage_shared)
|
|
|
|
|
printed += fprintf(output, "%sshared", printed ? "," : "");
|
2022-02-25 09:22:04 +01:00
|
|
|
if (storage & storage_task_payload)
|
|
|
|
|
printed += fprintf(output, "%stask_payload", printed ? "," : "");
|
2020-06-26 15:54:22 +01:00
|
|
|
if (storage & storage_vmem_output)
|
|
|
|
|
printed += fprintf(output, "%svmem_output", printed ? "," : "");
|
|
|
|
|
if (storage & storage_scratch)
|
|
|
|
|
printed += fprintf(output, "%sscratch", printed ? "," : "");
|
|
|
|
|
if (storage & storage_vgpr_spill)
|
|
|
|
|
printed += fprintf(output, "%svgpr_spill", printed ? "," : "");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
print_semantics(memory_semantics sem, FILE* output)
|
|
|
|
|
{
|
|
|
|
|
fprintf(output, " semantics:");
|
|
|
|
|
int printed = 0;
|
|
|
|
|
if (sem & semantic_acquire)
|
|
|
|
|
printed += fprintf(output, "%sacquire", printed ? "," : "");
|
|
|
|
|
if (sem & semantic_release)
|
|
|
|
|
printed += fprintf(output, "%srelease", printed ? "," : "");
|
|
|
|
|
if (sem & semantic_volatile)
|
|
|
|
|
printed += fprintf(output, "%svolatile", printed ? "," : "");
|
|
|
|
|
if (sem & semantic_private)
|
|
|
|
|
printed += fprintf(output, "%sprivate", printed ? "," : "");
|
|
|
|
|
if (sem & semantic_can_reorder)
|
|
|
|
|
printed += fprintf(output, "%sreorder", printed ? "," : "");
|
|
|
|
|
if (sem & semantic_atomic)
|
|
|
|
|
printed += fprintf(output, "%satomic", printed ? "," : "");
|
|
|
|
|
if (sem & semantic_rmw)
|
|
|
|
|
printed += fprintf(output, "%srmw", printed ? "," : "");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
print_scope(sync_scope scope, FILE* output, const char* prefix = "scope")
|
|
|
|
|
{
|
|
|
|
|
fprintf(output, " %s:", prefix);
|
|
|
|
|
switch (scope) {
|
|
|
|
|
case scope_invocation: fprintf(output, "invocation"); break;
|
|
|
|
|
case scope_subgroup: fprintf(output, "subgroup"); break;
|
|
|
|
|
case scope_workgroup: fprintf(output, "workgroup"); break;
|
|
|
|
|
case scope_queuefamily: fprintf(output, "queuefamily"); break;
|
|
|
|
|
case scope_device: fprintf(output, "device"); break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-09-17 13:22:17 +02:00
|
|
|
|
2020-06-26 15:54:22 +01:00
|
|
|
static void
|
|
|
|
|
print_sync(memory_sync_info sync, FILE* output)
|
|
|
|
|
{
|
2022-07-18 20:44:21 +01:00
|
|
|
if (sync.storage)
|
|
|
|
|
print_storage(sync.storage, output);
|
|
|
|
|
if (sync.semantics)
|
|
|
|
|
print_semantics(sync.semantics, output);
|
|
|
|
|
if (sync.scope != scope_invocation)
|
|
|
|
|
print_scope(sync.scope, output);
|
2019-09-17 13:22:17 +02:00
|
|
|
}
|
|
|
|
|
|
2024-05-14 18:34:01 +01:00
|
|
|
template <typename T>
|
|
|
|
|
static void
|
|
|
|
|
print_cache_flags(enum amd_gfx_level gfx_level, const T& instr, FILE* output)
|
|
|
|
|
{
|
2024-06-07 13:46:11 +01:00
|
|
|
if (gfx_level >= GFX12) {
|
|
|
|
|
if (instr_info.is_atomic[(unsigned)instr.opcode]) {
|
|
|
|
|
if (instr.cache.gfx12.temporal_hint & gfx12_atomic_return)
|
|
|
|
|
fprintf(output, " atomic_return");
|
|
|
|
|
if (instr.cache.gfx12.temporal_hint & gfx12_atomic_non_temporal)
|
|
|
|
|
fprintf(output, " non_temporal");
|
|
|
|
|
if (instr.cache.gfx12.temporal_hint & gfx12_atomic_accum_deferred_scope)
|
|
|
|
|
fprintf(output, " accum_deferred_scope");
|
2025-03-04 17:30:14 +00:00
|
|
|
} else if (!instr.definitions.empty()) {
|
2024-06-07 13:46:11 +01:00
|
|
|
switch (instr.cache.gfx12.temporal_hint) {
|
|
|
|
|
case gfx12_load_regular_temporal: break;
|
|
|
|
|
case gfx12_load_non_temporal: fprintf(output, " non_temporal"); break;
|
|
|
|
|
case gfx12_load_high_temporal: fprintf(output, " high_temporal"); break;
|
|
|
|
|
case gfx12_load_last_use_discard: fprintf(output, " last_use_discard"); break;
|
|
|
|
|
case gfx12_load_near_non_temporal_far_regular_temporal:
|
|
|
|
|
fprintf(output, " near_non_temporal_far_regular_temporal");
|
|
|
|
|
break;
|
|
|
|
|
case gfx12_load_near_regular_temporal_far_non_temporal:
|
|
|
|
|
fprintf(output, " near_regular_temporal_far_non_temporal");
|
|
|
|
|
break;
|
|
|
|
|
case gfx12_load_near_non_temporal_far_high_temporal:
|
|
|
|
|
fprintf(output, " near_non_temporal_far_high_temporal");
|
|
|
|
|
break;
|
|
|
|
|
case gfx12_load_reserved: fprintf(output, " reserved"); break;
|
|
|
|
|
default: fprintf(output, "tmp:%u", (unsigned)instr.cache.gfx12.temporal_hint);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
switch (instr.cache.gfx12.temporal_hint) {
|
|
|
|
|
case gfx12_store_regular_temporal: break;
|
|
|
|
|
case gfx12_store_non_temporal: fprintf(output, " non_temporal"); break;
|
|
|
|
|
case gfx12_store_high_temporal: fprintf(output, " high_temporal"); break;
|
|
|
|
|
case gfx12_store_high_temporal_stay_dirty:
|
|
|
|
|
fprintf(output, " high_temporal_stay_dirty");
|
|
|
|
|
break;
|
|
|
|
|
case gfx12_store_near_non_temporal_far_regular_temporal:
|
|
|
|
|
fprintf(output, " near_non_temporal_far_regular_temporal");
|
|
|
|
|
break;
|
|
|
|
|
case gfx12_store_near_regular_temporal_far_non_temporal:
|
|
|
|
|
fprintf(output, " near_regular_temporal_far_non_temporal");
|
|
|
|
|
break;
|
|
|
|
|
case gfx12_store_near_non_temporal_far_high_temporal:
|
|
|
|
|
fprintf(output, " near_non_temporal_far_high_temporal");
|
|
|
|
|
break;
|
|
|
|
|
case gfx12_store_near_non_temporal_far_writeback:
|
|
|
|
|
fprintf(output, " near_non_temporal_far_writeback");
|
|
|
|
|
break;
|
|
|
|
|
default: fprintf(output, "tmp:%u", (unsigned)instr.cache.gfx12.temporal_hint);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
switch (instr.cache.gfx12.scope) {
|
|
|
|
|
case gfx12_scope_cu: break;
|
|
|
|
|
case gfx12_scope_se: fprintf(output, " se"); break;
|
|
|
|
|
case gfx12_scope_device: fprintf(output, " device"); break;
|
|
|
|
|
case gfx12_scope_memory: fprintf(output, " memory"); break;
|
|
|
|
|
}
|
|
|
|
|
if (instr.cache.gfx12.swizzled)
|
|
|
|
|
fprintf(output, " swizzled");
|
|
|
|
|
} else {
|
|
|
|
|
if (instr.cache.value & ac_glc)
|
|
|
|
|
fprintf(output, " glc");
|
|
|
|
|
if (instr.cache.value & ac_slc)
|
|
|
|
|
fprintf(output, " slc");
|
|
|
|
|
if (instr.cache.value & ac_dlc)
|
|
|
|
|
fprintf(output, " dlc");
|
|
|
|
|
if (instr.cache.value & ac_swizzled)
|
|
|
|
|
fprintf(output, " swizzled");
|
|
|
|
|
}
|
2024-05-14 18:34:01 +01:00
|
|
|
}
|
|
|
|
|
|
2020-04-23 15:24:47 +02:00
|
|
|
static void
|
2022-07-21 15:17:24 +01:00
|
|
|
print_instr_format_specific(enum amd_gfx_level gfx_level, const Instruction* instr, FILE* output)
|
2019-09-17 13:22:17 +02:00
|
|
|
{
|
|
|
|
|
switch (instr->format) {
|
|
|
|
|
case Format::SOPK: {
|
2024-03-19 15:46:56 +01:00
|
|
|
const SALU_instruction& sopk = instr->salu();
|
2021-01-21 16:13:34 +00:00
|
|
|
fprintf(output, " imm:%d", sopk.imm & 0x8000 ? (sopk.imm - 65536) : sopk.imm);
|
2019-09-17 13:22:17 +02:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case Format::SOPP: {
|
2024-03-19 15:46:56 +01:00
|
|
|
uint16_t imm = instr->salu().imm;
|
2019-09-17 13:22:17 +02:00
|
|
|
switch (instr->opcode) {
|
2024-05-03 12:02:21 +01:00
|
|
|
case aco_opcode::s_waitcnt:
|
|
|
|
|
case aco_opcode::s_wait_loadcnt_dscnt:
|
|
|
|
|
case aco_opcode::s_wait_storecnt_dscnt: {
|
2024-05-03 11:19:57 +01:00
|
|
|
wait_imm unpacked;
|
|
|
|
|
unpacked.unpack(gfx_level, instr);
|
|
|
|
|
const char* names[wait_type_num];
|
|
|
|
|
names[wait_type_exp] = "expcnt";
|
2024-05-03 12:02:21 +01:00
|
|
|
names[wait_type_vm] = gfx_level >= GFX12 ? "loadcnt" : "vmcnt";
|
|
|
|
|
names[wait_type_lgkm] = gfx_level >= GFX12 ? "dscnt" : "lgkmcnt";
|
|
|
|
|
names[wait_type_vs] = gfx_level >= GFX12 ? "storecnt" : "vscnt";
|
|
|
|
|
names[wait_type_sample] = "samplecnt";
|
|
|
|
|
names[wait_type_bvh] = "bvhcnt";
|
|
|
|
|
names[wait_type_km] = "kmcnt";
|
2024-05-03 11:19:57 +01:00
|
|
|
for (unsigned i = 0; i < wait_type_num; i++) {
|
|
|
|
|
if (unpacked[i] != wait_imm::unset_counter)
|
|
|
|
|
fprintf(output, " %s(%d)", names[i], unpacked[i]);
|
|
|
|
|
}
|
2019-09-17 13:22:17 +02:00
|
|
|
break;
|
|
|
|
|
}
|
2024-05-03 12:02:21 +01:00
|
|
|
case aco_opcode::s_wait_expcnt:
|
|
|
|
|
case aco_opcode::s_wait_dscnt:
|
|
|
|
|
case aco_opcode::s_wait_loadcnt:
|
|
|
|
|
case aco_opcode::s_wait_storecnt:
|
|
|
|
|
case aco_opcode::s_wait_samplecnt:
|
|
|
|
|
case aco_opcode::s_wait_bvhcnt:
|
2024-07-17 16:57:35 +01:00
|
|
|
case aco_opcode::s_wait_kmcnt:
|
|
|
|
|
case aco_opcode::s_setprio: {
|
2024-05-03 12:02:21 +01:00
|
|
|
fprintf(output, " imm:%u", imm);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2022-07-21 15:13:57 +01:00
|
|
|
case aco_opcode::s_waitcnt_depctr: {
|
2024-10-03 18:29:03 +02:00
|
|
|
depctr_wait wait = parse_depctr_wait(instr);
|
|
|
|
|
if (wait.va_vdst != 0xf)
|
|
|
|
|
fprintf(output, " va_vdst(%d)", wait.va_vdst);
|
|
|
|
|
if (wait.va_sdst != 0x7)
|
|
|
|
|
fprintf(output, " va_sdst(%d)", wait.va_sdst);
|
|
|
|
|
if (wait.va_ssrc != 0x1)
|
|
|
|
|
fprintf(output, " va_ssrc(%d)", wait.va_ssrc);
|
|
|
|
|
if (wait.hold_cnt != 0x1)
|
|
|
|
|
fprintf(output, " holt_cnt(%d)", wait.hold_cnt);
|
|
|
|
|
if (wait.vm_vsrc != 0x7)
|
|
|
|
|
fprintf(output, " vm_vsrc(%d)", wait.vm_vsrc);
|
|
|
|
|
if (wait.va_vcc != 0x1)
|
|
|
|
|
fprintf(output, " va_vcc(%d)", wait.va_vcc);
|
|
|
|
|
if (wait.sa_sdst != 0x1)
|
|
|
|
|
fprintf(output, " sa_sdst(%d)", wait.sa_sdst);
|
2022-07-21 15:13:57 +01:00
|
|
|
break;
|
|
|
|
|
}
|
2023-05-24 16:24:35 +01:00
|
|
|
case aco_opcode::s_delay_alu: {
|
|
|
|
|
unsigned delay[2] = {imm & 0xfu, (imm >> 7) & 0xfu};
|
2024-07-28 22:02:00 +02:00
|
|
|
unsigned skip = (imm >> 4) & 0x7;
|
2023-05-24 16:24:35 +01:00
|
|
|
for (unsigned i = 0; i < 2; i++) {
|
|
|
|
|
if (i == 1 && skip) {
|
|
|
|
|
if (skip == 1)
|
|
|
|
|
fprintf(output, " next");
|
|
|
|
|
else
|
|
|
|
|
fprintf(output, " skip_%u", skip - 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
alu_delay_wait wait = (alu_delay_wait)delay[i];
|
|
|
|
|
if (wait >= alu_delay_wait::VALU_DEP_1 && wait <= alu_delay_wait::VALU_DEP_4)
|
|
|
|
|
fprintf(output, " valu_dep_%u", delay[i]);
|
|
|
|
|
else if (wait >= alu_delay_wait::TRANS32_DEP_1 && wait <= alu_delay_wait::TRANS32_DEP_3)
|
|
|
|
|
fprintf(output, " trans32_dep_%u",
|
|
|
|
|
delay[i] - (unsigned)alu_delay_wait::TRANS32_DEP_1 + 1);
|
|
|
|
|
else if (wait == alu_delay_wait::FMA_ACCUM_CYCLE_1)
|
|
|
|
|
fprintf(output, " fma_accum_cycle_1");
|
|
|
|
|
else if (wait >= alu_delay_wait::SALU_CYCLE_1 && wait <= alu_delay_wait::SALU_CYCLE_3)
|
|
|
|
|
fprintf(output, " salu_cycle_%u",
|
|
|
|
|
delay[i] - (unsigned)alu_delay_wait::SALU_CYCLE_1 + 1);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
2019-09-17 13:22:17 +02:00
|
|
|
case aco_opcode::s_endpgm:
|
|
|
|
|
case aco_opcode::s_endpgm_saved:
|
|
|
|
|
case aco_opcode::s_endpgm_ordered_ps_done:
|
|
|
|
|
case aco_opcode::s_wakeup:
|
|
|
|
|
case aco_opcode::s_barrier:
|
|
|
|
|
case aco_opcode::s_icache_inv:
|
|
|
|
|
case aco_opcode::s_ttracedata:
|
|
|
|
|
case aco_opcode::s_set_gpr_idx_off: {
|
|
|
|
|
break;
|
|
|
|
|
}
|
2019-10-14 17:21:04 +01:00
|
|
|
case aco_opcode::s_sendmsg: {
|
2022-10-25 13:17:34 +02:00
|
|
|
unsigned id = imm & sendmsg_id_mask;
|
2023-04-25 18:40:18 +02:00
|
|
|
static_assert(sendmsg_gs == sendmsg_hs_tessfactor);
|
|
|
|
|
static_assert(sendmsg_gs_done == sendmsg_dealloc_vgprs);
|
2019-10-14 17:21:04 +01:00
|
|
|
switch (id) {
|
|
|
|
|
case sendmsg_none: fprintf(output, " sendmsg(MSG_NONE)"); break;
|
2023-04-25 18:40:18 +02:00
|
|
|
case sendmsg_gs:
|
2022-07-21 15:45:11 +01:00
|
|
|
if (gfx_level >= GFX11)
|
|
|
|
|
fprintf(output, " sendmsg(hs_tessfactor)");
|
|
|
|
|
else
|
|
|
|
|
fprintf(output, " sendmsg(gs%s%s, %u)", imm & 0x10 ? ", cut" : "",
|
|
|
|
|
imm & 0x20 ? ", emit" : "", imm >> 8);
|
2019-10-14 17:21:04 +01:00
|
|
|
break;
|
2023-04-25 18:40:18 +02:00
|
|
|
case sendmsg_gs_done:
|
2022-07-21 15:45:11 +01:00
|
|
|
if (gfx_level >= GFX11)
|
|
|
|
|
fprintf(output, " sendmsg(dealloc_vgprs)");
|
|
|
|
|
else
|
|
|
|
|
fprintf(output, " sendmsg(gs_done%s%s, %u)", imm & 0x10 ? ", cut" : "",
|
|
|
|
|
imm & 0x20 ? ", emit" : "", imm >> 8);
|
2019-10-14 17:21:04 +01:00
|
|
|
break;
|
|
|
|
|
case sendmsg_save_wave: fprintf(output, " sendmsg(save_wave)"); break;
|
|
|
|
|
case sendmsg_stall_wave_gen: fprintf(output, " sendmsg(stall_wave_gen)"); break;
|
|
|
|
|
case sendmsg_halt_waves: fprintf(output, " sendmsg(halt_waves)"); break;
|
|
|
|
|
case sendmsg_ordered_ps_done: fprintf(output, " sendmsg(ordered_ps_done)"); break;
|
|
|
|
|
case sendmsg_early_prim_dealloc: fprintf(output, " sendmsg(early_prim_dealloc)"); break;
|
|
|
|
|
case sendmsg_gs_alloc_req: fprintf(output, " sendmsg(gs_alloc_req)"); break;
|
2022-07-21 15:45:11 +01:00
|
|
|
case sendmsg_get_doorbell: fprintf(output, " sendmsg(get_doorbell)"); break;
|
|
|
|
|
case sendmsg_get_ddid: fprintf(output, " sendmsg(get_ddid)"); break;
|
|
|
|
|
default: fprintf(output, " imm:%u", imm);
|
2019-10-14 17:21:04 +01:00
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
2023-04-03 21:09:34 +03:00
|
|
|
case aco_opcode::s_wait_event: {
|
2024-05-27 14:23:38 +01:00
|
|
|
if (is_wait_export_ready(gfx_level, instr))
|
|
|
|
|
fprintf(output, " wait_export_ready");
|
2023-04-03 21:09:34 +03:00
|
|
|
break;
|
|
|
|
|
}
|
2019-09-17 13:22:17 +02:00
|
|
|
default: {
|
2024-03-19 15:21:00 +01:00
|
|
|
if (instr_info.classes[(int)instr->opcode] == instr_class::branch)
|
2024-03-19 15:46:56 +01:00
|
|
|
fprintf(output, " block:BB%d", imm);
|
2024-03-19 15:21:00 +01:00
|
|
|
else if (imm)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " imm:%u", imm);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
2022-10-25 13:17:34 +02:00
|
|
|
case Format::SOP1: {
|
|
|
|
|
if (instr->opcode == aco_opcode::s_sendmsg_rtn_b32 ||
|
|
|
|
|
instr->opcode == aco_opcode::s_sendmsg_rtn_b64) {
|
|
|
|
|
unsigned id = instr->operands[0].constantValue();
|
|
|
|
|
switch (id) {
|
|
|
|
|
case sendmsg_rtn_get_doorbell: fprintf(output, " sendmsg(rtn_get_doorbell)"); break;
|
|
|
|
|
case sendmsg_rtn_get_ddid: fprintf(output, " sendmsg(rtn_get_ddid)"); break;
|
|
|
|
|
case sendmsg_rtn_get_tma: fprintf(output, " sendmsg(rtn_get_tma)"); break;
|
|
|
|
|
case sendmsg_rtn_get_realtime: fprintf(output, " sendmsg(rtn_get_realtime)"); break;
|
|
|
|
|
case sendmsg_rtn_save_wave: fprintf(output, " sendmsg(rtn_save_wave)"); break;
|
|
|
|
|
case sendmsg_rtn_get_tba: fprintf(output, " sendmsg(rtn_get_tba)"); break;
|
|
|
|
|
default: break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
2019-09-17 13:22:17 +02:00
|
|
|
case Format::SMEM: {
|
2021-01-21 16:13:34 +00:00
|
|
|
const SMEM_instruction& smem = instr->smem();
|
2024-05-14 18:34:01 +01:00
|
|
|
print_cache_flags(gfx_level, smem, output);
|
2021-01-21 16:13:34 +00:00
|
|
|
print_sync(smem.sync, output);
|
2019-09-17 13:22:17 +02:00
|
|
|
break;
|
|
|
|
|
}
|
2022-06-17 13:53:08 +01:00
|
|
|
case Format::VINTERP_INREG: {
|
|
|
|
|
const VINTERP_inreg_instruction& vinterp = instr->vinterp_inreg();
|
|
|
|
|
if (vinterp.wait_exp != 7)
|
|
|
|
|
fprintf(output, " wait_exp:%u", vinterp.wait_exp);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2019-09-17 13:22:17 +02:00
|
|
|
case Format::VINTRP: {
|
2022-09-14 11:19:30 +01:00
|
|
|
const VINTRP_instruction& vintrp = instr->vintrp();
|
2021-01-21 16:13:34 +00:00
|
|
|
fprintf(output, " attr%d.%c", vintrp.attribute, "xyzw"[vintrp.component]);
|
2024-03-27 18:02:08 +01:00
|
|
|
if (vintrp.high_16bits)
|
|
|
|
|
fprintf(output, " high");
|
2019-09-17 13:22:17 +02:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case Format::DS: {
|
2021-01-21 16:13:34 +00:00
|
|
|
const DS_instruction& ds = instr->ds();
|
|
|
|
|
if (ds.offset0)
|
|
|
|
|
fprintf(output, " offset0:%u", ds.offset0);
|
|
|
|
|
if (ds.offset1)
|
|
|
|
|
fprintf(output, " offset1:%u", ds.offset1);
|
|
|
|
|
if (ds.gds)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " gds");
|
2021-01-21 16:13:34 +00:00
|
|
|
print_sync(ds.sync, output);
|
2019-09-17 13:22:17 +02:00
|
|
|
break;
|
|
|
|
|
}
|
2022-06-17 13:53:08 +01:00
|
|
|
case Format::LDSDIR: {
|
|
|
|
|
const LDSDIR_instruction& ldsdir = instr->ldsdir();
|
|
|
|
|
if (instr->opcode == aco_opcode::lds_param_load)
|
|
|
|
|
fprintf(output, " attr%u.%c", ldsdir.attr, "xyzw"[ldsdir.attr_chan]);
|
|
|
|
|
if (ldsdir.wait_vdst != 15)
|
|
|
|
|
fprintf(output, " wait_vdst:%u", ldsdir.wait_vdst);
|
2024-05-01 19:43:01 +01:00
|
|
|
if (ldsdir.wait_vsrc != 1)
|
|
|
|
|
fprintf(output, " wait_vsrc:%u", ldsdir.wait_vsrc);
|
2022-06-17 13:53:08 +01:00
|
|
|
print_sync(ldsdir.sync, output);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2019-09-17 13:22:17 +02:00
|
|
|
case Format::MUBUF: {
|
2021-01-21 16:13:34 +00:00
|
|
|
const MUBUF_instruction& mubuf = instr->mubuf();
|
|
|
|
|
if (mubuf.offset)
|
|
|
|
|
fprintf(output, " offset:%u", mubuf.offset);
|
|
|
|
|
if (mubuf.offen)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " offen");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mubuf.idxen)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " idxen");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mubuf.addr64)
|
2020-01-16 17:02:44 +01:00
|
|
|
fprintf(output, " addr64");
|
2024-05-14 18:34:01 +01:00
|
|
|
print_cache_flags(gfx_level, mubuf, output);
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mubuf.tfe)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " tfe");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mubuf.lds)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " lds");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mubuf.disable_wqm)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " disable_wqm");
|
2021-01-21 16:13:34 +00:00
|
|
|
print_sync(mubuf.sync, output);
|
2019-09-17 13:22:17 +02:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case Format::MIMG: {
|
2021-01-21 16:13:34 +00:00
|
|
|
const MIMG_instruction& mimg = instr->mimg();
|
2024-08-08 15:17:25 +01:00
|
|
|
unsigned identity_dmask = 0xf;
|
|
|
|
|
if (!instr->definitions.empty()) {
|
|
|
|
|
unsigned num_channels = instr->definitions[0].bytes() / (mimg.d16 ? 2 : 4);
|
|
|
|
|
identity_dmask = (1 << num_channels) - 1;
|
|
|
|
|
}
|
2021-01-21 16:13:34 +00:00
|
|
|
if ((mimg.dmask & identity_dmask) != identity_dmask)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " dmask:%s%s%s%s", mimg.dmask & 0x1 ? "x" : "",
|
2021-01-21 16:13:34 +00:00
|
|
|
mimg.dmask & 0x2 ? "y" : "", mimg.dmask & 0x4 ? "z" : "",
|
|
|
|
|
mimg.dmask & 0x8 ? "w" : "");
|
|
|
|
|
switch (mimg.dim) {
|
2019-10-10 12:17:04 +01:00
|
|
|
case ac_image_1d: fprintf(output, " 1d"); break;
|
|
|
|
|
case ac_image_2d: fprintf(output, " 2d"); break;
|
|
|
|
|
case ac_image_3d: fprintf(output, " 3d"); break;
|
|
|
|
|
case ac_image_cube: fprintf(output, " cube"); break;
|
|
|
|
|
case ac_image_1darray: fprintf(output, " 1darray"); break;
|
|
|
|
|
case ac_image_2darray: fprintf(output, " 2darray"); break;
|
|
|
|
|
case ac_image_2dmsaa: fprintf(output, " 2dmsaa"); break;
|
|
|
|
|
case ac_image_2darraymsaa: fprintf(output, " 2darraymsaa"); break;
|
|
|
|
|
}
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mimg.unrm)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " unrm");
|
2024-05-14 18:34:01 +01:00
|
|
|
print_cache_flags(gfx_level, mimg, output);
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mimg.tfe)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " tfe");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mimg.da)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " da");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mimg.lwe)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " lwe");
|
2022-06-10 14:44:58 +02:00
|
|
|
if (mimg.r128)
|
|
|
|
|
fprintf(output, " r128");
|
|
|
|
|
if (mimg.a16)
|
|
|
|
|
fprintf(output, " a16");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mimg.d16)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " d16");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mimg.disable_wqm)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " disable_wqm");
|
2021-01-21 16:13:34 +00:00
|
|
|
print_sync(mimg.sync, output);
|
2019-09-17 13:22:17 +02:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case Format::EXP: {
|
2021-01-21 16:13:34 +00:00
|
|
|
const Export_instruction& exp = instr->exp();
|
|
|
|
|
unsigned identity_mask = exp.compressed ? 0x5 : 0xf;
|
|
|
|
|
if ((exp.enabled_mask & identity_mask) != identity_mask)
|
|
|
|
|
fprintf(output, " en:%c%c%c%c", exp.enabled_mask & 0x1 ? 'r' : '*',
|
|
|
|
|
exp.enabled_mask & 0x2 ? 'g' : '*', exp.enabled_mask & 0x4 ? 'b' : '*',
|
|
|
|
|
exp.enabled_mask & 0x8 ? 'a' : '*');
|
|
|
|
|
if (exp.compressed)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " compr");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (exp.done)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " done");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (exp.valid_mask)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " vm");
|
|
|
|
|
|
2021-01-21 16:13:34 +00:00
|
|
|
if (exp.dest <= V_008DFC_SQ_EXP_MRT + 7)
|
|
|
|
|
fprintf(output, " mrt%d", exp.dest - V_008DFC_SQ_EXP_MRT);
|
|
|
|
|
else if (exp.dest == V_008DFC_SQ_EXP_MRTZ)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " mrtz");
|
2021-01-21 16:13:34 +00:00
|
|
|
else if (exp.dest == V_008DFC_SQ_EXP_NULL)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " null");
|
2021-01-21 16:13:34 +00:00
|
|
|
else if (exp.dest >= V_008DFC_SQ_EXP_POS && exp.dest <= V_008DFC_SQ_EXP_POS + 3)
|
|
|
|
|
fprintf(output, " pos%d", exp.dest - V_008DFC_SQ_EXP_POS);
|
|
|
|
|
else if (exp.dest >= V_008DFC_SQ_EXP_PARAM && exp.dest <= V_008DFC_SQ_EXP_PARAM + 31)
|
|
|
|
|
fprintf(output, " param%d", exp.dest - V_008DFC_SQ_EXP_PARAM);
|
2019-09-17 13:22:17 +02:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case Format::PSEUDO_BRANCH: {
|
2021-01-21 16:13:34 +00:00
|
|
|
const Pseudo_branch_instruction& branch = instr->branch();
|
2019-09-17 13:22:17 +02:00
|
|
|
/* Note: BB0 cannot be a branch target */
|
2021-01-21 16:13:34 +00:00
|
|
|
if (branch.target[0] != 0)
|
|
|
|
|
fprintf(output, " BB%d", branch.target[0]);
|
|
|
|
|
if (branch.target[1] != 0)
|
|
|
|
|
fprintf(output, ", BB%d", branch.target[1]);
|
2024-07-12 19:36:07 +01:00
|
|
|
if (branch.rarely_taken)
|
|
|
|
|
fprintf(output, " rarely_taken");
|
|
|
|
|
if (branch.never_taken)
|
|
|
|
|
fprintf(output, " never_taken");
|
2019-09-17 13:22:17 +02:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case Format::PSEUDO_REDUCTION: {
|
2021-01-21 16:13:34 +00:00
|
|
|
const Pseudo_reduction_instruction& reduce = instr->reduction();
|
|
|
|
|
fprintf(output, " op:%s", reduce_ops[reduce.reduce_op]);
|
|
|
|
|
if (reduce.cluster_size)
|
|
|
|
|
fprintf(output, " cluster_size:%u", reduce.cluster_size);
|
2019-09-17 13:22:17 +02:00
|
|
|
break;
|
|
|
|
|
}
|
2020-06-26 15:54:22 +01:00
|
|
|
case Format::PSEUDO_BARRIER: {
|
2021-01-21 16:13:34 +00:00
|
|
|
const Pseudo_barrier_instruction& barrier = instr->barrier();
|
|
|
|
|
print_sync(barrier.sync, output);
|
|
|
|
|
print_scope(barrier.exec_scope, output, "exec_scope");
|
2020-06-26 15:54:22 +01:00
|
|
|
break;
|
|
|
|
|
}
|
2019-09-17 13:22:17 +02:00
|
|
|
case Format::FLAT:
|
|
|
|
|
case Format::GLOBAL:
|
|
|
|
|
case Format::SCRATCH: {
|
2021-01-21 16:13:34 +00:00
|
|
|
const FLAT_instruction& flat = instr->flatlike();
|
|
|
|
|
if (flat.offset)
|
2022-05-19 15:18:36 +01:00
|
|
|
fprintf(output, " offset:%d", flat.offset);
|
2024-05-14 18:34:01 +01:00
|
|
|
print_cache_flags(gfx_level, flat, output);
|
2021-01-21 16:13:34 +00:00
|
|
|
if (flat.lds)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " lds");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (flat.nv)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " nv");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (flat.disable_wqm)
|
2019-11-27 17:15:54 +00:00
|
|
|
fprintf(output, " disable_wqm");
|
2025-06-26 14:15:50 +01:00
|
|
|
if (flat.may_use_lds)
|
|
|
|
|
fprintf(output, " may_use_lds");
|
2021-01-21 16:13:34 +00:00
|
|
|
print_sync(flat.sync, output);
|
2019-09-17 13:22:17 +02:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case Format::MTBUF: {
|
2021-01-21 16:13:34 +00:00
|
|
|
const MTBUF_instruction& mtbuf = instr->mtbuf();
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " dfmt:");
|
2021-01-21 16:13:34 +00:00
|
|
|
switch (mtbuf.dfmt) {
|
2019-09-17 13:22:17 +02:00
|
|
|
case V_008F0C_BUF_DATA_FORMAT_8: fprintf(output, "8"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_16: fprintf(output, "16"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_8_8: fprintf(output, "8_8"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_32: fprintf(output, "32"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_16_16: fprintf(output, "16_16"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_10_11_11: fprintf(output, "10_11_11"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_11_11_10: fprintf(output, "11_11_10"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_10_10_10_2: fprintf(output, "10_10_10_2"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_2_10_10_10: fprintf(output, "2_10_10_10"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_8_8_8_8: fprintf(output, "8_8_8_8"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_32_32: fprintf(output, "32_32"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_16_16_16_16: fprintf(output, "16_16_16_16"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_32_32_32: fprintf(output, "32_32_32"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_32_32_32_32: fprintf(output, "32_32_32_32"); break;
|
|
|
|
|
case V_008F0C_BUF_DATA_FORMAT_RESERVED_15: fprintf(output, "reserved15"); break;
|
|
|
|
|
}
|
|
|
|
|
fprintf(output, " nfmt:");
|
2021-01-21 16:13:34 +00:00
|
|
|
switch (mtbuf.nfmt) {
|
2019-09-17 13:22:17 +02:00
|
|
|
case V_008F0C_BUF_NUM_FORMAT_UNORM: fprintf(output, "unorm"); break;
|
|
|
|
|
case V_008F0C_BUF_NUM_FORMAT_SNORM: fprintf(output, "snorm"); break;
|
|
|
|
|
case V_008F0C_BUF_NUM_FORMAT_USCALED: fprintf(output, "uscaled"); break;
|
|
|
|
|
case V_008F0C_BUF_NUM_FORMAT_SSCALED: fprintf(output, "sscaled"); break;
|
|
|
|
|
case V_008F0C_BUF_NUM_FORMAT_UINT: fprintf(output, "uint"); break;
|
|
|
|
|
case V_008F0C_BUF_NUM_FORMAT_SINT: fprintf(output, "sint"); break;
|
|
|
|
|
case V_008F0C_BUF_NUM_FORMAT_SNORM_OGL: fprintf(output, "snorm"); break;
|
|
|
|
|
case V_008F0C_BUF_NUM_FORMAT_FLOAT: fprintf(output, "float"); break;
|
|
|
|
|
}
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mtbuf.offset)
|
|
|
|
|
fprintf(output, " offset:%u", mtbuf.offset);
|
|
|
|
|
if (mtbuf.offen)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " offen");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mtbuf.idxen)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " idxen");
|
2024-05-14 18:34:01 +01:00
|
|
|
print_cache_flags(gfx_level, mtbuf, output);
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mtbuf.tfe)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " tfe");
|
2021-01-21 16:13:34 +00:00
|
|
|
if (mtbuf.disable_wqm)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " disable_wqm");
|
2021-01-21 16:13:34 +00:00
|
|
|
print_sync(mtbuf.sync, output);
|
2019-09-17 13:22:17 +02:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default: {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-01-11 13:09:20 +01:00
|
|
|
if (instr->isVALU()) {
|
|
|
|
|
const VALU_instruction& valu = instr->valu();
|
|
|
|
|
switch (valu.omod) {
|
2019-09-17 13:22:17 +02:00
|
|
|
case 1: fprintf(output, " *2"); break;
|
|
|
|
|
case 2: fprintf(output, " *4"); break;
|
|
|
|
|
case 3: fprintf(output, " *0.5"); break;
|
|
|
|
|
}
|
2023-01-11 13:09:20 +01:00
|
|
|
if (valu.clamp)
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " clamp");
|
2023-01-11 13:09:20 +01:00
|
|
|
if (valu.opsel & (1 << 3))
|
2020-01-30 11:41:34 +00:00
|
|
|
fprintf(output, " opsel_hi");
|
2023-01-11 13:09:20 +01:00
|
|
|
}
|
|
|
|
|
|
2024-02-04 19:57:40 +01:00
|
|
|
bool bound_ctrl = false, fetch_inactive = false;
|
|
|
|
|
|
|
|
|
|
if (instr->opcode == aco_opcode::v_permlane16_b32 ||
|
|
|
|
|
instr->opcode == aco_opcode::v_permlanex16_b32) {
|
|
|
|
|
fetch_inactive = instr->valu().opsel[0];
|
|
|
|
|
bound_ctrl = instr->valu().opsel[1];
|
|
|
|
|
} else if (instr->isDPP16()) {
|
2021-11-29 00:12:04 +09:00
|
|
|
const DPP16_instruction& dpp = instr->dpp16();
|
2021-01-21 16:13:34 +00:00
|
|
|
if (dpp.dpp_ctrl <= 0xff) {
|
|
|
|
|
fprintf(output, " quad_perm:[%d,%d,%d,%d]", dpp.dpp_ctrl & 0x3, (dpp.dpp_ctrl >> 2) & 0x3,
|
|
|
|
|
(dpp.dpp_ctrl >> 4) & 0x3, (dpp.dpp_ctrl >> 6) & 0x3);
|
|
|
|
|
} else if (dpp.dpp_ctrl >= 0x101 && dpp.dpp_ctrl <= 0x10f) {
|
|
|
|
|
fprintf(output, " row_shl:%d", dpp.dpp_ctrl & 0xf);
|
|
|
|
|
} else if (dpp.dpp_ctrl >= 0x111 && dpp.dpp_ctrl <= 0x11f) {
|
|
|
|
|
fprintf(output, " row_shr:%d", dpp.dpp_ctrl & 0xf);
|
|
|
|
|
} else if (dpp.dpp_ctrl >= 0x121 && dpp.dpp_ctrl <= 0x12f) {
|
|
|
|
|
fprintf(output, " row_ror:%d", dpp.dpp_ctrl & 0xf);
|
|
|
|
|
} else if (dpp.dpp_ctrl == dpp_wf_sl1) {
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " wave_shl:1");
|
2021-01-21 16:13:34 +00:00
|
|
|
} else if (dpp.dpp_ctrl == dpp_wf_rl1) {
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " wave_rol:1");
|
2021-01-21 16:13:34 +00:00
|
|
|
} else if (dpp.dpp_ctrl == dpp_wf_sr1) {
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " wave_shr:1");
|
2021-01-21 16:13:34 +00:00
|
|
|
} else if (dpp.dpp_ctrl == dpp_wf_rr1) {
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " wave_ror:1");
|
2021-01-21 16:13:34 +00:00
|
|
|
} else if (dpp.dpp_ctrl == dpp_row_mirror) {
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " row_mirror");
|
2021-01-21 16:13:34 +00:00
|
|
|
} else if (dpp.dpp_ctrl == dpp_row_half_mirror) {
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " row_half_mirror");
|
2021-01-21 16:13:34 +00:00
|
|
|
} else if (dpp.dpp_ctrl == dpp_row_bcast15) {
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " row_bcast:15");
|
2021-01-21 16:13:34 +00:00
|
|
|
} else if (dpp.dpp_ctrl == dpp_row_bcast31) {
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, " row_bcast:31");
|
2023-02-19 22:09:01 +01:00
|
|
|
} else if (dpp.dpp_ctrl >= dpp_row_share(0) && dpp.dpp_ctrl <= dpp_row_share(15)) {
|
|
|
|
|
fprintf(output, " row_share:%d", dpp.dpp_ctrl & 0xf);
|
|
|
|
|
} else if (dpp.dpp_ctrl >= dpp_row_xmask(0) && dpp.dpp_ctrl <= dpp_row_xmask(15)) {
|
|
|
|
|
fprintf(output, " row_xmask:%d", dpp.dpp_ctrl & 0xf);
|
2019-09-17 13:22:17 +02:00
|
|
|
} else {
|
2021-01-21 16:13:34 +00:00
|
|
|
fprintf(output, " dpp_ctrl:0x%.3x", dpp.dpp_ctrl);
|
2019-09-17 13:22:17 +02:00
|
|
|
}
|
2021-01-21 16:13:34 +00:00
|
|
|
if (dpp.row_mask != 0xf)
|
|
|
|
|
fprintf(output, " row_mask:0x%.1x", dpp.row_mask);
|
|
|
|
|
if (dpp.bank_mask != 0xf)
|
|
|
|
|
fprintf(output, " bank_mask:0x%.1x", dpp.bank_mask);
|
2024-02-04 19:57:40 +01:00
|
|
|
bound_ctrl = dpp.bound_ctrl;
|
|
|
|
|
fetch_inactive = dpp.fetch_inactive;
|
2021-11-29 00:12:04 +09:00
|
|
|
} else if (instr->isDPP8()) {
|
|
|
|
|
const DPP8_instruction& dpp = instr->dpp8();
|
2023-10-02 15:44:49 +01:00
|
|
|
fprintf(output, " dpp8:[");
|
|
|
|
|
for (unsigned i = 0; i < 8; i++)
|
2024-01-17 00:45:11 +01:00
|
|
|
fprintf(output, "%s%u", i ? "," : "", (dpp.lane_sel >> (i * 3)) & 0x7);
|
2023-10-02 15:44:49 +01:00
|
|
|
fprintf(output, "]");
|
2024-02-04 19:57:40 +01:00
|
|
|
fetch_inactive = dpp.fetch_inactive;
|
2021-01-20 15:27:16 +00:00
|
|
|
} else if (instr->isSDWA()) {
|
2021-01-21 16:13:34 +00:00
|
|
|
const SDWA_instruction& sdwa = instr->sdwa();
|
2021-08-31 16:21:32 +02:00
|
|
|
if (!instr->isVOPC()) {
|
2021-08-30 17:58:36 +02:00
|
|
|
char sext = sdwa.dst_sel.sign_extend() ? 's' : 'u';
|
2021-08-31 16:21:32 +02:00
|
|
|
unsigned offset = sdwa.dst_sel.offset();
|
|
|
|
|
if (instr->definitions[0].isFixed())
|
|
|
|
|
offset += instr->definitions[0].physReg().byte();
|
2021-08-30 17:58:36 +02:00
|
|
|
switch (sdwa.dst_sel.size()) {
|
2021-08-31 16:21:32 +02:00
|
|
|
case 1: fprintf(output, " dst_sel:%cbyte%u", sext, offset); break;
|
|
|
|
|
case 2: fprintf(output, " dst_sel:%cword%u", sext, offset >> 1); break;
|
|
|
|
|
case 4: fprintf(output, " dst_sel:dword"); break;
|
|
|
|
|
default: break;
|
|
|
|
|
}
|
|
|
|
|
if (instr->definitions[0].bytes() < 4)
|
|
|
|
|
fprintf(output, " dst_preserve");
|
|
|
|
|
}
|
|
|
|
|
for (unsigned i = 0; i < std::min<unsigned>(2, instr->operands.size()); i++) {
|
|
|
|
|
char sext = sdwa.sel[i].sign_extend() ? 's' : 'u';
|
|
|
|
|
unsigned offset = sdwa.sel[i].offset();
|
|
|
|
|
if (instr->operands[i].isFixed())
|
|
|
|
|
offset += instr->operands[i].physReg().byte();
|
|
|
|
|
switch (sdwa.sel[i].size()) {
|
|
|
|
|
case 1: fprintf(output, " src%d_sel:%cbyte%u", i, sext, offset); break;
|
|
|
|
|
case 2: fprintf(output, " src%d_sel:%cword%u", i, sext, offset >> 1); break;
|
|
|
|
|
case 4: fprintf(output, " src%d_sel:dword", i); break;
|
2021-08-30 17:58:36 +02:00
|
|
|
default: break;
|
|
|
|
|
}
|
2019-12-04 20:18:05 +00:00
|
|
|
}
|
2019-09-17 13:22:17 +02:00
|
|
|
}
|
2024-02-04 19:57:40 +01:00
|
|
|
|
|
|
|
|
if (bound_ctrl)
|
|
|
|
|
fprintf(output, " bound_ctrl:1");
|
|
|
|
|
if (fetch_inactive)
|
|
|
|
|
fprintf(output, " fi");
|
2019-09-17 13:22:17 +02:00
|
|
|
}
|
|
|
|
|
|
2024-02-06 12:03:40 +00:00
|
|
|
void
|
|
|
|
|
print_vopd_instr(enum amd_gfx_level gfx_level, const Instruction* instr, FILE* output,
|
|
|
|
|
unsigned flags)
|
|
|
|
|
{
|
|
|
|
|
unsigned opy_start = get_vopd_opy_start(instr);
|
|
|
|
|
|
|
|
|
|
if (!instr->definitions.empty()) {
|
|
|
|
|
print_definition(&instr->definitions[0], output, flags);
|
|
|
|
|
fprintf(output, " = ");
|
|
|
|
|
}
|
|
|
|
|
fprintf(output, "%s", instr_info.name[(int)instr->opcode]);
|
|
|
|
|
for (unsigned i = 0; i < MIN2(instr->operands.size(), opy_start); ++i) {
|
|
|
|
|
fprintf(output, i ? ", " : " ");
|
|
|
|
|
aco_print_operand(&instr->operands[i], output, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fprintf(output, " ::");
|
|
|
|
|
|
|
|
|
|
if (instr->definitions.size() > 1) {
|
|
|
|
|
print_definition(&instr->definitions[1], output, flags);
|
|
|
|
|
fprintf(output, " = ");
|
|
|
|
|
}
|
|
|
|
|
fprintf(output, "%s", instr_info.name[(int)instr->vopd().opy]);
|
|
|
|
|
for (unsigned i = opy_start; i < instr->operands.size(); ++i) {
|
|
|
|
|
fprintf(output, i > opy_start ? ", " : " ");
|
|
|
|
|
aco_print_operand(&instr->operands[i], output, flags);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-17 13:22:17 +02:00
|
|
|
static void
|
|
|
|
|
print_block_kind(uint16_t kind, FILE* output)
|
|
|
|
|
{
|
|
|
|
|
if (kind & block_kind_uniform)
|
|
|
|
|
fprintf(output, "uniform, ");
|
|
|
|
|
if (kind & block_kind_top_level)
|
|
|
|
|
fprintf(output, "top-level, ");
|
|
|
|
|
if (kind & block_kind_loop_preheader)
|
|
|
|
|
fprintf(output, "loop-preheader, ");
|
|
|
|
|
if (kind & block_kind_loop_header)
|
|
|
|
|
fprintf(output, "loop-header, ");
|
|
|
|
|
if (kind & block_kind_loop_exit)
|
|
|
|
|
fprintf(output, "loop-exit, ");
|
|
|
|
|
if (kind & block_kind_continue)
|
|
|
|
|
fprintf(output, "continue, ");
|
|
|
|
|
if (kind & block_kind_break)
|
|
|
|
|
fprintf(output, "break, ");
|
|
|
|
|
if (kind & block_kind_branch)
|
|
|
|
|
fprintf(output, "branch, ");
|
|
|
|
|
if (kind & block_kind_merge)
|
|
|
|
|
fprintf(output, "merge, ");
|
|
|
|
|
if (kind & block_kind_invert)
|
|
|
|
|
fprintf(output, "invert, ");
|
2024-09-03 12:14:03 +01:00
|
|
|
if (kind & block_kind_discard_early_exit)
|
|
|
|
|
fprintf(output, "discard_early_exit, ");
|
2022-01-31 16:30:08 +01:00
|
|
|
if (kind & block_kind_uses_discard)
|
|
|
|
|
fprintf(output, "discard, ");
|
2023-11-07 15:00:46 +01:00
|
|
|
if (kind & block_kind_resume)
|
|
|
|
|
fprintf(output, "resume, ");
|
2020-01-27 08:16:29 +01:00
|
|
|
if (kind & block_kind_export_end)
|
|
|
|
|
fprintf(output, "export_end, ");
|
2023-11-07 15:00:46 +01:00
|
|
|
if (kind & block_kind_end_with_regs)
|
|
|
|
|
fprintf(output, "end_with_regs, ");
|
2025-04-07 11:56:16 +02:00
|
|
|
if (kind & block_kind_contains_call)
|
|
|
|
|
fprintf(output, "contains_call, ");
|
2019-09-17 13:22:17 +02:00
|
|
|
}
|
|
|
|
|
|
2020-04-01 13:39:25 +02:00
|
|
|
static void
|
|
|
|
|
print_stage(Stage stage, FILE* output)
|
|
|
|
|
{
|
2023-08-21 15:22:05 +02:00
|
|
|
fprintf(output, "ACO shader stage: SW (");
|
|
|
|
|
|
|
|
|
|
u_foreach_bit (s, (uint32_t)stage.sw) {
|
|
|
|
|
switch ((SWStage)(1 << s)) {
|
|
|
|
|
case SWStage::VS: fprintf(output, "VS"); break;
|
|
|
|
|
case SWStage::GS: fprintf(output, "GS"); break;
|
|
|
|
|
case SWStage::TCS: fprintf(output, "TCS"); break;
|
|
|
|
|
case SWStage::TES: fprintf(output, "TES"); break;
|
|
|
|
|
case SWStage::FS: fprintf(output, "FS"); break;
|
|
|
|
|
case SWStage::CS: fprintf(output, "CS"); break;
|
|
|
|
|
case SWStage::TS: fprintf(output, "TS"); break;
|
|
|
|
|
case SWStage::MS: fprintf(output, "MS"); break;
|
|
|
|
|
case SWStage::RT: fprintf(output, "RT"); break;
|
2025-07-23 09:17:35 +02:00
|
|
|
default: UNREACHABLE("invalid SW stage");
|
2023-08-21 15:22:05 +02:00
|
|
|
}
|
|
|
|
|
if (stage.num_sw_stages() > 1)
|
|
|
|
|
fprintf(output, "+");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fprintf(output, "), HW (");
|
|
|
|
|
|
|
|
|
|
switch (stage.hw) {
|
|
|
|
|
case AC_HW_LOCAL_SHADER: fprintf(output, "LOCAL_SHADER"); break;
|
|
|
|
|
case AC_HW_HULL_SHADER: fprintf(output, "HULL_SHADER"); break;
|
|
|
|
|
case AC_HW_EXPORT_SHADER: fprintf(output, "EXPORT_SHADER"); break;
|
|
|
|
|
case AC_HW_LEGACY_GEOMETRY_SHADER: fprintf(output, "LEGACY_GEOMETRY_SHADER"); break;
|
|
|
|
|
case AC_HW_VERTEX_SHADER: fprintf(output, "VERTEX_SHADER"); break;
|
|
|
|
|
case AC_HW_NEXT_GEN_GEOMETRY_SHADER: fprintf(output, "NEXT_GEN_GEOMETRY_SHADER"); break;
|
|
|
|
|
case AC_HW_PIXEL_SHADER: fprintf(output, "PIXEL_SHADER"); break;
|
|
|
|
|
case AC_HW_COMPUTE_SHADER: fprintf(output, "COMPUTE_SHADER"); break;
|
2025-07-23 09:17:35 +02:00
|
|
|
default: UNREACHABLE("invalid HW stage");
|
2023-08-21 15:22:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fprintf(output, ")\n");
|
2020-04-01 13:39:25 +02:00
|
|
|
}
|
|
|
|
|
|
2024-10-06 09:38:35 +02:00
|
|
|
void
|
|
|
|
|
print_debug_info(const Program* program, const Instruction* instr, FILE* output)
|
|
|
|
|
{
|
|
|
|
|
fprintf(output, "// ");
|
|
|
|
|
|
|
|
|
|
assert(instr->operands[0].isConstant());
|
|
|
|
|
const auto& info = program->debug_info[instr->operands[0].constantValue()];
|
|
|
|
|
switch (info.type) {
|
|
|
|
|
case ac_shader_debug_info_src_loc:
|
|
|
|
|
if (info.src_loc.spirv_offset)
|
|
|
|
|
fprintf(output, "0x%x ", info.src_loc.spirv_offset);
|
|
|
|
|
fprintf(output, "%s:%u:%u", info.src_loc.file, info.src_loc.line, info.src_loc.column);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fprintf(output, "\n");
|
|
|
|
|
}
|
|
|
|
|
|
2021-03-15 14:15:29 +00:00
|
|
|
void
|
2022-07-21 15:17:24 +01:00
|
|
|
aco_print_block(enum amd_gfx_level gfx_level, const Block* block, FILE* output, unsigned flags,
|
2024-06-13 11:55:27 +02:00
|
|
|
const Program* program)
|
2019-09-17 13:22:17 +02:00
|
|
|
{
|
2024-11-25 15:39:22 +01:00
|
|
|
if (block->instructions.empty() && block->linear_preds.empty())
|
|
|
|
|
return;
|
|
|
|
|
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, "BB%d\n", block->index);
|
|
|
|
|
fprintf(output, "/* logical preds: ");
|
|
|
|
|
for (unsigned pred : block->logical_preds)
|
|
|
|
|
fprintf(output, "BB%d, ", pred);
|
|
|
|
|
fprintf(output, "/ linear preds: ");
|
|
|
|
|
for (unsigned pred : block->linear_preds)
|
|
|
|
|
fprintf(output, "BB%d, ", pred);
|
|
|
|
|
fprintf(output, "/ kind: ");
|
|
|
|
|
print_block_kind(block->kind, output);
|
|
|
|
|
fprintf(output, "*/\n");
|
2021-03-15 14:15:29 +00:00
|
|
|
|
|
|
|
|
if (flags & print_live_vars) {
|
2024-07-09 14:41:47 +02:00
|
|
|
fprintf(output, "\tlive in:");
|
|
|
|
|
for (unsigned id : program->live.live_in[block->index])
|
2021-03-15 14:15:29 +00:00
|
|
|
fprintf(output, " %%%d", id);
|
|
|
|
|
fprintf(output, "\n");
|
|
|
|
|
|
|
|
|
|
RegisterDemand demand = block->register_demand;
|
|
|
|
|
fprintf(output, "\tdemand: %u vgpr, %u sgpr\n", demand.vgpr, demand.sgpr);
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-17 13:22:17 +02:00
|
|
|
for (auto const& instr : block->instructions) {
|
|
|
|
|
fprintf(output, "\t");
|
2024-10-06 09:38:35 +02:00
|
|
|
if (instr->opcode == aco_opcode::p_debug_info) {
|
|
|
|
|
print_debug_info(program, instr.get(), output);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2021-03-15 14:15:29 +00:00
|
|
|
if (flags & print_live_vars) {
|
2024-06-21 15:45:22 +02:00
|
|
|
RegisterDemand demand = instr->register_demand;
|
2021-03-15 14:15:29 +00:00
|
|
|
fprintf(output, "(%3u vgpr, %3u sgpr) ", demand.vgpr, demand.sgpr);
|
|
|
|
|
}
|
2021-02-03 13:40:54 +00:00
|
|
|
if (flags & print_perf_info)
|
|
|
|
|
fprintf(output, "(%3u clk) ", instr->pass_flags);
|
|
|
|
|
|
2025-11-26 14:42:38 +00:00
|
|
|
if (instr->opcode == aco_opcode::p_parallelcopy &&
|
|
|
|
|
instr->definitions.size() == instr->operands.size() && instr->definitions.size() > 2) {
|
|
|
|
|
fprintf(output, "p_parallelcopy");
|
|
|
|
|
for (unsigned i = 0; i < instr->definitions.size(); i++) {
|
|
|
|
|
fprintf(output, "\n\t ");
|
|
|
|
|
print_definition(&instr->definitions[i], output, flags);
|
|
|
|
|
fprintf(output, " = ");
|
|
|
|
|
aco_print_operand(&instr->operands[i], output, flags);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
aco_print_instr(gfx_level, instr.get(), output, flags);
|
|
|
|
|
}
|
2019-09-17 13:22:17 +02:00
|
|
|
fprintf(output, "\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2024-06-15 16:17:29 +02:00
|
|
|
} /* end namespace */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
aco_print_operand(const Operand* operand, FILE* output, unsigned flags)
|
|
|
|
|
{
|
|
|
|
|
if (operand->isLiteral() || (operand->isConstant() && operand->bytes() == 1)) {
|
|
|
|
|
if (operand->bytes() == 1)
|
|
|
|
|
fprintf(output, "0x%.2x", operand->constantValue());
|
|
|
|
|
else if (operand->bytes() == 2)
|
|
|
|
|
fprintf(output, "0x%.4x", operand->constantValue());
|
|
|
|
|
else
|
|
|
|
|
fprintf(output, "0x%x", operand->constantValue());
|
|
|
|
|
} else if (operand->isConstant()) {
|
|
|
|
|
print_constant(operand->physReg().reg(), output);
|
|
|
|
|
} else if (operand->isUndefined()) {
|
|
|
|
|
print_reg_class(operand->regClass(), output);
|
|
|
|
|
fprintf(output, "undef");
|
|
|
|
|
} else {
|
|
|
|
|
if (operand->is16bit())
|
|
|
|
|
fprintf(output, "(is16bit)");
|
|
|
|
|
if (operand->is24bit())
|
|
|
|
|
fprintf(output, "(is24bit)");
|
2025-04-02 14:24:04 +02:00
|
|
|
if ((flags & print_kill) && operand->isKill()) {
|
|
|
|
|
if (operand->isLateKill())
|
|
|
|
|
fprintf(output, "(lateKill)");
|
|
|
|
|
else
|
|
|
|
|
fprintf(output, "(kill)");
|
|
|
|
|
}
|
2024-06-15 16:17:29 +02:00
|
|
|
|
|
|
|
|
if (!(flags & print_no_ssa))
|
|
|
|
|
fprintf(output, "%%%d%s", operand->tempId(), operand->isFixed() ? ":" : "");
|
|
|
|
|
|
|
|
|
|
if (operand->isFixed())
|
|
|
|
|
print_physReg(operand->physReg(), operand->bytes(), output, flags);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
aco_print_instr(enum amd_gfx_level gfx_level, const Instruction* instr, FILE* output,
|
|
|
|
|
unsigned flags)
|
|
|
|
|
{
|
|
|
|
|
if (instr->isVOPD()) {
|
|
|
|
|
print_vopd_instr(gfx_level, instr, output, flags);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!instr->definitions.empty()) {
|
|
|
|
|
for (unsigned i = 0; i < instr->definitions.size(); ++i) {
|
|
|
|
|
print_definition(&instr->definitions[i], output, flags);
|
|
|
|
|
if (i + 1 != instr->definitions.size())
|
|
|
|
|
fprintf(output, ", ");
|
|
|
|
|
}
|
|
|
|
|
fprintf(output, " = ");
|
|
|
|
|
}
|
|
|
|
|
fprintf(output, "%s", instr_info.name[(int)instr->opcode]);
|
|
|
|
|
if (instr->operands.size()) {
|
|
|
|
|
const unsigned num_operands = instr->operands.size();
|
|
|
|
|
bitarray8 abs = 0;
|
|
|
|
|
bitarray8 neg = 0;
|
|
|
|
|
bitarray8 neg_lo = 0;
|
|
|
|
|
bitarray8 neg_hi = 0;
|
|
|
|
|
bitarray8 opsel = 0;
|
|
|
|
|
bitarray8 f2f32 = 0;
|
|
|
|
|
bitarray8 opsel_lo = 0;
|
|
|
|
|
bitarray8 opsel_hi = -1;
|
|
|
|
|
|
|
|
|
|
if (instr->opcode == aco_opcode::v_fma_mix_f32 ||
|
|
|
|
|
instr->opcode == aco_opcode::v_fma_mixlo_f16 ||
|
|
|
|
|
instr->opcode == aco_opcode::v_fma_mixhi_f16) {
|
|
|
|
|
const VALU_instruction& vop3p = instr->valu();
|
|
|
|
|
abs = vop3p.abs;
|
|
|
|
|
neg = vop3p.neg;
|
|
|
|
|
f2f32 = vop3p.opsel_hi;
|
|
|
|
|
opsel = f2f32 & vop3p.opsel_lo;
|
|
|
|
|
} else if (instr->isVOP3P()) {
|
|
|
|
|
const VALU_instruction& vop3p = instr->valu();
|
|
|
|
|
neg = vop3p.neg_lo & vop3p.neg_hi;
|
|
|
|
|
neg_lo = vop3p.neg_lo & ~neg;
|
|
|
|
|
neg_hi = vop3p.neg_hi & ~neg;
|
|
|
|
|
opsel_lo = vop3p.opsel_lo;
|
|
|
|
|
opsel_hi = vop3p.opsel_hi;
|
|
|
|
|
} else if (instr->isVALU() && instr->opcode != aco_opcode::v_permlane16_b32 &&
|
|
|
|
|
instr->opcode != aco_opcode::v_permlanex16_b32) {
|
|
|
|
|
const VALU_instruction& valu = instr->valu();
|
|
|
|
|
abs = valu.abs;
|
|
|
|
|
neg = valu.neg;
|
|
|
|
|
opsel = valu.opsel;
|
|
|
|
|
}
|
2025-04-02 14:24:30 +02:00
|
|
|
bool is_vector_op = false;
|
2024-06-15 16:17:29 +02:00
|
|
|
for (unsigned i = 0; i < num_operands; ++i) {
|
|
|
|
|
if (i)
|
|
|
|
|
fprintf(output, ", ");
|
|
|
|
|
else
|
|
|
|
|
fprintf(output, " ");
|
2025-04-02 14:24:30 +02:00
|
|
|
if (!is_vector_op && instr->operands[i].isVectorAligned())
|
|
|
|
|
fprintf(output, "(");
|
2024-06-15 16:17:29 +02:00
|
|
|
|
|
|
|
|
if (i < 3) {
|
2024-08-22 10:28:27 +02:00
|
|
|
if (neg[i] && instr->operands[i].isConstant())
|
|
|
|
|
fprintf(output, "neg(");
|
|
|
|
|
else if (neg[i])
|
2024-06-15 16:17:29 +02:00
|
|
|
fprintf(output, "-");
|
|
|
|
|
if (abs[i])
|
|
|
|
|
fprintf(output, "|");
|
|
|
|
|
if (opsel[i])
|
|
|
|
|
fprintf(output, "hi(");
|
|
|
|
|
else if (f2f32[i])
|
|
|
|
|
fprintf(output, "lo(");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
aco_print_operand(&instr->operands[i], output, flags);
|
|
|
|
|
|
|
|
|
|
if (i < 3) {
|
|
|
|
|
if (f2f32[i] || opsel[i])
|
|
|
|
|
fprintf(output, ")");
|
|
|
|
|
if (abs[i])
|
|
|
|
|
fprintf(output, "|");
|
|
|
|
|
|
|
|
|
|
if (opsel_lo[i] || !opsel_hi[i])
|
|
|
|
|
fprintf(output, ".%c%c", opsel_lo[i] ? 'y' : 'x', opsel_hi[i] ? 'y' : 'x');
|
|
|
|
|
|
2024-08-22 10:28:27 +02:00
|
|
|
if (neg[i] && instr->operands[i].isConstant())
|
|
|
|
|
fprintf(output, ")");
|
2024-06-15 16:17:29 +02:00
|
|
|
if (neg_lo[i])
|
|
|
|
|
fprintf(output, "*[-1,1]");
|
|
|
|
|
if (neg_hi[i])
|
|
|
|
|
fprintf(output, "*[1,-1]");
|
|
|
|
|
}
|
2025-04-02 14:24:30 +02:00
|
|
|
|
|
|
|
|
if (is_vector_op && !instr->operands[i].isVectorAligned())
|
|
|
|
|
fprintf(output, ")");
|
|
|
|
|
is_vector_op = instr->operands[i].isVectorAligned();
|
2024-06-15 16:17:29 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
print_instr_format_specific(gfx_level, instr, output);
|
|
|
|
|
}
|
|
|
|
|
|
2021-03-15 14:15:29 +00:00
|
|
|
void
|
2024-06-13 11:55:27 +02:00
|
|
|
aco_print_program(const Program* program, FILE* output, unsigned flags)
|
2019-09-17 13:22:17 +02:00
|
|
|
{
|
2021-04-20 17:35:41 +01:00
|
|
|
switch (program->progress) {
|
|
|
|
|
case CompilationProgress::after_isel: fprintf(output, "After Instruction Selection:\n"); break;
|
|
|
|
|
case CompilationProgress::after_spilling:
|
|
|
|
|
fprintf(output, "After Spilling:\n");
|
|
|
|
|
flags |= print_kill;
|
|
|
|
|
break;
|
|
|
|
|
case CompilationProgress::after_ra: fprintf(output, "After RA:\n"); break;
|
2024-07-29 17:28:34 +02:00
|
|
|
case CompilationProgress::after_lower_to_hw:
|
|
|
|
|
fprintf(output, "After lowering to hw instructions:\n");
|
|
|
|
|
break;
|
2021-04-20 17:35:41 +01:00
|
|
|
}
|
|
|
|
|
|
2020-04-01 13:39:25 +02:00
|
|
|
print_stage(program->stage, output);
|
|
|
|
|
|
2019-09-17 13:22:17 +02:00
|
|
|
for (Block const& block : program->blocks)
|
2024-06-13 11:55:27 +02:00
|
|
|
aco_print_block(program->gfx_level, &block, output, flags, program);
|
2019-09-17 13:22:17 +02:00
|
|
|
|
|
|
|
|
if (program->constant_data.size()) {
|
|
|
|
|
fprintf(output, "\n/* constant data */\n");
|
|
|
|
|
for (unsigned i = 0; i < program->constant_data.size(); i += 32) {
|
|
|
|
|
fprintf(output, "[%06d] ", i);
|
|
|
|
|
unsigned line_size = std::min<size_t>(program->constant_data.size() - i, 32);
|
|
|
|
|
for (unsigned j = 0; j < line_size; j += 4) {
|
|
|
|
|
unsigned size = std::min<size_t>(program->constant_data.size() - (i + j), 4);
|
|
|
|
|
uint32_t v = 0;
|
|
|
|
|
memcpy(&v, &program->constant_data[i + j], size);
|
|
|
|
|
fprintf(output, " %08x", v);
|
|
|
|
|
}
|
|
|
|
|
fprintf(output, "\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fprintf(output, "\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} // namespace aco
|
