fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-07 13:38:06 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

vc4: make some dump functions return strings instead of printf

Browse source 
This will give better flexibility on how and where the dumps will be
done.

Signed-off-by: Juan A. Suarez Romero <jasuarez@igalia.com>
Reviewed-by: Iago Toral Quiroga <itoral@igalia.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/40434>
This commit is contained in:
Juan A. Suarez Romero 2026-03-26 18:50:34 +01:00 • committed by Marge Bot
parent 4172100617
commit 260e051187
13 changed files with 101 additions and 120 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
src/gallium/drivers/vc4/vc4_opt_algebraic.c
View file

@ -43,9 +43,8 @@ dump_from(struct vc4_compile *c, struct qinst *inst)
if (!debug)
return;
fprintf(stderr, "optimizing: ");
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "optimizing: %s\n", dump_inst);
}
static void
@ -54,9 +53,8 @@ dump_to(struct vc4_compile *c, struct qinst *inst)
if (!debug)
return;
fprintf(stderr, "to: ");
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "to: %s", dump_inst);
}
static bool

10
src/gallium/drivers/vc4/vc4_opt_constant_folding.c
View file

@ -39,9 +39,8 @@ dump_from(struct vc4_compile *c, struct qinst *inst)
if (!debug)
return;
fprintf(stderr, "optimizing: ");
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "optimizing: %s\n", dump_inst);
}
static void
@ -50,9 +49,8 @@ dump_to(struct vc4_compile *c, struct qinst *inst)
if (!debug)
return;
fprintf(stderr, "to: ");
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "to: %s\n", dump_inst);
}
static bool

10
src/gallium/drivers/vc4/vc4_opt_copy_propagation.c
View file

@ -133,18 +133,16 @@ try_copy_prop(struct vc4_compile *c, struct qinst *inst, struct qinst **movs)
}
if (debug) {
fprintf(stderr, "Copy propagate: ");
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "Copy propagate: %s\n", dump_inst);
}
inst->src[i] = mov->src[0];
inst->src[i].pack = unpack;
if (debug) {
fprintf(stderr, "to: ");
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "to: %s\n", dump_inst);
}
progress = true;

11
src/gallium/drivers/vc4/vc4_opt_dead_code.c
View file

@ -43,9 +43,8 @@ static void
dce(struct vc4_compile *c, struct qinst *inst)
{
if (debug) {
fprintf(stderr, "Removing: ");
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "Removing: %s\n", dump_inst);
}
assert(!inst->sf);
qir_remove_instruction(c, inst);
@ -117,10 +116,10 @@ qir_opt_dead_code(struct vc4_compile *c)
*/
if (inst->dst.file == QFILE_TEMP) {
if (debug) {
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr,
"Removing dst from: ");
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
"Removing dst from: %s\n",
dump_inst);
}
c->defs[inst->dst.index] = NULL;
inst->dst.file = QFILE_NULL;

10
src/gallium/drivers/vc4/vc4_opt_peephole_sf.c
View file

@ -38,9 +38,8 @@ dump_from(struct vc4_compile *c, struct qinst *inst, const char *type)
if (!debug)
return;
fprintf(stderr, "optimizing %s: ", type);
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "optimizing %s: %s\n", type, dump_inst);
}
static void
@ -49,9 +48,8 @@ dump_to(struct vc4_compile *c, struct qinst *inst)
if (!debug)
return;
fprintf(stderr, "to: ");
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "to: %s\n", dump_inst);
}
static bool

10
src/gallium/drivers/vc4/vc4_opt_small_immediates.c
View file

@ -87,16 +87,14 @@ qir_opt_small_immediates(struct vc4_compile *c)
continue;
if (debug) {
fprintf(stderr, "opt_small_immediate() from: ");
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "opt_small_immediate() from: %s\n", dump_inst);
}
inst->src[i].file = QFILE_SMALL_IMM;
inst->src[i].index = imm;
if (debug) {
fprintf(stderr, "to: ");
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "to: %s\n", dump_inst);
}
progress = true;
break;

61
src/gallium/drivers/vc4/vc4_qir.c
View file

