| #include "aco_ir.h" |
| #include "aco_builder.h" |
| |
| #include "sid.h" |
| #include "ac_shader_util.h" |
| |
| 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", |
| }; |
| |
| static void print_reg_class(const RegClass rc, FILE *output) |
| { |
| switch (rc) { |
| case RegClass::s1: fprintf(output, " s1: "); return; |
| case RegClass::s2: fprintf(output, " s2: "); return; |
| case RegClass::s3: fprintf(output, " s3: "); return; |
| case RegClass::s4: fprintf(output, " s4: "); return; |
| case RegClass::s6: fprintf(output, " s6: "); return; |
| case RegClass::s8: fprintf(output, " s8: "); return; |
| case RegClass::s16: fprintf(output, "s16: "); return; |
| case RegClass::v1: fprintf(output, " v1: "); return; |
| case RegClass::v2: fprintf(output, " v2: "); return; |
| case RegClass::v3: fprintf(output, " v3: "); return; |
| case RegClass::v4: fprintf(output, " v4: "); return; |
| case RegClass::v5: fprintf(output, " v5: "); return; |
| case RegClass::v6: fprintf(output, " v6: "); return; |
| case RegClass::v7: fprintf(output, " v7: "); return; |
| case RegClass::v8: fprintf(output, " v8: "); return; |
| case RegClass::v1b: fprintf(output, " v1b: "); return; |
| case RegClass::v2b: fprintf(output, " v2b: "); return; |
| case RegClass::v3b: fprintf(output, " v3b: "); return; |
| case RegClass::v4b: fprintf(output, " v4b: "); return; |
| case RegClass::v6b: fprintf(output, " v6b: "); return; |
| case RegClass::v8b: fprintf(output, " v8b: "); return; |
| case RegClass::v1_linear: fprintf(output, " v1: "); return; |
| case RegClass::v2_linear: fprintf(output, " v2: "); return; |
| } |
| } |
| |
| void print_physReg(PhysReg reg, unsigned bytes, FILE *output) |
| { |
| if (reg == 124) { |
| fprintf(output, ":m0"); |
| } else if (reg == 106) { |
| fprintf(output, ":vcc"); |
| } else if (reg == 253) { |
| fprintf(output, ":scc"); |
| } else if (reg == 126) { |
| fprintf(output, ":exec"); |
| } else { |
| bool is_vgpr = reg / 256; |
| unsigned r = reg % 256; |
| unsigned size = DIV_ROUND_UP(bytes, 4); |
| fprintf(output, ":%c[%d", is_vgpr ? 'v' : 's', r); |
| if (size > 1) |
| fprintf(output, "-%d]", r + size -1); |
| else |
| fprintf(output, "]"); |
| if (reg.byte() || bytes % 4) |
| fprintf(output, "[%d:%d]", reg.byte()*8, (reg.byte()+bytes) * 8); |
| } |
| } |
| |
| 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; |
| } |
| } |
| |
| static void print_operand(const Operand *operand, FILE *output) |
| { |
| 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->isLateKill()) |
| fprintf(output, "(latekill)"); |
| |
| fprintf(output, "%%%d", operand->tempId()); |
| |
| if (operand->isFixed()) |
| print_physReg(operand->physReg(), operand->bytes(), output); |
| } |
| } |
| |
| static void print_definition(const Definition *definition, FILE *output) |
| { |
| print_reg_class(definition->regClass(), output); |
| if (definition->isPrecise()) |
| fprintf(output, "(precise)"); |
| 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) |
| { |
| if (can_reorder) |
| fprintf(output, " reorder"); |
| |
| 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_instr_format_specific(const Instruction *instr, FILE *output) |
| { |
| switch (instr->format) { |
| case Format::SOPK: { |
| 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: { |
| const SOPP_instruction* sopp = static_cast<const SOPP_instruction*>(instr); |
| uint16_t imm = sopp->imm; |
| switch (instr->opcode) { |
| case aco_opcode::s_waitcnt: { |
| /* we usually should check the chip class for vmcnt/lgkm, but |
| * insert_waitcnt() should fill it in regardless. */ |
| unsigned vmcnt = (imm & 0xF) | ((imm & (0x3 << 14)) >> 10); |
| if (vmcnt != 63) fprintf(output, " vmcnt(%d)", vmcnt); |
| if (((imm >> 4) & 0x7) < 0x7) fprintf(output, " expcnt(%d)", (imm >> 4) & 0x7); |
| if (((imm >> 8) & 0x3F) < 0x3F) fprintf(output, " lgkmcnt(%d)", (imm >> 8) & 0x3F); |
| break; |
| } |
| 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; |
| } |
| case aco_opcode::s_sendmsg: { |
| unsigned id = imm & sendmsg_id_mask; |
| switch (id) { |
| case sendmsg_none: |
| fprintf(output, " sendmsg(MSG_NONE)"); |
| break; |
| case _sendmsg_gs: |
| fprintf(output, " sendmsg(gs%s%s, %u)", |
| imm & 0x10 ? ", cut" : "", imm & 0x20 ? ", emit" : "", imm >> 8); |
| break; |
| case _sendmsg_gs_done: |
| fprintf(output, " sendmsg(gs_done%s%s, %u)", |
| imm & 0x10 ? ", cut" : "", imm & 0x20 ? ", emit" : "", imm >> 8); |
| 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; |
| } |
| break; |
| } |
| default: { |
| if (imm) |
| fprintf(output, " imm:%u", imm); |
| break; |
| } |
| } |
| if (sopp->block != -1) |
| fprintf(output, " block:BB%d", sopp->block); |
| break; |
| } |
| case Format::SMEM: { |
| 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); |
| break; |
| } |
| case Format::VINTRP: { |
| const Interp_instruction* vintrp = static_cast<const Interp_instruction*>(instr); |
| fprintf(output, " attr%d.%c", vintrp->attribute, "xyzw"[vintrp->component]); |
| break; |
| } |
| case Format::DS: { |
| 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"); |
| break; |
| } |
| case Format::MUBUF: { |
| const MUBUF_instruction* mubuf = static_cast<const MUBUF_instruction*>(instr); |
| if (mubuf->offset) |
| fprintf(output, " offset:%u", mubuf->offset); |
| if (mubuf->offen) |
| fprintf(output, " offen"); |
| if (mubuf->idxen) |
| fprintf(output, " idxen"); |
| if (mubuf->addr64) |
| fprintf(output, " addr64"); |
| if (mubuf->glc) |
| fprintf(output, " glc"); |
| if (mubuf->dlc) |
| fprintf(output, " dlc"); |
| if (mubuf->slc) |
| fprintf(output, " slc"); |
| if (mubuf->tfe) |
| fprintf(output, " tfe"); |
| if (mubuf->lds) |
| fprintf(output, " lds"); |
| if (mubuf->disable_wqm) |
| fprintf(output, " disable_wqm"); |
| print_barrier_reorder(mubuf->can_reorder, mubuf->barrier, output); |
| break; |
| } |
| case Format::MIMG: { |
| const MIMG_instruction* mimg = static_cast<const MIMG_instruction*>(instr); |
| unsigned identity_dmask = !instr->definitions.empty() ? |
| (1 << instr->definitions[0].size()) - 1 : |
| 0xf; |
| if ((mimg->dmask & identity_dmask) != identity_dmask) |
| fprintf(output, " dmask:%s%s%s%s", |
| mimg->dmask & 0x1 ? "x" : "", |
| mimg->dmask & 0x2 ? "y" : "", |
| mimg->dmask & 0x4 ? "z" : "", |
| mimg->dmask & 0x8 ? "w" : ""); |
| switch (mimg->dim) { |
| 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; |
| } |
| if (mimg->unrm) |
| fprintf(output, " unrm"); |
| if (mimg->glc) |
| fprintf(output, " glc"); |
| if (mimg->dlc) |
| fprintf(output, " dlc"); |
| if (mimg->slc) |
| fprintf(output, " slc"); |
| if (mimg->tfe) |
| fprintf(output, " tfe"); |
| if (mimg->da) |
| fprintf(output, " da"); |
| if (mimg->lwe) |
| fprintf(output, " lwe"); |
| if (mimg->r128 || mimg->a16) |
| fprintf(output, " r128/a16"); |
| if (mimg->d16) |
| fprintf(output, " d16"); |
| if (mimg->disable_wqm) |
| fprintf(output, " disable_wqm"); |
| print_barrier_reorder(mimg->can_reorder, mimg->barrier, output); |
| break; |
| } |
| case Format::EXP: { |
| 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", |
| exp->enabled_mask & 0x1 ? 'r' : '*', |
| exp->enabled_mask & 0x2 ? 'g' : '*', |
| exp->enabled_mask & 0x4 ? 'b' : '*', |
| exp->enabled_mask & 0x8 ? 'a' : '*'); |
| if (exp->compressed) |
| fprintf(output, " compr"); |
| if (exp->done) |
| fprintf(output, " done"); |
| if (exp->valid_mask) |
| fprintf(output, " vm"); |
| |
| 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) |
| fprintf(output, " mrtz"); |
| else if (exp->dest == V_008DFC_SQ_EXP_NULL) |
| fprintf(output, " null"); |
| 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); |
| break; |
| } |
| case Format::PSEUDO_BRANCH: { |
| 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]); |
| if (branch->target[1] != 0) |
| fprintf(output, ", BB%d", branch->target[1]); |
| break; |
| } |
| case Format::PSEUDO_REDUCTION: { |
| 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::FLAT: |
| case Format::GLOBAL: |
| case Format::SCRATCH: { |
| const FLAT_instruction* flat = static_cast<const FLAT_instruction*>(instr); |
| if (flat->offset) |
| fprintf(output, " offset:%u", flat->offset); |
| if (flat->glc) |
| fprintf(output, " glc"); |
| if (flat->dlc) |
| fprintf(output, " dlc"); |
| if (flat->slc) |
| fprintf(output, " slc"); |
| if (flat->lds) |
| fprintf(output, " lds"); |
| if (flat->nv) |
| fprintf(output, " nv"); |
| if (flat->disable_wqm) |
| fprintf(output, " disable_wqm"); |
| print_barrier_reorder(flat->can_reorder, flat->barrier, output); |
| break; |
| } |
| case Format::MTBUF: { |
| 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; |
| 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:"); |
| switch (mtbuf->nfmt) { |
| 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; |
| } |
| if (mtbuf->offset) |
| fprintf(output, " offset:%u", mtbuf->offset); |
| if (mtbuf->offen) |
| fprintf(output, " offen"); |
| if (mtbuf->idxen) |
| fprintf(output, " idxen"); |
| if (mtbuf->glc) |
| fprintf(output, " glc"); |
| if (mtbuf->dlc) |
| fprintf(output, " dlc"); |
| if (mtbuf->slc) |
| fprintf(output, " slc"); |
| if (mtbuf->tfe) |
| fprintf(output, " tfe"); |
| if (mtbuf->disable_wqm) |
| fprintf(output, " disable_wqm"); |
| print_barrier_reorder(mtbuf->can_reorder, mtbuf->barrier, output); |
| break; |
| } |
| case Format::VOP3P: { |
| if (static_cast<const VOP3P_instruction*>(instr)->clamp) |
| fprintf(output, " clamp"); |
| break; |
| } |
| default: { |
| break; |
| } |
| } |
| if (instr->isVOP3()) { |
| const VOP3A_instruction* vop3 = static_cast<const VOP3A_instruction*>(instr); |
| switch (vop3->omod) { |
| case 1: |
| fprintf(output, " *2"); |
| break; |
| case 2: |
| fprintf(output, " *4"); |
| break; |
| case 3: |
| fprintf(output, " *0.5"); |
| break; |
| } |
| if (vop3->clamp) |
| fprintf(output, " clamp"); |
| if (vop3->opsel & (1 << 3)) |
| fprintf(output, " opsel_hi"); |
| } else if (instr->isDPP()) { |
| 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, |
| (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) { |
| fprintf(output, " wave_shl:1"); |
| } else if (dpp->dpp_ctrl == dpp_wf_rl1) { |
| fprintf(output, " wave_rol:1"); |
| } else if (dpp->dpp_ctrl == dpp_wf_sr1) { |
| fprintf(output, " wave_shr:1"); |
| } else if (dpp->dpp_ctrl == dpp_wf_rr1) { |
| fprintf(output, " wave_ror:1"); |
| } else if (dpp->dpp_ctrl == dpp_row_mirror) { |
| fprintf(output, " row_mirror"); |
| } else if (dpp->dpp_ctrl == dpp_row_half_mirror) { |
| fprintf(output, " row_half_mirror"); |
| } else if (dpp->dpp_ctrl == dpp_row_bcast15) { |
| fprintf(output, " row_bcast:15"); |
| } else if (dpp->dpp_ctrl == dpp_row_bcast31) { |
| fprintf(output, " row_bcast:31"); |
| } else { |
| fprintf(output, " dpp_ctrl:0x%.3x", dpp->dpp_ctrl); |
| } |
| 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); |
| if (dpp->bound_ctrl) |
| fprintf(output, " bound_ctrl:1"); |
| } else if ((int)instr->format & (int)Format::SDWA) { |
| const SDWA_instruction* sdwa = static_cast<const SDWA_instruction*>(instr); |
| switch (sdwa->omod) { |
| case 1: |
| fprintf(output, " *2"); |
| break; |
| case 2: |
| fprintf(output, " *4"); |
| break; |
| case 3: |
| fprintf(output, " *0.5"); |
| break; |
| } |
| if (sdwa->clamp) |
| fprintf(output, " clamp"); |
| switch (sdwa->dst_sel & sdwa_asuint) { |
| case sdwa_udword: |
| break; |
| case sdwa_ubyte0: |
| case sdwa_ubyte1: |
| case sdwa_ubyte2: |
| case sdwa_ubyte3: |
| fprintf(output, " dst_sel:%sbyte%u", sdwa->dst_sel & sdwa_sext ? "s" : "u", |
| sdwa->dst_sel & sdwa_bytenum); |
| break; |
| case sdwa_uword0: |
| case sdwa_uword1: |
| fprintf(output, " dst_sel:%sword%u", sdwa->dst_sel & sdwa_sext ? "s" : "u", |
| sdwa->dst_sel & sdwa_wordnum); |
| break; |
| } |
| if (sdwa->dst_preserve) |
| fprintf(output, " dst_preserve"); |
| } |
| } |
| |
| void aco_print_instr(const Instruction *instr, FILE *output) |
| { |
| if (!instr->definitions.empty()) { |
| for (unsigned i = 0; i < instr->definitions.size(); ++i) { |
| print_definition(&instr->definitions[i], output); |
| if (i + 1 != instr->definitions.size()) |
| fprintf(output, ", "); |
| } |
| fprintf(output, " = "); |
| } |
| fprintf(output, "%s", instr_info.name[(int)instr->opcode]); |
| if (instr->operands.size()) { |
| bool abs[instr->operands.size()]; |
| bool neg[instr->operands.size()]; |
| bool opsel[instr->operands.size()]; |
| uint8_t sel[instr->operands.size()]; |
| if ((int)instr->format & (int)Format::VOP3A) { |
| 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]; |
| opsel[i] = vop3->opsel & (1 << i); |
| sel[i] = sdwa_udword; |
| } |
| } else if (instr->isDPP()) { |
| 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; |
| opsel[i] = false; |
| sel[i] = sdwa_udword; |
| } |
| } else if (instr->isSDWA()) { |
| 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; |
| opsel[i] = false; |
| sel[i] = i < 2 ? sdwa->sel[i] : sdwa_udword; |
| } |
| } else { |
| for (unsigned i = 0; i < instr->operands.size(); ++i) { |
| abs[i] = false; |
| neg[i] = false; |
| opsel[i] = false; |
| sel[i] = sdwa_udword; |
| } |
| } |
| for (unsigned i = 0; i < instr->operands.size(); ++i) { |
| if (i) |
| fprintf(output, ", "); |
| else |
| fprintf(output, " "); |
| |
| if (neg[i]) |
| fprintf(output, "-"); |
| if (abs[i]) |
| fprintf(output, "|"); |
| if (opsel[i]) |
| fprintf(output, "hi("); |
| else if (sel[i] & sdwa_sext) |
| fprintf(output, "sext("); |
| print_operand(&instr->operands[i], output); |
| if (opsel[i] || (sel[i] & sdwa_sext)) |
| fprintf(output, ")"); |
| if (!(sel[i] & sdwa_isra)) { |
| if (sel[i] & sdwa_udword) { |
| /* print nothing */ |
| } else if (sel[i] & sdwa_isword) { |
| unsigned index = sel[i] & sdwa_wordnum; |
| fprintf(output, "[%u:%u]", index * 16, index * 16 + 15); |
| } else { |
| unsigned index = sel[i] & sdwa_bytenum; |
| fprintf(output, "[%u:%u]", index * 8, index * 8 + 7); |
| } |
| } |
| if (abs[i]) |
| fprintf(output, "|"); |
| |
| if (instr->format == Format::VOP3P) { |
| 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', |
| vop3->opsel_hi & (1 << i) ? 'y' : 'x'); |
| } |
| if (vop3->neg_lo[i] && vop3->neg_hi[i]) |
| fprintf(output, "*[-1,-1]"); |
| else if (vop3->neg_lo[i]) |
| fprintf(output, "*[-1,1]"); |
| else if (vop3->neg_hi[i]) |
| fprintf(output, "*[1,-1]"); |
| } |
| } |
| } |
| print_instr_format_specific(instr, output); |
| } |
| |
| 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_continue_or_break) |
| fprintf(output, "continue_or_break, "); |
| if (kind & block_kind_discard) |
| fprintf(output, "discard, "); |
| if (kind & block_kind_branch) |
| fprintf(output, "branch, "); |
| if (kind & block_kind_merge) |
| fprintf(output, "merge, "); |
| if (kind & block_kind_invert) |
| fprintf(output, "invert, "); |
| if (kind & block_kind_uses_discard_if) |
| fprintf(output, "discard_if, "); |
| if (kind & block_kind_needs_lowering) |
| fprintf(output, "needs_lowering, "); |
| if (kind & block_kind_uses_demote) |
| fprintf(output, "uses_demote, "); |
| if (kind & block_kind_export_end) |
| fprintf(output, "export_end, "); |
| } |
| |
| static void print_stage(Stage stage, FILE *output) |
| { |
| fprintf(output, "ACO shader stage: "); |
| |
| if (stage == compute_cs) |
| fprintf(output, "compute_cs"); |
| else if (stage == fragment_fs) |
| fprintf(output, "fragment_fs"); |
| else if (stage == gs_copy_vs) |
| fprintf(output, "gs_copy_vs"); |
| else if (stage == vertex_ls) |
| fprintf(output, "vertex_ls"); |
| else if (stage == vertex_es) |
| fprintf(output, "vertex_es"); |
| else if (stage == vertex_vs) |
| fprintf(output, "vertex_vs"); |
| else if (stage == tess_control_hs) |
| fprintf(output, "tess_control_hs"); |
| else if (stage == vertex_tess_control_hs) |
| fprintf(output, "vertex_tess_control_hs"); |
| else if (stage == tess_eval_es) |
| fprintf(output, "tess_eval_es"); |
| else if (stage == tess_eval_vs) |
| fprintf(output, "tess_eval_vs"); |
| else if (stage == geometry_gs) |
| fprintf(output, "geometry_gs"); |
| else if (stage == vertex_geometry_gs) |
| fprintf(output, "vertex_geometry_gs"); |
| else if (stage == tess_eval_geometry_gs) |
| fprintf(output, "tess_eval_geometry_gs"); |
| else if (stage == ngg_vertex_gs) |
| fprintf(output, "ngg_vertex_gs"); |
| else if (stage == ngg_tess_eval_gs) |
| fprintf(output, "ngg_tess_eval_gs"); |
| else if (stage == ngg_vertex_geometry_gs) |
| fprintf(output, "ngg_vertex_geometry_gs"); |
| else if (stage == ngg_tess_eval_geometry_gs) |
| fprintf(output, "ngg_tess_eval_geometry_gs"); |
| else |
| fprintf(output, "unknown"); |
| |
| fprintf(output, "\n"); |
| } |
| |
| void aco_print_block(const Block* block, FILE *output) |
| { |
| 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"); |
| for (auto const& instr : block->instructions) { |
| fprintf(output, "\t"); |
| aco_print_instr(instr.get(), output); |
| fprintf(output, "\n"); |
| } |
| } |
| |
| void aco_print_program(const Program *program, FILE *output) |
| { |
| print_stage(program->stage, output); |
| |
| for (Block const& block : program->blocks) |
| aco_print_block(&block, output); |
| |
| 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"); |
| } |
| |
| } |
