Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright 2014 Advanced Micro Devices, Inc.
  3.  *
  4.  * Permission is hereby granted, free of charge, to any person obtaining a
  5.  * copy of this software and associated documentation files (the "Software"),
  6.  * to deal in the Software without restriction, including without limitation
  7.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8.  * and/or sell copies of the Software, and to permit persons to whom the
  9.  * Software is furnished to do so, subject to the following conditions:
  10.  *
  11.  * The above copyright notice and this permission notice (including the next
  12.  * paragraph) shall be included in all copies or substantial portions of the
  13.  * Software.
  14.  *
  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21.  * SOFTWARE.
  22.  *
  23.  * Authors: Tom Stellard <thomas.stellard@amd.com>
  24.  *
  25.  */
  26.  
  27. #include "radeon_elf_util.h"
  28. #include "r600_pipe_common.h"
  29.  
  30. #include "util/u_memory.h"
  31.  
  32. #include <gelf.h>
  33. #include <libelf.h>
  34. #include <stdio.h>
  35.  
  36. static void parse_symbol_table(Elf_Data *symbol_table_data,
  37.                                 const GElf_Shdr *symbol_table_header,
  38.                                 struct radeon_shader_binary *binary)
  39. {
  40.         GElf_Sym symbol;
  41.         unsigned i = 0;
  42.         unsigned symbol_count =
  43.                 symbol_table_header->sh_size / symbol_table_header->sh_entsize;
  44.  
  45.         /* We are over allocating this list, because symbol_count gives the
  46.          * total number of symbols, and we will only be filling the list
  47.          * with offsets of global symbols.  The memory savings from
  48.          * allocating the correct size of this list will be small, and
  49.          * I don't think it is worth the cost of pre-computing the number
  50.          * of global symbols.
  51.          */
  52.         binary->global_symbol_offsets = CALLOC(symbol_count, sizeof(uint64_t));
  53.  
  54.         while (gelf_getsym(symbol_table_data, i++, &symbol)) {
  55.                 unsigned i;
  56.                 if (GELF_ST_BIND(symbol.st_info) != STB_GLOBAL ||
  57.                     symbol.st_shndx == 0 /* Undefined symbol */) {
  58.                         continue;
  59.                 }
  60.  
  61.                 binary->global_symbol_offsets[binary->global_symbol_count] =
  62.                                         symbol.st_value;
  63.  
  64.                 /* Sort the list using bubble sort.  This list will usually
  65.                  * be small. */
  66.                 for (i = binary->global_symbol_count; i > 0; --i) {
  67.                         uint64_t lhs = binary->global_symbol_offsets[i - 1];
  68.                         uint64_t rhs = binary->global_symbol_offsets[i];
  69.                         if (lhs < rhs) {
  70.                                 break;
  71.                         }
  72.                         binary->global_symbol_offsets[i] = lhs;
  73.                         binary->global_symbol_offsets[i - 1] = rhs;
  74.                 }
  75.                 ++binary->global_symbol_count;
  76.         }
  77. }
  78.  
  79. static void parse_relocs(Elf *elf, Elf_Data *relocs, Elf_Data *symbols,
  80.                         unsigned symbol_sh_link,
  81.                         struct radeon_shader_binary *binary)
  82. {
  83.         unsigned i;
  84.  
  85.         if (!relocs || !symbols || !binary->reloc_count) {
  86.                 return;
  87.         }
  88.         binary->relocs = CALLOC(binary->reloc_count,
  89.                         sizeof(struct radeon_shader_reloc));
  90.         for (i = 0; i < binary->reloc_count; i++) {
  91.                 GElf_Sym symbol;
  92.                 GElf_Rel rel;
  93.                 char *symbol_name;
  94.                 struct radeon_shader_reloc *reloc = &binary->relocs[i];
  95.  
  96.                 gelf_getrel(relocs, i, &rel);
  97.                 gelf_getsym(symbols, GELF_R_SYM(rel.r_info), &symbol);
  98.                 symbol_name = elf_strptr(elf, symbol_sh_link, symbol.st_name);
  99.  
  100.                 reloc->offset = rel.r_offset;
  101.                 reloc->name = strdup(symbol_name);
  102.         }
  103. }
  104.  
  105. void radeon_elf_read(const char *elf_data, unsigned elf_size,
  106.                                         struct radeon_shader_binary *binary,
  107.                                         unsigned debug)
  108. {
  109.         char *elf_buffer;
  110.         Elf *elf;
  111.         Elf_Scn *section = NULL;
  112.         Elf_Data *symbols = NULL, *relocs = NULL;
  113.         size_t section_str_index;
  114.         unsigned symbol_sh_link = 0;
  115.  
  116.         /* One of the libelf implementations
  117.          * (http://www.mr511.de/software/english.htm) requires calling
  118.          * elf_version() before elf_memory().
  119.          */
  120.         elf_version(EV_CURRENT);
  121.         elf_buffer = MALLOC(elf_size);
  122.         memcpy(elf_buffer, elf_data, elf_size);
  123.  
  124.         elf = elf_memory(elf_buffer, elf_size);
  125.  
  126.         elf_getshdrstrndx(elf, &section_str_index);
  127.         binary->disassembled = 0;
  128.  
  129.         while ((section = elf_nextscn(elf, section))) {
  130.                 const char *name;
  131.                 Elf_Data *section_data = NULL;
  132.                 GElf_Shdr section_header;
  133.                 if (gelf_getshdr(section, &section_header) != &section_header) {
  134.                         fprintf(stderr, "Failed to read ELF section header\n");
  135.                         return;
  136.                 }
  137.                 name = elf_strptr(elf, section_str_index, section_header.sh_name);
  138.                 if (!strcmp(name, ".text")) {
  139.                         section_data = elf_getdata(section, section_data);
  140.                         binary->code_size = section_data->d_size;
  141.                         binary->code = MALLOC(binary->code_size * sizeof(unsigned char));
  142.                         memcpy(binary->code, section_data->d_buf, binary->code_size);
  143.                 } else if (!strcmp(name, ".AMDGPU.config")) {
  144.                         section_data = elf_getdata(section, section_data);
  145.                         binary->config_size = section_data->d_size;
  146.                         binary->config = MALLOC(binary->config_size * sizeof(unsigned char));
  147.                         memcpy(binary->config, section_data->d_buf, binary->config_size);
  148.                 } else if (debug && !strcmp(name, ".AMDGPU.disasm")) {
  149.                         binary->disassembled = 1;
  150.                         section_data = elf_getdata(section, section_data);
  151.                         fprintf(stderr, "\nShader Disassembly:\n\n");
  152.                         fprintf(stderr, "%.*s\n", (int)section_data->d_size,
  153.                                                   (char *)section_data->d_buf);
  154.                 } else if (!strncmp(name, ".rodata", 7)) {
  155.                         section_data = elf_getdata(section, section_data);
  156.                         binary->rodata_size = section_data->d_size;
  157.                         binary->rodata = MALLOC(binary->rodata_size * sizeof(unsigned char));
  158.                         memcpy(binary->rodata, section_data->d_buf, binary->rodata_size);
  159.                 } else if (!strncmp(name, ".symtab", 7)) {
  160.                         symbols = elf_getdata(section, section_data);
  161.                         symbol_sh_link = section_header.sh_link;
  162.                         parse_symbol_table(symbols, &section_header, binary);
  163.                 } else if (!strcmp(name, ".rel.text")) {
  164.                         relocs = elf_getdata(section, section_data);
  165.                         binary->reloc_count = section_header.sh_size /
  166.                                         section_header.sh_entsize;
  167.                 }
  168.         }
  169.  
  170.         parse_relocs(elf, relocs, symbols, symbol_sh_link, binary);
  171.  
  172.         if (elf){
  173.                 elf_end(elf);
  174.         }
  175.         FREE(elf_buffer);
  176.  
  177.         /* Cache the config size per symbol */
  178.         if (binary->global_symbol_count) {
  179.                 binary->config_size_per_symbol =
  180.                         binary->config_size / binary->global_symbol_count;
  181.         } else {
  182.                 binary->global_symbol_count = 1;
  183.                 binary->config_size_per_symbol = binary->config_size;
  184.         }
  185. }
  186.  
  187. const unsigned char *radeon_shader_binary_config_start(
  188.         const struct radeon_shader_binary *binary,
  189.         uint64_t symbol_offset)
  190. {
  191.         unsigned i;
  192.         for (i = 0; i < binary->global_symbol_count; ++i) {
  193.                 if (binary->global_symbol_offsets[i] == symbol_offset) {
  194.                         unsigned offset = i * binary->config_size_per_symbol;
  195.                         return binary->config + offset;
  196.                 }
  197.         }
  198.         return binary->config;
  199. }
  200.  
  201. void radeon_shader_binary_free_relocs(struct radeon_shader_reloc *relocs,
  202.                                         unsigned reloc_count)
  203. {
  204.         unsigned i;
  205.         for (i = 0; i < reloc_count; i++) {
  206.                 FREE(relocs[i].name);
  207.         }
  208.         FREE(relocs);
  209. }
  210.  
  211. void radeon_shader_binary_free_members(struct radeon_shader_binary *binary,
  212.                                         unsigned free_relocs)
  213. {
  214.         FREE(binary->code);
  215.         FREE(binary->config);
  216.         FREE(binary->rodata);
  217.  
  218.         if (free_relocs) {
  219.                 radeon_shader_binary_free_relocs(binary->relocs,
  220.                                                 binary->reloc_count);
  221.         }
  222. }
  223.