@ -388,7 +388,7 @@ qir_describe_uniform(enum quniform_contents contents, uint32_t data,
}
}
static void
static const char *
qir_print_reg(struct vc4_compile *c, struct qreg reg, bool write)
{
static const char *files[] = {
@ -412,26 +412,26 @@ qir_print_reg(struct vc4_compile *c, struct qreg reg, bool write)
switch (reg.file) {
case QFILE_NULL:
fprintf(stderr, "null");
return ralloc_asprintf(c, "null");
break;
case QFILE_LOAD_IMM:
fprintf(stderr, "0x%08x (%f)", reg.index, uif(reg.index));
return ralloc_asprintf(c, "0x%08x (%f)", reg.index, uif(reg.index));
break;
case QFILE_SMALL_IMM:
if ((int)reg.index >= -16 && (int)reg.index <= 15)
fprintf(stderr, "%d", reg.index);
return ralloc_asprintf(c, "%d", reg.index);
else
fprintf(stderr, "%f", uif(reg.index));
return ralloc_asprintf(c, "%f", uif(reg.index));
break;
case QFILE_VPM:
if (write) {
fprintf(stderr, "vpm");
return ralloc_asprintf(c, "vpm");
} else {
fprintf(stderr, "vpm%d.%d",
reg.index / 4, reg.index % 4);
return ralloc_asprintf(c, "vpm%d.%d",
reg.index / 4, reg.index % 4);
}
break;
@ -444,53 +444,50 @@ qir_print_reg(struct vc4_compile *c, struct qreg reg, bool write)
case QFILE_TEX_T:
case QFILE_TEX_R:
case QFILE_TEX_B:
fprintf(stderr, "%s", files[reg.file]);
return ralloc_asprintf(c, "%s", files[reg.file]);
break;
case QFILE_UNIF: {
char *desc = qir_describe_uniform(c->uniform_contents[reg.index],
c->uniform_data[reg.index],
NULL);
fprintf(stderr, "u%d (%s)", reg.index, desc);
char *unif = ralloc_asprintf(c, "u%d (%s)", reg.index, desc);
ralloc_free(desc);
return unif;
break;
}
default:
fprintf(stderr, "%s%d", files[reg.file], reg.index);
return ralloc_asprintf(c, "%s%d", files[reg.file], reg.index);
break;
}
}
void
char *
qir_dump_inst(struct vc4_compile *c, struct qinst *inst)
{
fprintf(stderr, "%s", qir_get_op_name(inst->op));
if (inst->op == QOP_BRANCH)
vc4_qpu_disasm_cond_branch(stderr, inst->cond);
else
vc4_qpu_disasm_cond(stderr, inst->cond);
if (inst->sf)
fprintf(stderr, ".sf");
fprintf(stderr, " ");
char *dump_inst =
ralloc_asprintf(c, "%s%s%s ", qir_get_op_name(inst->op),
inst->op == QOP_BRANCH ? vc4_qpu_disasm_cond_branch(inst->cond)
: vc4_qpu_disasm_cond(inst->cond),
inst->sf ? ".sf" : "");
if (inst->op != QOP_BRANCH) {
qir_print_reg(c, inst->dst, true);
const char *reg = qir_print_reg(c, inst->dst, true);
ralloc_asprintf_append(&dump_inst, "%s", reg);
if (inst->dst.pack) {
if (inst->dst.pack) {
if (qir_is_mul(inst))
vc4_qpu_disasm_pack_mul(stderr, inst->dst.pack);
else
vc4_qpu_disasm_pack_a(stderr, inst->dst.pack);
}
ralloc_asprintf_append(&dump_inst, "%s",
qir_is_mul(inst) ? vc4_qpu_disasm_pack_mul(inst->dst.pack)
: vc4_qpu_disasm_pack_a(inst->dst.pack));
}
}
for (int i = 0; i < qir_get_nsrc(inst); i++) {
fprintf(stderr, ", ");
qir_print_reg(c, inst->src[i], false);
vc4_qpu_disasm_unpack(stderr, inst->src[i].pack);
const char *reg = qir_print_reg(c, inst->src[i], false);
ralloc_asprintf_append(&dump_inst, ", %s%s", reg, vc4_qpu_disasm_unpack(inst->src[i].pack));
}
return dump_inst;
}
void
@ -548,8 +545,8 @@ qir_dump(struct vc4_compile *c)
fprintf(stderr, " ");
}
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "%s\n", dump_inst);
ip++;
}
if (block->successors[1]) {

2
src/gallium/drivers/vc4/vc4_qir.h
View file

@ -554,7 +554,7 @@ struct qreg qir_follow_movs(struct vc4_compile *c, struct qreg reg);
uint8_t qir_channels_written(struct qinst *inst);
void qir_dump(struct vc4_compile *c);
void qir_dump_inst(struct vc4_compile *c, struct qinst *inst);
char *qir_dump_inst(struct vc4_compile *c, struct qinst *inst);
char *qir_describe_uniform(enum quniform_contents contents, uint32_t data,
const uint32_t *uniforms);
const char *qir_get_stage_name(enum qstage stage);

16
src/gallium/drivers/vc4/vc4_qir_schedule.c
View file

@ -529,17 +529,15 @@ dump_state(struct vc4_compile *c, struct schedule_state *state)
uint32_t i = 0;
list_for_each_entry(struct schedule_node, n, &state->dag->heads,
dag.link) {
fprintf(stderr, "%3d: ", i++);
qir_dump_inst(c, n->inst);
fprintf(stderr, " (%d cost)\n",
char *dump_inst = qir_dump_inst(c, n->inst);
fprintf(stderr, "%3d: %s (%d cost)\n", i++, dump_inst,
get_register_pressure_cost(state, n->inst));
util_dynarray_foreach(&n->dag.edges, struct dag_edge, edge) {
struct schedule_node *child =
(struct schedule_node *)edge->child;
fprintf(stderr, " - ");
qir_dump_inst(c, child->inst);
fprintf(stderr, " (%d parents)\n",
char *dump_inst = qir_dump_inst(c, child->inst);
fprintf(stderr, " - %s (%d parents)\n", dump_inst,
child->dag.parent_count);
}
}
@ -627,9 +625,9 @@ schedule_instructions(struct vc4_compile *c,
if (debug) {
fprintf(stderr, "current list:\n");
dump_state(c, state);
fprintf(stderr, "chose: ");
qir_dump_inst(c, inst);
fprintf(stderr, " (%d cost)\n",
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "chose: %s (%d cost)\n",
dump_inst,
get_register_pressure_cost(state, inst));
}

5
src/gallium/drivers/vc4/vc4_qir_validate.c
View file

@ -27,9 +27,8 @@
static void
fail_instr(struct vc4_compile *c, struct qinst *inst, const char *msg)
{
fprintf(stderr, "qir_validate: %s: ", msg);
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(c, inst);
fprintf(stderr, "qir_validate: %s: %s\n", msg, dump_inst);
abort();
}

20
src/gallium/drivers/vc4/vc4_qpu.h
View file

@ -227,22 +227,22 @@ M_ALU2(V8SUBS)
void
vc4_qpu_disasm(const uint64_t *instructions, int num_instructions);
void
vc4_qpu_disasm_pack_mul(FILE *out, uint32_t pack);
const char *
vc4_qpu_disasm_pack_mul(uint32_t pack);
void
vc4_qpu_disasm_pack_a(FILE *out, uint32_t pack);
const char *
vc4_qpu_disasm_pack_a(uint32_t pack);
void
vc4_qpu_disasm_unpack(FILE *out, uint32_t pack);
const char *
vc4_qpu_disasm_unpack(uint32_t pack);
void
vc4_qpu_validate(uint64_t *insts, uint32_t num_inst);
void
vc4_qpu_disasm_cond(FILE *out, uint32_t cond);
const char *
vc4_qpu_disasm_cond(uint32_t cond);
void
vc4_qpu_disasm_cond_branch(FILE *out, uint32_t cond);
const char *
vc4_qpu_disasm_cond_branch(uint32_t cond);
#endif /* VC4_QPU_H */

51
src/gallium/drivers/vc4/vc4_qpu_disasm.c
View file

@ -261,34 +261,34 @@ get_special_write_desc(int reg, bool is_a)
return special_write[reg];
}
void
vc4_qpu_disasm_pack_mul(FILE *out, uint32_t pack)
const char *
vc4_qpu_disasm_pack_mul(uint32_t pack)
{
fprintf(out, "%s", DESC(qpu_pack_mul, pack));
return DESC(qpu_pack_mul, pack);
}
void
vc4_qpu_disasm_pack_a(FILE *out, uint32_t pack)
const char *
vc4_qpu_disasm_pack_a(uint32_t pack)
{
fprintf(out, "%s", DESC(qpu_pack_a, pack));
return DESC(qpu_pack_a, pack);
}
void
vc4_qpu_disasm_unpack(FILE *out, uint32_t unpack)
const char *
vc4_qpu_disasm_unpack(uint32_t unpack)
{
fprintf(out, "%s", DESC(qpu_unpack, unpack));
return DESC(qpu_unpack, unpack);
}
void
vc4_qpu_disasm_cond(FILE *out, uint32_t cond)
const char *
vc4_qpu_disasm_cond(uint32_t cond)
{
fprintf(out, "%s", DESC(qpu_cond, cond));
return DESC(qpu_cond, cond);
}
void
vc4_qpu_disasm_cond_branch(FILE *out, uint32_t cond)
const char *
vc4_qpu_disasm_cond_branch(uint32_t cond)
{
fprintf(out, "%s", DESC(qpu_cond_branch, cond));
return DESC(qpu_cond_branch, cond);
}
static void
@ -309,9 +309,9 @@ print_alu_dst(uint64_t inst, bool is_mul)
fprintf(stderr, "%s%d?", file, waddr);
if (is_mul && (inst & QPU_PM)) {
vc4_qpu_disasm_pack_mul(stderr, pack);
fprintf(stderr, "%s", vc4_qpu_disasm_pack_mul(pack));
} else if (is_a && !(inst & QPU_PM)) {
vc4_qpu_disasm_pack_a(stderr, pack);
fprintf(stderr, "%s", vc4_qpu_disasm_pack_a(pack));
}
}
@ -353,7 +353,7 @@ print_alu_src(uint64_t inst, uint32_t mux, bool is_mul)
if (((mux == QPU_MUX_A && !(inst & QPU_PM)) ||
(mux == QPU_MUX_R4 && (inst & QPU_PM)))) {
vc4_qpu_disasm_unpack(stderr, unpack);
fprintf(stderr, "%s", vc4_qpu_disasm_unpack(unpack));
}
}
@ -375,7 +375,7 @@ print_add_op(uint64_t inst)
fprintf(stderr, ".sf");
if (op_add != QPU_A_NOP)
vc4_qpu_disasm_cond(stderr, cond);
fprintf(stderr, "%s", vc4_qpu_disasm_cond(cond));
fprintf(stderr, " ");
print_alu_dst(inst, false);
@ -409,7 +409,7 @@ print_mul_op(uint64_t inst)
fprintf(stderr, ".sf");
if (op_mul != QPU_M_NOP)
vc4_qpu_disasm_cond(stderr, cond);
fprintf(stderr, "%s", vc4_qpu_disasm_cond(cond));
fprintf(stderr, " ");
print_alu_dst(inst, true);
@ -436,12 +436,12 @@ print_load_imm(uint64_t inst)
print_alu_dst(inst, false);
if (waddr_add != QPU_W_NOP)
vc4_qpu_disasm_cond(stderr, cond_add);
fprintf(stderr, "%s", vc4_qpu_disasm_cond(cond_add));
fprintf(stderr, ", ");
print_alu_dst(inst, true);
if (waddr_mul != QPU_W_NOP)
vc4_qpu_disasm_cond(stderr, cond_mul);
fprintf(stderr, "%s", vc4_qpu_disasm_cond(cond_mul));;
fprintf(stderr, ", ");
fprintf(stderr, "0x%08x (%f)", imm, uif(imm));
@ -456,10 +456,9 @@ vc4_qpu_disasm(const uint64_t *instructions, int num_instructions)
switch (sig) {
case QPU_SIG_BRANCH:
fprintf(stderr, "branch");
vc4_qpu_disasm_cond_branch(stderr,
QPU_GET_FIELD(inst,
QPU_BRANCH_COND));
fprintf(stderr, "branch%s",
vc4_qpu_disasm_cond_branch(QPU_GET_FIELD(inst,
QPU_BRANCH_COND)));
fprintf(stderr, " %d", (uint32_t)inst);
break;

5
src/gallium/drivers/vc4/vc4_qpu_emit.c
View file

@ -246,9 +246,8 @@ vc4_generate_code_block(struct vc4_compile *c,
qir_for_each_inst(qinst, block) {
#if 0
fprintf(stderr, "translating qinst to qpu: ");
qir_dump_inst(qinst);
fprintf(stderr, "\n");
char *dump_inst = qir_dump_inst(qinst);
fprintf(stderr, "translating qinst to qpu: %s\n", dump_inst);
#endif
static const struct {