amd/rtld: update the ELF representation of LDS symbols
[mesa.git] / src / amd / common / ac_rtld.c
1 /*
2 * Copyright 2014-2019 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
24 #include "ac_rtld.h"
25
26 #include <gelf.h>
27 #include <libelf.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #include "ac_binary.h"
34 #include "ac_gpu_info.h"
35 #include "util/u_dynarray.h"
36 #include "util/u_math.h"
37
38 // Old distributions may not have this enum constant
39 #define MY_EM_AMDGPU 224
40
41 #ifndef STT_AMDGPU_LDS
42 #define STT_AMDGPU_LDS 13 // this is deprecated -- remove
43 #endif
44
45 #ifndef SHN_AMDGPU_LDS
46 #define SHN_AMDGPU_LDS 0xff00
47 #endif
48
49 #ifndef R_AMDGPU_NONE
50 #define R_AMDGPU_NONE 0
51 #define R_AMDGPU_ABS32_LO 1
52 #define R_AMDGPU_ABS32_HI 2
53 #define R_AMDGPU_ABS64 3
54 #define R_AMDGPU_REL32 4
55 #define R_AMDGPU_REL64 5
56 #define R_AMDGPU_ABS32 6
57 #define R_AMDGPU_GOTPCREL 7
58 #define R_AMDGPU_GOTPCREL32_LO 8
59 #define R_AMDGPU_GOTPCREL32_HI 9
60 #define R_AMDGPU_REL32_LO 10
61 #define R_AMDGPU_REL32_HI 11
62 #define R_AMDGPU_RELATIVE64 13
63 #endif
64
65 /* For the UMR disassembler. */
66 #define DEBUGGER_END_OF_CODE_MARKER 0xbf9f0000 /* invalid instruction */
67 #define DEBUGGER_NUM_MARKERS 5
68
69 struct ac_rtld_section {
70 bool is_rx : 1;
71 bool is_pasted_text : 1;
72 uint64_t offset;
73 const char *name;
74 };
75
76 struct ac_rtld_part {
77 Elf *elf;
78 struct ac_rtld_section *sections;
79 unsigned num_sections;
80 };
81
82 static void report_erroraf(const char *fmt, va_list va)
83 {
84 char *msg;
85 int ret = asprintf(&msg, fmt, va);
86 if (ret < 0)
87 msg = "(asprintf failed)";
88
89 fprintf(stderr, "ac_rtld error: %s\n", msg);
90
91 if (ret >= 0)
92 free(msg);
93 }
94
95 static void report_errorf(const char *fmt, ...) PRINTFLIKE(1, 2);
96
97 static void report_errorf(const char *fmt, ...)
98 {
99 va_list va;
100 va_start(va, fmt);
101 report_erroraf(fmt, va);
102 va_end(va);
103 }
104
105 static void report_elf_errorf(const char *fmt, ...) PRINTFLIKE(1, 2);
106
107 static void report_elf_errorf(const char *fmt, ...)
108 {
109 va_list va;
110 va_start(va, fmt);
111 report_erroraf(fmt, va);
112 va_end(va);
113
114 fprintf(stderr, "ELF error: %s\n", elf_errmsg(elf_errno()));
115 }
116
117 /**
118 * Find a symbol in a dynarray of struct ac_rtld_symbol by \p name and shader
119 * \p part_idx.
120 */
121 static const struct ac_rtld_symbol *find_symbol(const struct util_dynarray *symbols,
122 const char *name, unsigned part_idx)
123 {
124 util_dynarray_foreach(symbols, struct ac_rtld_symbol, symbol) {
125 if ((symbol->part_idx == ~0u || symbol->part_idx == part_idx) &&
126 !strcmp(name, symbol->name))
127 return symbol;
128 }
129 return 0;
130 }
131
132 static int compare_symbol_by_align(const void *lhsp, const void *rhsp)
133 {
134 const struct ac_rtld_symbol *lhs = lhsp;
135 const struct ac_rtld_symbol *rhs = rhsp;
136 if (rhs->align > lhs->align)
137 return 1;
138 if (rhs->align < lhs->align)
139 return -1;
140 return 0;
141 }
142
143 /**
144 * Sort the given symbol list by decreasing alignment and assign offsets.
145 */
146 static bool layout_symbols(struct ac_rtld_symbol *symbols, unsigned num_symbols,
147 uint64_t *ptotal_size)
148 {
149 qsort(symbols, num_symbols, sizeof(*symbols), compare_symbol_by_align);
150
151 uint64_t total_size = *ptotal_size;
152
153 for (unsigned i = 0; i < num_symbols; ++i) {
154 struct ac_rtld_symbol *s = &symbols[i];
155 assert(util_is_power_of_two_nonzero(s->align));
156
157 total_size = align64(total_size, s->align);
158 s->offset = total_size;
159
160 if (total_size + s->size < total_size) {
161 report_errorf("%s: size overflow", __FUNCTION__);
162 return false;
163 }
164
165 total_size += s->size;
166 }
167
168 *ptotal_size = total_size;
169 return true;
170 }
171
172 /**
173 * Read LDS symbols from the given \p section of the ELF of \p part and append
174 * them to the LDS symbols list.
175 *
176 * Shared LDS symbols are filtered out.
177 */
178 static bool read_private_lds_symbols(struct ac_rtld_binary *binary,
179 unsigned part_idx,
180 Elf_Scn *section,
181 uint32_t *lds_end_align)
182 {
183 #define report_if(cond) \
184 do { \
185 if ((cond)) { \
186 report_errorf(#cond); \
187 return false; \
188 } \
189 } while (false)
190 #define report_elf_if(cond) \
191 do { \
192 if ((cond)) { \
193 report_elf_errorf(#cond); \
194 return false; \
195 } \
196 } while (false)
197
198 struct ac_rtld_part *part = &binary->parts[part_idx];
199 Elf64_Shdr *shdr = elf64_getshdr(section);
200 uint32_t strtabidx = shdr->sh_link;
201 Elf_Data *symbols_data = elf_getdata(section, NULL);
202 report_elf_if(!symbols_data);
203
204 const Elf64_Sym *symbol = symbols_data->d_buf;
205 size_t num_symbols = symbols_data->d_size / sizeof(Elf64_Sym);
206
207 for (size_t j = 0; j < num_symbols; ++j, ++symbol) {
208 struct ac_rtld_symbol s = {};
209
210 if (ELF64_ST_TYPE(symbol->st_info) == STT_AMDGPU_LDS) {
211 /* old-style LDS symbols from initial prototype -- remove eventually */
212 s.align = MIN2(1u << (symbol->st_other >> 3), 1u << 16);
213 } else if (symbol->st_shndx == SHN_AMDGPU_LDS) {
214 s.align = MIN2(symbol->st_value, 1u << 16);
215 report_if(!util_is_power_of_two_nonzero(s.align));
216 } else
217 continue;
218
219 report_if(symbol->st_size > 1u << 29);
220
221 s.name = elf_strptr(part->elf, strtabidx, symbol->st_name);
222 s.size = symbol->st_size;
223 s.part_idx = part_idx;
224
225 if (!strcmp(s.name, "__lds_end")) {
226 report_elf_if(s.size != 0);
227 *lds_end_align = MAX2(*lds_end_align, s.align);
228 continue;
229 }
230
231 const struct ac_rtld_symbol *shared =
232 find_symbol(&binary->lds_symbols, s.name, part_idx);
233 if (shared) {
234 report_elf_if(s.align > shared->align);
235 report_elf_if(s.size > shared->size);
236 continue;
237 }
238
239 util_dynarray_append(&binary->lds_symbols, struct ac_rtld_symbol, s);
240 }
241
242 return true;
243
244 #undef report_if
245 #undef report_elf_if
246 }
247
248 /**
249 * Open a binary consisting of one or more shader parts.
250 *
251 * \param binary the uninitialized struct
252 * \param i binary opening parameters
253 */
254 bool ac_rtld_open(struct ac_rtld_binary *binary,
255 struct ac_rtld_open_info i)
256 {
257 /* One of the libelf implementations
258 * (http://www.mr511.de/software/english.htm) requires calling
259 * elf_version() before elf_memory().
260 */
261 elf_version(EV_CURRENT);
262
263 memset(binary, 0, sizeof(*binary));
264 memcpy(&binary->options, &i.options, sizeof(binary->options));
265 binary->num_parts = i.num_parts;
266 binary->parts = calloc(sizeof(*binary->parts), i.num_parts);
267 if (!binary->parts)
268 return false;
269
270 uint64_t pasted_text_size = 0;
271 uint64_t rx_align = 1;
272 uint64_t rx_size = 0;
273
274 #define report_if(cond) \
275 do { \
276 if ((cond)) { \
277 report_errorf(#cond); \
278 goto fail; \
279 } \
280 } while (false)
281 #define report_elf_if(cond) \
282 do { \
283 if ((cond)) { \
284 report_elf_errorf(#cond); \
285 goto fail; \
286 } \
287 } while (false)
288
289 /* Copy and layout shared LDS symbols. */
290 if (i.num_shared_lds_symbols) {
291 if (!util_dynarray_resize(&binary->lds_symbols, struct ac_rtld_symbol,
292 i.num_shared_lds_symbols))
293 goto fail;
294
295 memcpy(binary->lds_symbols.data, i.shared_lds_symbols, binary->lds_symbols.size);
296 }
297
298 util_dynarray_foreach(&binary->lds_symbols, struct ac_rtld_symbol, symbol)
299 symbol->part_idx = ~0u;
300
301 unsigned max_lds_size = 64 * 1024;
302
303 if (i.info->chip_class == GFX6 ||
304 (i.shader_type != MESA_SHADER_COMPUTE &&
305 i.shader_type != MESA_SHADER_FRAGMENT))
306 max_lds_size = 32 * 1024;
307
308 uint64_t shared_lds_size = 0;
309 if (!layout_symbols(binary->lds_symbols.data, i.num_shared_lds_symbols, &shared_lds_size))
310 goto fail;
311
312 if (shared_lds_size > max_lds_size) {
313 fprintf(stderr, "ac_rtld error(1): too much LDS (used = %u, max = %u)\n",
314 (unsigned)shared_lds_size, max_lds_size);
315 goto fail;
316 }
317 binary->lds_size = shared_lds_size;
318
319 /* First pass over all parts: open ELFs, pre-determine the placement of
320 * sections in the memory image, and collect and layout private LDS symbols. */
321 uint32_t lds_end_align = 0;
322
323 if (binary->options.halt_at_entry)
324 pasted_text_size += 4;
325
326 for (unsigned part_idx = 0; part_idx < i.num_parts; ++part_idx) {
327 struct ac_rtld_part *part = &binary->parts[part_idx];
328 unsigned part_lds_symbols_begin =
329 util_dynarray_num_elements(&binary->lds_symbols, struct ac_rtld_symbol);
330
331 part->elf = elf_memory((char *)i.elf_ptrs[part_idx], i.elf_sizes[part_idx]);
332 report_elf_if(!part->elf);
333
334 const Elf64_Ehdr *ehdr = elf64_getehdr(part->elf);
335 report_elf_if(!ehdr);
336 report_if(ehdr->e_machine != MY_EM_AMDGPU);
337
338 size_t section_str_index;
339 size_t num_shdrs;
340 report_elf_if(elf_getshdrstrndx(part->elf, &section_str_index) < 0);
341 report_elf_if(elf_getshdrnum(part->elf, &num_shdrs) < 0);
342
343 part->num_sections = num_shdrs;
344 part->sections = calloc(sizeof(*part->sections), num_shdrs);
345 report_if(!part->sections);
346
347 Elf_Scn *section = NULL;
348 while ((section = elf_nextscn(part->elf, section))) {
349 Elf64_Shdr *shdr = elf64_getshdr(section);
350 struct ac_rtld_section *s = &part->sections[elf_ndxscn(section)];
351 s->name = elf_strptr(part->elf, section_str_index, shdr->sh_name);
352 report_elf_if(!s->name);
353
354 /* Cannot actually handle linked objects yet */
355 report_elf_if(shdr->sh_addr != 0);
356
357 /* Alignment must be 0 or a power of two */
358 report_elf_if(shdr->sh_addralign & (shdr->sh_addralign - 1));
359 uint64_t sh_align = MAX2(shdr->sh_addralign, 1);
360
361 if (shdr->sh_flags & SHF_ALLOC &&
362 shdr->sh_type != SHT_NOTE) {
363 report_if(shdr->sh_flags & SHF_WRITE);
364
365 s->is_rx = true;
366
367 if (shdr->sh_flags & SHF_EXECINSTR) {
368 report_elf_if(shdr->sh_size & 3);
369
370 if (!strcmp(s->name, ".text"))
371 s->is_pasted_text = true;
372 }
373
374 if (s->is_pasted_text) {
375 s->offset = pasted_text_size;
376 pasted_text_size += shdr->sh_size;
377 } else {
378 rx_align = align(rx_align, sh_align);
379 rx_size = align(rx_size, sh_align);
380 s->offset = rx_size;
381 rx_size += shdr->sh_size;
382 }
383 } else if (shdr->sh_type == SHT_SYMTAB) {
384 if (!read_private_lds_symbols(binary, part_idx, section, &lds_end_align))
385 goto fail;
386 }
387 }
388
389 uint64_t part_lds_size = shared_lds_size;
390 if (!layout_symbols(
391 util_dynarray_element(&binary->lds_symbols, struct ac_rtld_symbol, part_lds_symbols_begin),
392 util_dynarray_num_elements(&binary->lds_symbols, struct ac_rtld_symbol) - part_lds_symbols_begin,
393 &part_lds_size))
394 goto fail;
395 binary->lds_size = MAX2(binary->lds_size, part_lds_size);
396 }
397
398 binary->rx_end_markers = pasted_text_size;
399 pasted_text_size += 4 * DEBUGGER_NUM_MARKERS;
400
401 /* __lds_end is a special symbol that points at the end of the memory
402 * occupied by other LDS symbols. Its alignment is taken as the
403 * maximum of its alignment over all shader parts where it occurs.
404 */
405 if (lds_end_align) {
406 binary->lds_size = align(binary->lds_size, lds_end_align);
407
408 struct ac_rtld_symbol *lds_end =
409 util_dynarray_grow(&binary->lds_symbols, struct ac_rtld_symbol, 1);
410 lds_end->name = "__lds_end";
411 lds_end->size = 0;
412 lds_end->align = lds_end_align;
413 lds_end->offset = binary->lds_size;
414 lds_end->part_idx = ~0u;
415 }
416
417 if (binary->lds_size > max_lds_size) {
418 fprintf(stderr, "ac_rtld error(2): too much LDS (used = %u, max = %u)\n",
419 (unsigned)binary->lds_size, max_lds_size);
420 goto fail;
421 }
422
423 /* Second pass: Adjust offsets of non-pasted text sections. */
424 binary->rx_size = pasted_text_size;
425 binary->rx_size = align(binary->rx_size, rx_align);
426
427 for (unsigned part_idx = 0; part_idx < i.num_parts; ++part_idx) {
428 struct ac_rtld_part *part = &binary->parts[part_idx];
429 size_t num_shdrs;
430 elf_getshdrnum(part->elf, &num_shdrs);
431
432 for (unsigned j = 0; j < num_shdrs; ++j) {
433 struct ac_rtld_section *s = &part->sections[j];
434 if (s->is_rx && !s->is_pasted_text)
435 s->offset += binary->rx_size;
436 }
437 }
438
439 binary->rx_size += rx_size;
440
441 return true;
442
443 #undef report_if
444 #undef report_elf_if
445
446 fail:
447 ac_rtld_close(binary);
448 return false;
449 }
450
451 void ac_rtld_close(struct ac_rtld_binary *binary)
452 {
453 for (unsigned i = 0; i < binary->num_parts; ++i) {
454 struct ac_rtld_part *part = &binary->parts[i];
455 free(part->sections);
456 elf_end(part->elf);
457 }
458
459 util_dynarray_fini(&binary->lds_symbols);
460 free(binary->parts);
461 binary->parts = NULL;
462 binary->num_parts = 0;
463 }
464
465 static bool get_section_by_name(struct ac_rtld_part *part, const char *name,
466 const char **data, size_t *nbytes)
467 {
468 for (unsigned i = 0; i < part->num_sections; ++i) {
469 struct ac_rtld_section *s = &part->sections[i];
470 if (s->name && !strcmp(name, s->name)) {
471 Elf_Scn *target_scn = elf_getscn(part->elf, i);
472 Elf_Data *target_data = elf_getdata(target_scn, NULL);
473 if (!target_data) {
474 report_elf_errorf("ac_rtld: get_section_by_name: elf_getdata");
475 return false;
476 }
477
478 *data = target_data->d_buf;
479 *nbytes = target_data->d_size;
480 return true;
481 }
482 }
483 return false;
484 }
485
486 bool ac_rtld_get_section_by_name(struct ac_rtld_binary *binary, const char *name,
487 const char **data, size_t *nbytes)
488 {
489 assert(binary->num_parts == 1);
490 return get_section_by_name(&binary->parts[0], name, data, nbytes);
491 }
492
493 bool ac_rtld_read_config(struct ac_rtld_binary *binary,
494 struct ac_shader_config *config)
495 {
496 for (unsigned i = 0; i < binary->num_parts; ++i) {
497 struct ac_rtld_part *part = &binary->parts[i];
498 const char *config_data;
499 size_t config_nbytes;
500
501 if (!get_section_by_name(part, ".AMDGPU.config",
502 &config_data, &config_nbytes))
503 return false;
504
505 /* TODO: be precise about scratch use? */
506 struct ac_shader_config c = {};
507 ac_parse_shader_binary_config(config_data, config_nbytes, true, &c);
508
509 config->num_sgprs = MAX2(config->num_sgprs, c.num_sgprs);
510 config->num_vgprs = MAX2(config->num_vgprs, c.num_vgprs);
511 config->spilled_sgprs = MAX2(config->spilled_sgprs, c.spilled_sgprs);
512 config->spilled_vgprs = MAX2(config->spilled_vgprs, c.spilled_vgprs);
513 config->scratch_bytes_per_wave = MAX2(config->scratch_bytes_per_wave,
514 c.scratch_bytes_per_wave);
515
516 assert(i == 0 || config->float_mode == c.float_mode);
517 config->float_mode = c.float_mode;
518
519 /* SPI_PS_INPUT_ENA/ADDR can't be combined. Only the value from
520 * the main shader part is used. */
521 assert(config->spi_ps_input_ena == 0 &&
522 config->spi_ps_input_addr == 0);
523 config->spi_ps_input_ena = c.spi_ps_input_ena;
524 config->spi_ps_input_addr = c.spi_ps_input_addr;
525
526 /* TODO: consistently use LDS symbols for this */
527 config->lds_size = MAX2(config->lds_size, c.lds_size);
528
529 /* TODO: Should we combine these somehow? It's currently only
530 * used for radeonsi's compute, where multiple parts aren't used. */
531 assert(config->rsrc1 == 0 && config->rsrc2 == 0);
532 config->rsrc1 = c.rsrc1;
533 config->rsrc2 = c.rsrc2;
534 }
535
536 return true;
537 }
538
539 static bool resolve_symbol(const struct ac_rtld_upload_info *u,
540 unsigned part_idx, const Elf64_Sym *sym,
541 const char *name, uint64_t *value)
542 {
543 /* TODO: properly disentangle the undef and the LDS cases once
544 * STT_AMDGPU_LDS is retired. */
545 if (sym->st_shndx == SHN_UNDEF || sym->st_shndx == SHN_AMDGPU_LDS) {
546 const struct ac_rtld_symbol *lds_sym =
547 find_symbol(&u->binary->lds_symbols, name, part_idx);
548
549 if (lds_sym) {
550 *value = lds_sym->offset;
551 return true;
552 }
553
554 /* TODO: resolve from other parts */
555
556 if (u->get_external_symbol(u->cb_data, name, value))
557 return true;
558
559 report_errorf("symbol %s: unknown", name);
560 return false;
561 }
562
563 struct ac_rtld_part *part = &u->binary->parts[part_idx];
564 if (sym->st_shndx >= part->num_sections) {
565 report_errorf("symbol %s: section out of bounds", name);
566 return false;
567 }
568
569 struct ac_rtld_section *s = &part->sections[sym->st_shndx];
570 if (!s->is_rx) {
571 report_errorf("symbol %s: bad section", name);
572 return false;
573 }
574
575 uint64_t section_base = u->rx_va + s->offset;
576
577 *value = section_base + sym->st_value;
578 return true;
579 }
580
581 static bool apply_relocs(const struct ac_rtld_upload_info *u,
582 unsigned part_idx, const Elf64_Shdr *reloc_shdr,
583 const Elf_Data *reloc_data)
584 {
585 #define report_if(cond) \
586 do { \
587 if ((cond)) { \
588 report_errorf(#cond); \
589 return false; \
590 } \
591 } while (false)
592 #define report_elf_if(cond) \
593 do { \
594 if ((cond)) { \
595 report_elf_errorf(#cond); \
596 return false; \
597 } \
598 } while (false)
599
600 struct ac_rtld_part *part = &u->binary->parts[part_idx];
601 Elf_Scn *target_scn = elf_getscn(part->elf, reloc_shdr->sh_info);
602 report_elf_if(!target_scn);
603
604 Elf_Data *target_data = elf_getdata(target_scn, NULL);
605 report_elf_if(!target_data);
606
607 Elf_Scn *symbols_scn = elf_getscn(part->elf, reloc_shdr->sh_link);
608 report_elf_if(!symbols_scn);
609
610 Elf64_Shdr *symbols_shdr = elf64_getshdr(symbols_scn);
611 report_elf_if(!symbols_shdr);
612 uint32_t strtabidx = symbols_shdr->sh_link;
613
614 Elf_Data *symbols_data = elf_getdata(symbols_scn, NULL);
615 report_elf_if(!symbols_data);
616
617 const Elf64_Sym *symbols = symbols_data->d_buf;
618 size_t num_symbols = symbols_data->d_size / sizeof(Elf64_Sym);
619
620 struct ac_rtld_section *s = &part->sections[reloc_shdr->sh_info];
621 report_if(!s->is_rx);
622
623 const char *orig_base = target_data->d_buf;
624 char *dst_base = u->rx_ptr + s->offset;
625 uint64_t va_base = u->rx_va + s->offset;
626
627 Elf64_Rel *rel = reloc_data->d_buf;
628 size_t num_relocs = reloc_data->d_size / sizeof(*rel);
629 for (size_t i = 0; i < num_relocs; ++i, ++rel) {
630 size_t r_sym = ELF64_R_SYM(rel->r_info);
631 unsigned r_type = ELF64_R_TYPE(rel->r_info);
632
633 const char *orig_ptr = orig_base + rel->r_offset;
634 char *dst_ptr = dst_base + rel->r_offset;
635 uint64_t va = va_base + rel->r_offset;
636
637 uint64_t symbol;
638 uint64_t addend;
639
640 if (r_sym == STN_UNDEF) {
641 symbol = 0;
642 } else {
643 report_elf_if(r_sym >= num_symbols);
644
645 const Elf64_Sym *sym = &symbols[r_sym];
646 const char *symbol_name =
647 elf_strptr(part->elf, strtabidx, sym->st_name);
648 report_elf_if(!symbol_name);
649
650 if (!resolve_symbol(u, part_idx, sym, symbol_name, &symbol))
651 return false;
652 }
653
654 /* TODO: Should we also support .rela sections, where the
655 * addend is part of the relocation record? */
656
657 /* Load the addend from the ELF instead of the destination,
658 * because the destination may be in VRAM. */
659 switch (r_type) {
660 case R_AMDGPU_ABS32:
661 case R_AMDGPU_ABS32_LO:
662 case R_AMDGPU_ABS32_HI:
663 case R_AMDGPU_REL32:
664 case R_AMDGPU_REL32_LO:
665 case R_AMDGPU_REL32_HI:
666 addend = *(const uint32_t *)orig_ptr;
667 break;
668 case R_AMDGPU_ABS64:
669 case R_AMDGPU_REL64:
670 addend = *(const uint64_t *)orig_ptr;
671 break;
672 default:
673 report_errorf("unsupported r_type == %u", r_type);
674 return false;
675 }
676
677 uint64_t abs = symbol + addend;
678
679 switch (r_type) {
680 case R_AMDGPU_ABS32:
681 assert((uint32_t)abs == abs);
682 case R_AMDGPU_ABS32_LO:
683 *(uint32_t *)dst_ptr = util_cpu_to_le32(abs);
684 break;
685 case R_AMDGPU_ABS32_HI:
686 *(uint32_t *)dst_ptr = util_cpu_to_le32(abs >> 32);
687 break;
688 case R_AMDGPU_ABS64:
689 *(uint64_t *)dst_ptr = util_cpu_to_le64(abs);
690 break;
691 case R_AMDGPU_REL32:
692 assert((int64_t)(int32_t)(abs - va) == (int64_t)(abs - va));
693 case R_AMDGPU_REL32_LO:
694 *(uint32_t *)dst_ptr = util_cpu_to_le32(abs - va);
695 break;
696 case R_AMDGPU_REL32_HI:
697 *(uint32_t *)dst_ptr = util_cpu_to_le32((abs - va) >> 32);
698 break;
699 case R_AMDGPU_REL64:
700 *(uint64_t *)dst_ptr = util_cpu_to_le64(abs - va);
701 break;
702 default:
703 unreachable("bad r_type");
704 }
705 }
706
707 return true;
708
709 #undef report_if
710 #undef report_elf_if
711 }
712
713 /**
714 * Upload the binary or binaries to the provided GPU buffers, including
715 * relocations.
716 */
717 bool ac_rtld_upload(struct ac_rtld_upload_info *u)
718 {
719 #define report_if(cond) \
720 do { \
721 if ((cond)) { \
722 report_errorf(#cond); \
723 return false; \
724 } \
725 } while (false)
726 #define report_elf_if(cond) \
727 do { \
728 if ((cond)) { \
729 report_errorf(#cond); \
730 return false; \
731 } \
732 } while (false)
733
734 if (u->binary->options.halt_at_entry) {
735 /* s_sethalt 1 */
736 *(uint32_t *)u->rx_ptr = util_cpu_to_le32(0xbf8d0001);
737 }
738
739 /* First pass: upload raw section data and lay out private LDS symbols. */
740 for (unsigned i = 0; i < u->binary->num_parts; ++i) {
741 struct ac_rtld_part *part = &u->binary->parts[i];
742
743 Elf_Scn *section = NULL;
744 while ((section = elf_nextscn(part->elf, section))) {
745 Elf64_Shdr *shdr = elf64_getshdr(section);
746 struct ac_rtld_section *s = &part->sections[elf_ndxscn(section)];
747
748 if (!s->is_rx)
749 continue;
750
751 report_if(shdr->sh_type != SHT_PROGBITS);
752
753 Elf_Data *data = elf_getdata(section, NULL);
754 report_elf_if(!data || data->d_size != shdr->sh_size);
755 memcpy(u->rx_ptr + s->offset, data->d_buf, shdr->sh_size);
756 }
757 }
758
759 if (u->binary->rx_end_markers) {
760 uint32_t *dst = (uint32_t *)(u->rx_ptr + u->binary->rx_end_markers);
761 for (unsigned i = 0; i < DEBUGGER_NUM_MARKERS; ++i)
762 *dst++ = util_cpu_to_le32(DEBUGGER_END_OF_CODE_MARKER);
763 }
764
765 /* Second pass: handle relocations, overwriting uploaded data where
766 * appropriate. */
767 for (unsigned i = 0; i < u->binary->num_parts; ++i) {
768 struct ac_rtld_part *part = &u->binary->parts[i];
769 Elf_Scn *section = NULL;
770 while ((section = elf_nextscn(part->elf, section))) {
771 Elf64_Shdr *shdr = elf64_getshdr(section);
772 if (shdr->sh_type == SHT_REL) {
773 Elf_Data *relocs = elf_getdata(section, NULL);
774 report_elf_if(!relocs || relocs->d_size != shdr->sh_size);
775 if (!apply_relocs(u, i, shdr, relocs))
776 return false;
777 } else if (shdr->sh_type == SHT_RELA) {
778 report_errorf("SHT_RELA not supported");
779 return false;
780 }
781 }
782 }
783
784 return true;
785
786 #undef report_if
787 #undef report_elf_if
788 }