void trace_dump_compute_state(const struct pipe_compute_state *state)
{
if (!trace_dumping_enabled_locked())
return;
if (!state) {
trace_dump_null();
return;
}
trace_dump_struct_begin("pipe_compute_state");
trace_dump_member(uint, state, ir_type);
trace_dump_member_begin("prog");
if (state->prog && state->ir_type == PIPE_SHADER_IR_TGSI) {
static char str[64 * 1024];
tgsi_dump_str(state->prog, 0, str, sizeof(str));
trace_dump_string(str);
} else {
trace_dump_null();
}
trace_dump_member_end();
trace_dump_member(uint, state, req_local_mem);
trace_dump_member(uint, state, req_private_mem);
trace_dump_member(uint, state, req_input_mem);
trace_dump_struct_end();
}
void trace_dump_shader_state(const struct pipe_shader_state *state)
{
unsigned i;
if (!trace_dumping_enabled_locked())
return;
if (!state) {
trace_dump_null();
return;
}
trace_dump_struct_begin("pipe_shader_state");
trace_dump_member_begin("tokens");
if (state->tokens) {
static char str[64 * 1024];
tgsi_dump_str(state->tokens, 0, str, sizeof(str));
trace_dump_string(str);
} else {
trace_dump_null();
}
trace_dump_member_end();
trace_dump_member_begin("stream_output");
trace_dump_struct_begin("pipe_stream_output_info");
trace_dump_member(uint, &state->stream_output, num_outputs);
trace_dump_member_array(uint, &state->stream_output, stride);
trace_dump_member_begin("output");
trace_dump_array_begin();
for(i = 0; i < state->stream_output.num_outputs; ++i) {
trace_dump_elem_begin();
trace_dump_struct_begin(""); /* anonymous */
trace_dump_member(uint, &state->stream_output.output[i], register_index);
trace_dump_member(uint, &state->stream_output.output[i], start_component);
trace_dump_member(uint, &state->stream_output.output[i], num_components);
trace_dump_member(uint, &state->stream_output.output[i], output_buffer);
trace_dump_member(uint, &state->stream_output.output[i], dst_offset);
trace_dump_member(uint, &state->stream_output.output[i], stream);
trace_dump_struct_end();
trace_dump_elem_end();
}
trace_dump_array_end();
trace_dump_member_end(); // output
trace_dump_struct_end();
trace_dump_member_end(); // stream_output
trace_dump_struct_end();
}
void
util_dump_shader_state(FILE *stream, const struct pipe_shader_state *state)
{
char str[8192];
unsigned i;
if(!state) {
util_dump_null(stream);
return;
}
tgsi_dump_str(state->tokens, 0, str, sizeof(str));
util_dump_struct_begin(stream, "pipe_shader_state");
util_dump_member_begin(stream, "tokens");
util_dump_string(stream, str);
util_dump_member_end(stream);
util_dump_member_begin(stream, "stream_output");
util_dump_struct_begin(stream, "pipe_stream_output_info");
util_dump_member(stream, uint, &state->stream_output, num_outputs);
util_dump_array(stream, uint, state->stream_output.stride,
Elements(state->stream_output.stride));
util_dump_array_begin(stream);
for(i = 0; i < state->stream_output.num_outputs; ++i) {
util_dump_elem_begin(stream);
util_dump_struct_begin(stream, ""); /* anonymous */
util_dump_member(stream, uint, &state->stream_output.output[i], register_index);
util_dump_member(stream, uint, &state->stream_output.output[i], start_component);
util_dump_member(stream, uint, &state->stream_output.output[i], num_components);
util_dump_member(stream, uint, &state->stream_output.output[i], output_buffer);
util_dump_struct_end(stream);
util_dump_elem_end(stream);
}
util_dump_array_end(stream);
util_dump_struct_end(stream);
util_dump_member_end(stream);
util_dump_struct_end(stream);
}
void trace_dump_shader_state(const struct pipe_shader_state *state)
{
static char str[8192];
if (!trace_dumping_enabled_locked())
return;
if(!state) {
trace_dump_null();
return;
}
tgsi_dump_str(state->tokens, 0, str, sizeof(str));
trace_dump_struct_begin("pipe_shader_state");
trace_dump_member_begin("tokens");
trace_dump_string(str);
trace_dump_member_end();
trace_dump_struct_end();
}
int virgl_encode_shader_state(struct virgl_context *ctx,
uint32_t handle,
uint32_t type,
const struct pipe_stream_output_info *so_info,
const struct tgsi_token *tokens)
{
char *str, *sptr;
uint32_t shader_len, len;
bool bret;
int num_tokens = tgsi_num_tokens(tokens);
int str_total_size = 65536;
int retry_size = 1;
uint32_t left_bytes, base_hdr_size, strm_hdr_size, thispass;
bool first_pass;
str = CALLOC(1, str_total_size);
if (!str)
return -1;
do {
int old_size;
bret = tgsi_dump_str(tokens, TGSI_DUMP_FLOAT_AS_HEX, str, str_total_size);
if (bret == false) {
fprintf(stderr, "Failed to translate shader in available space - trying again\n");
old_size = str_total_size;
str_total_size = 65536 * ++retry_size;
str = REALLOC(str, old_size, str_total_size);
if (!str)
return -1;
}
} while (bret == false && retry_size < 10);
if (bret == false)
return -1;
shader_len = strlen(str) + 1;
left_bytes = shader_len;
base_hdr_size = 5;
strm_hdr_size = so_info->num_outputs ? so_info->num_outputs * 2 + 4 : 0;
first_pass = true;
sptr = str;
while (left_bytes) {
uint32_t length, offlen;
int hdr_len = base_hdr_size + (first_pass ? strm_hdr_size : 0);
if (ctx->cbuf->cdw + hdr_len + 1 > VIRGL_MAX_CMDBUF_DWORDS)
ctx->base.flush(&ctx->base, NULL, 0);
thispass = (VIRGL_MAX_CMDBUF_DWORDS - ctx->cbuf->cdw - hdr_len - 1) * 4;
length = MIN2(thispass, left_bytes);
len = ((length + 3) / 4) + hdr_len;
if (first_pass)
offlen = VIRGL_OBJ_SHADER_OFFSET_VAL(shader_len);
else
offlen = VIRGL_OBJ_SHADER_OFFSET_VAL((uintptr_t)sptr - (uintptr_t)str) | VIRGL_OBJ_SHADER_OFFSET_CONT;
virgl_emit_shader_header(ctx, handle, len, type, offlen, num_tokens);
virgl_emit_shader_streamout(ctx, first_pass ? so_info : NULL);
virgl_encoder_write_block(ctx->cbuf, (uint8_t *)sptr, length);
sptr += length;
first_pass = false;
left_bytes -= length;
}
FREE(str);
return 0;
}
