amd/common: removed unused ac_shader_binary functions

Reviewed-by: Bas Nieuwenhuizen <bas@basnieuwenhuizen.nl>
Reviewed-by: Samuel Pitoiset <samuel.pitoiset@gmail.com>
Reviewed-by: Marek Olšák <marek.olsak@amd.com>

diff --git a/src/amd/common/ac_binary.c b/src/amd/common/ac_binary.c
index c047666b656d2be446967efad11da1eb29a0ffbe..652ff228032050c2e7ca561f010b4ddbdd81ce86 100644 (file)
--- a/src/amd/common/ac_binary.c
+++ b/src/amd/common/ac_binary.c
@@ -35,177 +35,6 @@
 #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, &section_str_index);
-
-       while ((section = elf_nextscn(elf, section))) {
-               const char *name;
-               Elf_Data *section_data = NULL;
-               GElf_Shdr section_header;
-               if (gelf_getshdr(section, &section_header) != &section_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, &section_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,
@@ -273,52 +102,3 @@ void ac_parse_shader_binary_config(const char *data, size_t nbytes,
                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);
-}

diff --git a/src/amd/common/ac_binary.h b/src/amd/common/ac_binary.h
index b91ecb4317ba47b7840f21b0270523ecf4671a6d..3ac8562024db6317fbb6a400f8cc8afc852aedb6 100644 (file)
--- a/src/amd/common/ac_binary.h
+++ b/src/amd/common/ac_binary.h
@@ -84,29 +84,9 @@ struct ac_shader_config {
        unsigned rsrc2;
 };
 
-/*
- * Parse the elf binary stored in \p elf_data and create a
- * ac_shader_binary object.
- */
-bool ac_elf_read(const char *elf_data, unsigned elf_size,
-                struct ac_shader_binary *binary);
-
-/**
- * @returns A pointer to the start of the configuration information for
- * the function starting at \p symbol_offset of the binary.
- */
-const unsigned char *ac_shader_binary_config_start(
-       const struct ac_shader_binary *binary,
-       uint64_t symbol_offset);
-
 void ac_parse_shader_binary_config(const char *data, size_t nbytes,
                                   bool really_needs_scratch,
                                   struct ac_shader_config *conf);
-void ac_shader_binary_read_config(struct ac_shader_binary *binary,
-                                 struct ac_shader_config *conf,
-                                 unsigned symbol_offset,
-                                 bool supports_spill);
-void ac_shader_binary_clean(struct ac_shader_binary *b);
 
 #ifdef __cplusplus
 }