/* * Copyright 2014 Advanced Micro Devices, Inc. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include "ac_binary.h" #include "util/u_math.h" #include "util/u_memory.h" #include #include #include #include #define SPILLED_SGPRS 0x4 #define SPILLED_VGPRS 0x8 static void parse_symbol_table(Elf_Data *symbol_table_data, const GElf_Shdr *symbol_table_header, struct ac_shader_binary *binary) { GElf_Sym symbol; unsigned i = 0; unsigned symbol_count = symbol_table_header->sh_size / symbol_table_header->sh_entsize; /* We are over allocating this list, because symbol_count gives the * total number of symbols, and we will only be filling the list * with offsets of global symbols. The memory savings from * allocating the correct size of this list will be small, and * I don't think it is worth the cost of pre-computing the number * of global symbols. */ binary->global_symbol_offsets = CALLOC(symbol_count, sizeof(uint64_t)); while (gelf_getsym(symbol_table_data, i++, &symbol)) { unsigned i; if (GELF_ST_BIND(symbol.st_info) != STB_GLOBAL || symbol.st_shndx == 0 /* Undefined symbol */) { continue; } binary->global_symbol_offsets[binary->global_symbol_count] = symbol.st_value; /* Sort the list using bubble sort. This list will usually * be small. */ for (i = binary->global_symbol_count; i > 0; --i) { uint64_t lhs = binary->global_symbol_offsets[i - 1]; uint64_t rhs = binary->global_symbol_offsets[i]; if (lhs < rhs) { break; } binary->global_symbol_offsets[i] = lhs; binary->global_symbol_offsets[i - 1] = rhs; } ++binary->global_symbol_count; } } static void parse_relocs(Elf *elf, Elf_Data *relocs, Elf_Data *symbols, unsigned symbol_sh_link, struct ac_shader_binary *binary) { unsigned i; if (!relocs || !symbols || !binary->reloc_count) { return; } binary->relocs = CALLOC(binary->reloc_count, sizeof(struct ac_shader_reloc)); for (i = 0; i < binary->reloc_count; i++) { GElf_Sym symbol; GElf_Rel rel; char *symbol_name; struct ac_shader_reloc *reloc = &binary->relocs[i]; gelf_getrel(relocs, i, &rel); gelf_getsym(symbols, GELF_R_SYM(rel.r_info), &symbol); symbol_name = elf_strptr(elf, symbol_sh_link, symbol.st_name); reloc->offset = rel.r_offset; strncpy(reloc->name, symbol_name, sizeof(reloc->name)-1); reloc->name[sizeof(reloc->name)-1] = 0; } } bool ac_elf_read(const char *elf_data, unsigned elf_size, struct ac_shader_binary *binary) { char *elf_buffer; Elf *elf; Elf_Scn *section = NULL; Elf_Data *symbols = NULL, *relocs = NULL; size_t section_str_index; unsigned symbol_sh_link = 0; bool success = true; /* One of the libelf implementations * (http://www.mr511.de/software/english.htm) requires calling * elf_version() before elf_memory(). */ elf_version(EV_CURRENT); elf_buffer = MALLOC(elf_size); memcpy(elf_buffer, elf_data, elf_size); elf = elf_memory(elf_buffer, elf_size); elf_getshdrstrndx(elf, §ion_str_index); while ((section = elf_nextscn(elf, section))) { const char *name; Elf_Data *section_data = NULL; GElf_Shdr section_header; if (gelf_getshdr(section, §ion_header) != §ion_header) { fprintf(stderr, "Failed to read ELF section header\n"); success = false; break; } name = elf_strptr(elf, section_str_index, section_header.sh_name); if (!strcmp(name, ".text")) { section_data = elf_getdata(section, section_data); binary->code_size = section_data->d_size; binary->code = MALLOC(binary->code_size * sizeof(unsigned char)); memcpy(binary->code, section_data->d_buf, binary->code_size); } else if (!strcmp(name, ".AMDGPU.config")) { section_data = elf_getdata(section, section_data); binary->config_size = section_data->d_size; if (!binary->config_size) { fprintf(stderr, ".AMDGPU.config is empty!\n"); success = false; break; } binary->config = MALLOC(binary->config_size * sizeof(unsigned char)); memcpy(binary->config, section_data->d_buf, binary->config_size); } else if (!strcmp(name, ".AMDGPU.disasm")) { /* Always read disassembly if it's available. */ section_data = elf_getdata(section, section_data); binary->disasm_string = strndup(section_data->d_buf, section_data->d_size); } else if (!strncmp(name, ".rodata", 7)) { section_data = elf_getdata(section, section_data); binary->rodata_size = section_data->d_size; binary->rodata = MALLOC(binary->rodata_size * sizeof(unsigned char)); memcpy(binary->rodata, section_data->d_buf, binary->rodata_size); } else if (!strncmp(name, ".symtab", 7)) { symbols = elf_getdata(section, section_data); symbol_sh_link = section_header.sh_link; parse_symbol_table(symbols, §ion_header, binary); } else if (!strcmp(name, ".rel.text")) { relocs = elf_getdata(section, section_data); binary->reloc_count = section_header.sh_size / section_header.sh_entsize; } } parse_relocs(elf, relocs, symbols, symbol_sh_link, binary); if (elf){ elf_end(elf); } FREE(elf_buffer); /* Cache the config size per symbol */ if (binary->global_symbol_count) { binary->config_size_per_symbol = binary->config_size / binary->global_symbol_count; } else { binary->global_symbol_count = 1; binary->config_size_per_symbol = binary->config_size; } return success; } const unsigned char *ac_shader_binary_config_start( const struct ac_shader_binary *binary, uint64_t symbol_offset) { unsigned i; for (i = 0; i < binary->global_symbol_count; ++i) { if (binary->global_symbol_offsets[i] == symbol_offset) { unsigned offset = i * binary->config_size_per_symbol; return binary->config + offset; } } return binary->config; } /* Parse configuration data in .AMDGPU.config section format. */ void ac_parse_shader_binary_config(const char *data, size_t nbytes, bool really_needs_scratch, struct ac_shader_config *conf) { uint32_t wavesize = 0; for (size_t i = 0; i < nbytes; i += 8) { unsigned reg = util_le32_to_cpu(*(uint32_t*)(data + i)); unsigned value = util_le32_to_cpu(*(uint32_t*)(data + i + 4)); switch (reg) { case R_00B028_SPI_SHADER_PGM_RSRC1_PS: case R_00B128_SPI_SHADER_PGM_RSRC1_VS: case R_00B228_SPI_SHADER_PGM_RSRC1_GS: case R_00B848_COMPUTE_PGM_RSRC1: case R_00B428_SPI_SHADER_PGM_RSRC1_HS: conf->num_sgprs = MAX2(conf->num_sgprs, (G_00B028_SGPRS(value) + 1) * 8); conf->num_vgprs = MAX2(conf->num_vgprs, (G_00B028_VGPRS(value) + 1) * 4); conf->float_mode = G_00B028_FLOAT_MODE(value); conf->rsrc1 = value; break; case R_00B02C_SPI_SHADER_PGM_RSRC2_PS: conf->lds_size = MAX2(conf->lds_size, G_00B02C_EXTRA_LDS_SIZE(value)); break; case R_00B84C_COMPUTE_PGM_RSRC2: conf->lds_size = MAX2(conf->lds_size, G_00B84C_LDS_SIZE(value)); conf->rsrc2 = value; break; case R_0286CC_SPI_PS_INPUT_ENA: conf->spi_ps_input_ena = value; break; case R_0286D0_SPI_PS_INPUT_ADDR: conf->spi_ps_input_addr = value; break; case R_0286E8_SPI_TMPRING_SIZE: case R_00B860_COMPUTE_TMPRING_SIZE: /* WAVESIZE is in units of 256 dwords. */ wavesize = value; break; case SPILLED_SGPRS: conf->spilled_sgprs = value; break; case SPILLED_VGPRS: conf->spilled_vgprs = value; break; default: { static bool printed; if (!printed) { fprintf(stderr, "Warning: LLVM emitted unknown " "config register: 0x%x\n", reg); printed = true; } } break; } } if (!conf->spi_ps_input_addr) conf->spi_ps_input_addr = conf->spi_ps_input_ena; if (really_needs_scratch) { /* sgprs spills aren't spilling */ conf->scratch_bytes_per_wave = G_00B860_WAVESIZE(wavesize) * 256 * 4; } } static const char *scratch_rsrc_dword0_symbol = "SCRATCH_RSRC_DWORD0"; static const char *scratch_rsrc_dword1_symbol = "SCRATCH_RSRC_DWORD1"; void ac_shader_binary_read_config(struct ac_shader_binary *binary, struct ac_shader_config *conf, unsigned symbol_offset, bool supports_spill) { unsigned i; const char *config = (const char *)ac_shader_binary_config_start(binary, symbol_offset); bool really_needs_scratch = false; /* LLVM adds SGPR spills to the scratch size. * Find out if we really need the scratch buffer. */ if (supports_spill) { really_needs_scratch = true; } else { for (i = 0; i < binary->reloc_count; i++) { const struct ac_shader_reloc *reloc = &binary->relocs[i]; if (!strcmp(scratch_rsrc_dword0_symbol, reloc->name) || !strcmp(scratch_rsrc_dword1_symbol, reloc->name)) { really_needs_scratch = true; break; } } } ac_parse_shader_binary_config(config, binary->config_size_per_symbol, really_needs_scratch, conf); } void ac_shader_binary_clean(struct ac_shader_binary *b) { if (!b) return; FREE(b->code); FREE(b->config); FREE(b->rodata); FREE(b->global_symbol_offsets); FREE(b->relocs); FREE(b->disasm_string); FREE(b->llvm_ir_string); }