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
parse_symbol_table(Elf_Data * symbol_table_data,const GElf_Shdr * symbol_table_header,struct radeon_shader_binary * binary)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
parse_relocs(Elf * elf,Elf_Data * relocs,Elf_Data * symbols,unsigned symbol_sh_link,struct radeon_shader_binary * binary)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 strncpy(reloc->name, symbol_name, sizeof(reloc->name)-1);
102 reloc->name[sizeof(reloc->name)-1] = 0;
103 }
104 }
105
radeon_elf_read(const char * elf_data,unsigned elf_size,struct radeon_shader_binary * binary)106 void radeon_elf_read(const char *elf_data, unsigned elf_size,
107 struct radeon_shader_binary *binary)
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, §ion_str_index);
127
128 while ((section = elf_nextscn(elf, section))) {
129 const char *name;
130 Elf_Data *section_data = NULL;
131 GElf_Shdr section_header;
132 if (gelf_getshdr(section, §ion_header) != §ion_header) {
133 fprintf(stderr, "Failed to read ELF section header\n");
134 return;
135 }
136 name = elf_strptr(elf, section_str_index, section_header.sh_name);
137 if (!strcmp(name, ".text")) {
138 section_data = elf_getdata(section, section_data);
139 binary->code_size = section_data->d_size;
140 binary->code = MALLOC(binary->code_size * sizeof(unsigned char));
141 memcpy(binary->code, section_data->d_buf, binary->code_size);
142 } else if (!strcmp(name, ".AMDGPU.config")) {
143 section_data = elf_getdata(section, section_data);
144 binary->config_size = section_data->d_size;
145 binary->config = MALLOC(binary->config_size * sizeof(unsigned char));
146 memcpy(binary->config, section_data->d_buf, binary->config_size);
147 } else if (!strcmp(name, ".AMDGPU.disasm")) {
148 /* Always read disassembly if it's available. */
149 section_data = elf_getdata(section, section_data);
150 binary->disasm_string = strndup(section_data->d_buf,
151 section_data->d_size);
152 } else if (!strncmp(name, ".rodata", 7)) {
153 section_data = elf_getdata(section, section_data);
154 binary->rodata_size = section_data->d_size;
155 binary->rodata = MALLOC(binary->rodata_size * sizeof(unsigned char));
156 memcpy(binary->rodata, section_data->d_buf, binary->rodata_size);
157 } else if (!strncmp(name, ".symtab", 7)) {
158 symbols = elf_getdata(section, section_data);
159 symbol_sh_link = section_header.sh_link;
160 parse_symbol_table(symbols, §ion_header, binary);
161 } else if (!strcmp(name, ".rel.text")) {
162 relocs = elf_getdata(section, section_data);
163 binary->reloc_count = section_header.sh_size /
164 section_header.sh_entsize;
165 }
166 }
167
168 parse_relocs(elf, relocs, symbols, symbol_sh_link, binary);
169
170 if (elf){
171 elf_end(elf);
172 }
173 FREE(elf_buffer);
174
175 /* Cache the config size per symbol */
176 if (binary->global_symbol_count) {
177 binary->config_size_per_symbol =
178 binary->config_size / binary->global_symbol_count;
179 } else {
180 binary->global_symbol_count = 1;
181 binary->config_size_per_symbol = binary->config_size;
182 }
183 }
184
radeon_shader_binary_config_start(const struct radeon_shader_binary * binary,uint64_t symbol_offset)185 const unsigned char *radeon_shader_binary_config_start(
186 const struct radeon_shader_binary *binary,
187 uint64_t symbol_offset)
188 {
189 unsigned i;
190 for (i = 0; i < binary->global_symbol_count; ++i) {
191 if (binary->global_symbol_offsets[i] == symbol_offset) {
192 unsigned offset = i * binary->config_size_per_symbol;
193 return binary->config + offset;
194 }
195 }
196 return binary->config;
197 }
198