namespace aco {
static const char *reduce_ops[] = {
+ [iadd8] = "iadd8",
+ [iadd16] = "iadd16",
[iadd32] = "iadd32",
[iadd64] = "iadd64",
+ [imul8] = "imul8",
+ [imul16] = "imul16",
[imul32] = "imul32",
[imul64] = "imul64",
+ [fadd16] = "fadd16",
[fadd32] = "fadd32",
[fadd64] = "fadd64",
+ [fmul16] = "fmul16",
[fmul32] = "fmul32",
[fmul64] = "fmul64",
+ [imin8] = "imin8",
+ [imin16] = "imin16",
[imin32] = "imin32",
[imin64] = "imin64",
+ [imax8] = "imax8",
+ [imax16] = "imax16",
[imax32] = "imax32",
[imax64] = "imax64",
+ [umin8] = "umin8",
+ [umin16] = "umin16",
[umin32] = "umin32",
[umin64] = "umin64",
+ [umax8] = "umax8",
+ [umax16] = "umax16",
[umax32] = "umax32",
[umax64] = "umax64",
+ [fmin16] = "fmin16",
[fmin32] = "fmin32",
[fmin64] = "fmin64",
+ [fmax16] = "fmax16",
[fmax32] = "fmax32",
[fmax64] = "fmax64",
+ [iand8] = "iand8",
+ [iand16] = "iand16",
[iand32] = "iand32",
[iand64] = "iand64",
+ [ior8] = "ior8",
+ [ior16] = "ior16",
[ior32] = "ior32",
[ior64] = "ior64",
+ [ixor8] = "ixor8",
+ [ixor16] = "ixor16",
[ixor32] = "ixor32",
[ixor64] = "ixor64",
- [gfx10_wave64_bpermute] = "gfx10_wave64_bpermute",
};
static void print_reg_class(const RegClass rc, FILE *output)
static void print_operand(const Operand *operand, FILE *output)
{
- if (operand->isLiteral()) {
- fprintf(output, "0x%x", operand->constantValue());
+ 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()) {
static void print_definition(const Definition *definition, FILE *output)
{
print_reg_class(definition->regClass(), output);
+ if (definition->isPrecise())
+ fprintf(output, "(precise)");
+ if (definition->isNUW())
+ fprintf(output, "(nuw)");
fprintf(output, "%%%d", definition->tempId());
if (definition->isFixed())
print_physReg(definition->physReg(), definition->bytes(), output);
}
-static void print_barrier_reorder(bool can_reorder, barrier_interaction barrier, FILE *output)
+static void print_storage(storage_class storage, FILE *output)
{
- if (can_reorder)
- fprintf(output, " reorder");
+ fprintf(output, " storage:");
+ int printed = 0;
+ if (storage & storage_buffer)
+ printed += fprintf(output, "%sbuffer", printed ? "," : "");
+ if (storage & storage_atomic_counter)
+ printed += fprintf(output, "%satomic_counter", printed ? "," : "");
+ if (storage & storage_image)
+ printed += fprintf(output, "%simage", printed ? "," : "");
+ if (storage & storage_shared)
+ printed += fprintf(output, "%sshared", printed ? "," : "");
+ 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 ? "," : "");
+}
- if (barrier & barrier_buffer)
- fprintf(output, " buffer");
- if (barrier & barrier_image)
- fprintf(output, " image");
- if (barrier & barrier_atomic)
- fprintf(output, " atomic");
- if (barrier & barrier_shared)
- fprintf(output, " shared");
- if (barrier & barrier_gs_data)
- fprintf(output, " gs_data");
- if (barrier & barrier_gs_sendmsg)
- fprintf(output, " gs_sendmsg");
+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_instr_format_specific(struct Instruction *instr, FILE *output)
+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;
+ }
+}
+
+static void print_sync(memory_sync_info sync, FILE *output)
+{
+ print_storage(sync.storage, output);
+ print_semantics(sync.semantics, output);
+ print_scope(sync.scope, output);
+}
+
+static void print_instr_format_specific(const Instruction *instr, FILE *output)
{
switch (instr->format) {
case Format::SOPK: {
- SOPK_instruction* sopk = static_cast<SOPK_instruction*>(instr);
+ const SOPK_instruction* sopk = static_cast<const SOPK_instruction*>(instr);
fprintf(output, " imm:%d", sopk->imm & 0x8000 ? (sopk->imm - 65536) : sopk->imm);
break;
}
case Format::SOPP: {
- SOPP_instruction* sopp = static_cast<SOPP_instruction*>(instr);
+ const SOPP_instruction* sopp = static_cast<const SOPP_instruction*>(instr);
uint16_t imm = sopp->imm;
switch (instr->opcode) {
case aco_opcode::s_waitcnt: {
break;
}
case Format::SMEM: {
- SMEM_instruction* smem = static_cast<SMEM_instruction*>(instr);
+ const SMEM_instruction* smem = static_cast<const SMEM_instruction*>(instr);
if (smem->glc)
fprintf(output, " glc");
if (smem->dlc)
fprintf(output, " dlc");
if (smem->nv)
fprintf(output, " nv");
- print_barrier_reorder(smem->can_reorder, smem->barrier, output);
+ print_sync(smem->sync, output);
break;
}
case Format::VINTRP: {
- Interp_instruction* vintrp = static_cast<Interp_instruction*>(instr);
+ const Interp_instruction* vintrp = static_cast<const Interp_instruction*>(instr);
fprintf(output, " attr%d.%c", vintrp->attribute, "xyzw"[vintrp->component]);
break;
}
case Format::DS: {
- DS_instruction* ds = static_cast<DS_instruction*>(instr);
+ const DS_instruction* ds = static_cast<const DS_instruction*>(instr);
if (ds->offset0)
fprintf(output, " offset0:%u", ds->offset0);
if (ds->offset1)
fprintf(output, " offset1:%u", ds->offset1);
if (ds->gds)
fprintf(output, " gds");
+ print_sync(ds->sync, output);
break;
}
case Format::MUBUF: {
- MUBUF_instruction* mubuf = static_cast<MUBUF_instruction*>(instr);
+ const MUBUF_instruction* mubuf = static_cast<const MUBUF_instruction*>(instr);
if (mubuf->offset)
fprintf(output, " offset:%u", mubuf->offset);
if (mubuf->offen)
fprintf(output, " lds");
if (mubuf->disable_wqm)
fprintf(output, " disable_wqm");
- print_barrier_reorder(mubuf->can_reorder, mubuf->barrier, output);
+ print_sync(mubuf->sync, output);
break;
}
case Format::MIMG: {
- MIMG_instruction* mimg = static_cast<MIMG_instruction*>(instr);
+ const MIMG_instruction* mimg = static_cast<const MIMG_instruction*>(instr);
unsigned identity_dmask = !instr->definitions.empty() ?
(1 << instr->definitions[0].size()) - 1 :
0xf;
fprintf(output, " d16");
if (mimg->disable_wqm)
fprintf(output, " disable_wqm");
- print_barrier_reorder(mimg->can_reorder, mimg->barrier, output);
+ print_sync(mimg->sync, output);
break;
}
case Format::EXP: {
- Export_instruction* exp = static_cast<Export_instruction*>(instr);
+ const Export_instruction* exp = static_cast<const Export_instruction*>(instr);
unsigned identity_mask = exp->compressed ? 0x5 : 0xf;
if ((exp->enabled_mask & identity_mask) != identity_mask)
fprintf(output, " en:%c%c%c%c",
break;
}
case Format::PSEUDO_BRANCH: {
- Pseudo_branch_instruction* branch = static_cast<Pseudo_branch_instruction*>(instr);
+ const Pseudo_branch_instruction* branch = static_cast<const Pseudo_branch_instruction*>(instr);
/* Note: BB0 cannot be a branch target */
if (branch->target[0] != 0)
fprintf(output, " BB%d", branch->target[0]);
break;
}
case Format::PSEUDO_REDUCTION: {
- Pseudo_reduction_instruction* reduce = static_cast<Pseudo_reduction_instruction*>(instr);
+ const Pseudo_reduction_instruction* reduce = static_cast<const Pseudo_reduction_instruction*>(instr);
fprintf(output, " op:%s", reduce_ops[reduce->reduce_op]);
if (reduce->cluster_size)
fprintf(output, " cluster_size:%u", reduce->cluster_size);
break;
}
+ case Format::PSEUDO_BARRIER: {
+ const Pseudo_barrier_instruction* barrier = static_cast<const Pseudo_barrier_instruction*>(instr);
+ print_sync(barrier->sync, output);
+ print_scope(barrier->exec_scope, output, "exec_scope");
+ break;
+ }
case Format::FLAT:
case Format::GLOBAL:
case Format::SCRATCH: {
- FLAT_instruction* flat = static_cast<FLAT_instruction*>(instr);
+ const FLAT_instruction* flat = static_cast<const FLAT_instruction*>(instr);
if (flat->offset)
fprintf(output, " offset:%u", flat->offset);
if (flat->glc)
fprintf(output, " nv");
if (flat->disable_wqm)
fprintf(output, " disable_wqm");
- print_barrier_reorder(flat->can_reorder, flat->barrier, output);
+ print_sync(flat->sync, output);
break;
}
case Format::MTBUF: {
- MTBUF_instruction* mtbuf = static_cast<MTBUF_instruction*>(instr);
+ const MTBUF_instruction* mtbuf = static_cast<const MTBUF_instruction*>(instr);
fprintf(output, " dfmt:");
switch (mtbuf->dfmt) {
case V_008F0C_BUF_DATA_FORMAT_8: fprintf(output, "8"); break;
fprintf(output, " tfe");
if (mtbuf->disable_wqm)
fprintf(output, " disable_wqm");
- print_barrier_reorder(mtbuf->can_reorder, mtbuf->barrier, output);
+ print_sync(mtbuf->sync, output);
break;
}
case Format::VOP3P: {
- if (static_cast<VOP3P_instruction*>(instr)->clamp)
+ if (static_cast<const VOP3P_instruction*>(instr)->clamp)
fprintf(output, " clamp");
break;
}
}
}
if (instr->isVOP3()) {
- VOP3A_instruction* vop3 = static_cast<VOP3A_instruction*>(instr);
+ const VOP3A_instruction* vop3 = static_cast<const VOP3A_instruction*>(instr);
switch (vop3->omod) {
case 1:
fprintf(output, " *2");
if (vop3->opsel & (1 << 3))
fprintf(output, " opsel_hi");
} else if (instr->isDPP()) {
- DPP_instruction* dpp = static_cast<DPP_instruction*>(instr);
+ const DPP_instruction* dpp = static_cast<const DPP_instruction*>(instr);
if (dpp->dpp_ctrl <= 0xff) {
fprintf(output, " quad_perm:[%d,%d,%d,%d]",
dpp->dpp_ctrl & 0x3, (dpp->dpp_ctrl >> 2) & 0x3,
if (dpp->bound_ctrl)
fprintf(output, " bound_ctrl:1");
} else if ((int)instr->format & (int)Format::SDWA) {
- SDWA_instruction* sdwa = static_cast<SDWA_instruction*>(instr);
+ const SDWA_instruction* sdwa = static_cast<const SDWA_instruction*>(instr);
switch (sdwa->omod) {
case 1:
fprintf(output, " *2");
}
}
-void aco_print_instr(struct Instruction *instr, FILE *output)
+void aco_print_instr(const Instruction *instr, FILE *output)
{
if (!instr->definitions.empty()) {
for (unsigned i = 0; i < instr->definitions.size(); ++i) {
bool opsel[instr->operands.size()];
uint8_t sel[instr->operands.size()];
if ((int)instr->format & (int)Format::VOP3A) {
- VOP3A_instruction* vop3 = static_cast<VOP3A_instruction*>(instr);
+ const VOP3A_instruction* vop3 = static_cast<const VOP3A_instruction*>(instr);
for (unsigned i = 0; i < instr->operands.size(); ++i) {
abs[i] = vop3->abs[i];
neg[i] = vop3->neg[i];
sel[i] = sdwa_udword;
}
} else if (instr->isDPP()) {
- DPP_instruction* dpp = static_cast<DPP_instruction*>(instr);
+ const DPP_instruction* dpp = static_cast<const DPP_instruction*>(instr);
for (unsigned i = 0; i < instr->operands.size(); ++i) {
abs[i] = i < 2 ? dpp->abs[i] : false;
neg[i] = i < 2 ? dpp->neg[i] : false;
sel[i] = sdwa_udword;
}
} else if (instr->isSDWA()) {
- SDWA_instruction* sdwa = static_cast<SDWA_instruction*>(instr);
+ const SDWA_instruction* sdwa = static_cast<const SDWA_instruction*>(instr);
for (unsigned i = 0; i < instr->operands.size(); ++i) {
abs[i] = i < 2 ? sdwa->abs[i] : false;
neg[i] = i < 2 ? sdwa->neg[i] : false;
fprintf(output, "|");
if (instr->format == Format::VOP3P) {
- VOP3P_instruction* vop3 = static_cast<VOP3P_instruction*>(instr);
+ const VOP3P_instruction* vop3 = static_cast<const VOP3P_instruction*>(instr);
if ((vop3->opsel_lo & (1 << i)) || !(vop3->opsel_hi & (1 << i))) {
fprintf(output, ".%c%c",
vop3->opsel_lo & (1 << i) ? 'y' : 'x',
fprintf(output, "\n");
}
-void aco_print_block(const struct Block* block, FILE *output)
+void aco_print_block(const Block* block, FILE *output)
{
fprintf(output, "BB%d\n", block->index);
fprintf(output, "/* logical preds: ");
}
}
-void aco_print_program(Program *program, FILE *output)
+void aco_print_program(const Program *program, FILE *output)
{
print_stage(program->stage, output);
projects / mesa.git / blobdiff