Commit | Line | Data |
---|---|---|
1ccea77e | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
442f04c3 JP |
2 | /* |
3 | * elf.c - ELF access library | |
4 | * | |
5 | * Adapted from kpatch (https://github.com/dynup/kpatch): | |
6 | * Copyright (C) 2013-2015 Josh Poimboeuf <jpoimboe@redhat.com> | |
7 | * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com> | |
442f04c3 JP |
8 | */ |
9 | ||
10 | #include <sys/types.h> | |
11 | #include <sys/stat.h> | |
25cf0d8a | 12 | #include <sys/mman.h> |
442f04c3 JP |
13 | #include <fcntl.h> |
14 | #include <stdio.h> | |
15 | #include <stdlib.h> | |
16 | #include <string.h> | |
17 | #include <unistd.h> | |
385d11b1 | 18 | #include <errno.h> |
5da6aea3 | 19 | #include <linux/interval_tree_generic.h> |
7786032e | 20 | #include <objtool/builtin.h> |
442f04c3 | 21 | |
7786032e VG |
22 | #include <objtool/elf.h> |
23 | #include <objtool/warn.h> | |
442f04c3 | 24 | |
ae358196 PZ |
25 | static inline u32 str_hash(const char *str) |
26 | { | |
27 | return jhash(str, strlen(str), 0); | |
28 | } | |
29 | ||
25cf0d8a PZ |
30 | #define __elf_table(name) (elf->name##_hash) |
31 | #define __elf_bits(name) (elf->name##_bits) | |
34f7c96d | 32 | |
02b54001 JP |
33 | #define __elf_table_entry(name, key) \ |
34 | __elf_table(name)[hash_min(key, __elf_bits(name))] | |
35 | ||
36 | #define elf_hash_add(name, node, key) \ | |
37 | ({ \ | |
38 | struct elf_hash_node *__node = node; \ | |
39 | __node->next = __elf_table_entry(name, key); \ | |
40 | __elf_table_entry(name, key) = __node; \ | |
41 | }) | |
42 | ||
43 | static inline void __elf_hash_del(struct elf_hash_node *node, | |
44 | struct elf_hash_node **head) | |
45 | { | |
46 | struct elf_hash_node *cur, *prev; | |
34f7c96d | 47 | |
02b54001 JP |
48 | if (node == *head) { |
49 | *head = node->next; | |
50 | return; | |
51 | } | |
52 | ||
53 | for (prev = NULL, cur = *head; cur; prev = cur, cur = cur->next) { | |
54 | if (cur == node) { | |
55 | prev->next = cur->next; | |
56 | break; | |
57 | } | |
58 | } | |
59 | } | |
60 | ||
61 | #define elf_hash_del(name, node, key) \ | |
62 | __elf_hash_del(node, &__elf_table_entry(name, key)) | |
63 | ||
64 | #define elf_list_entry(ptr, type, member) \ | |
65 | ({ \ | |
66 | typeof(ptr) __ptr = (ptr); \ | |
67 | __ptr ? container_of(__ptr, type, member) : NULL; \ | |
68 | }) | |
69 | ||
70 | #define elf_hash_for_each_possible(name, obj, member, key) \ | |
71 | for (obj = elf_list_entry(__elf_table_entry(name, key), typeof(*obj), member); \ | |
72 | obj; \ | |
73 | obj = elf_list_entry(obj->member.next, typeof(*(obj)), member)) | |
34f7c96d | 74 | |
25cf0d8a PZ |
75 | #define elf_alloc_hash(name, size) \ |
76 | ({ \ | |
77 | __elf_bits(name) = max(10, ilog2(size)); \ | |
02b54001 | 78 | __elf_table(name) = mmap(NULL, sizeof(struct elf_hash_node *) << __elf_bits(name), \ |
25cf0d8a PZ |
79 | PROT_READ|PROT_WRITE, \ |
80 | MAP_PRIVATE|MAP_ANON, -1, 0); \ | |
81 | if (__elf_table(name) == (void *)-1L) { \ | |
82 | WARN("mmap fail " #name); \ | |
83 | __elf_table(name) = NULL; \ | |
84 | } \ | |
85 | __elf_table(name); \ | |
86 | }) | |
34f7c96d | 87 | |
5da6aea3 | 88 | static inline unsigned long __sym_start(struct symbol *s) |
2a362ecc | 89 | { |
5da6aea3 | 90 | return s->offset; |
2a362ecc PZ |
91 | } |
92 | ||
5da6aea3 | 93 | static inline unsigned long __sym_last(struct symbol *s) |
2a362ecc | 94 | { |
5da6aea3 PZ |
95 | return s->offset + s->len - 1; |
96 | } | |
2a362ecc | 97 | |
5da6aea3 PZ |
98 | INTERVAL_TREE_DEFINE(struct symbol, node, unsigned long, __subtree_last, |
99 | __sym_start, __sym_last, static, __sym) | |
2a362ecc | 100 | |
5da6aea3 PZ |
101 | #define __sym_for_each(_iter, _tree, _start, _end) \ |
102 | for (_iter = __sym_iter_first((_tree), (_start), (_end)); \ | |
103 | _iter; _iter = __sym_iter_next(_iter, (_start), (_end))) | |
2a362ecc | 104 | |
4adb2368 PZ |
105 | struct symbol_hole { |
106 | unsigned long key; | |
107 | const struct symbol *sym; | |
108 | }; | |
109 | ||
110 | /* | |
111 | * Find !section symbol where @offset is after it. | |
112 | */ | |
113 | static int symbol_hole_by_offset(const void *key, const struct rb_node *node) | |
114 | { | |
115 | const struct symbol *s = rb_entry(node, struct symbol, node); | |
116 | struct symbol_hole *sh = (void *)key; | |
117 | ||
118 | if (sh->key < s->offset) | |
119 | return -1; | |
120 | ||
121 | if (sh->key >= s->offset + s->len) { | |
122 | if (s->type != STT_SECTION) | |
123 | sh->sym = s; | |
124 | return 1; | |
125 | } | |
126 | ||
127 | return 0; | |
128 | } | |
129 | ||
894e48ca | 130 | struct section *find_section_by_name(const struct elf *elf, const char *name) |
442f04c3 JP |
131 | { |
132 | struct section *sec; | |
133 | ||
25cf0d8a | 134 | elf_hash_for_each_possible(section_name, sec, name_hash, str_hash(name)) { |
442f04c3 JP |
135 | if (!strcmp(sec->name, name)) |
136 | return sec; | |
25cf0d8a | 137 | } |
442f04c3 JP |
138 | |
139 | return NULL; | |
140 | } | |
141 | ||
142 | static struct section *find_section_by_index(struct elf *elf, | |
143 | unsigned int idx) | |
144 | { | |
145 | struct section *sec; | |
146 | ||
25cf0d8a | 147 | elf_hash_for_each_possible(section, sec, hash, idx) { |
442f04c3 JP |
148 | if (sec->idx == idx) |
149 | return sec; | |
25cf0d8a | 150 | } |
442f04c3 JP |
151 | |
152 | return NULL; | |
153 | } | |
154 | ||
155 | static struct symbol *find_symbol_by_index(struct elf *elf, unsigned int idx) | |
156 | { | |
442f04c3 JP |
157 | struct symbol *sym; |
158 | ||
25cf0d8a | 159 | elf_hash_for_each_possible(symbol, sym, hash, idx) { |
65fb11a7 PZ |
160 | if (sym->idx == idx) |
161 | return sym; | |
25cf0d8a | 162 | } |
442f04c3 JP |
163 | |
164 | return NULL; | |
165 | } | |
166 | ||
167 | struct symbol *find_symbol_by_offset(struct section *sec, unsigned long offset) | |
168 | { | |
5da6aea3 PZ |
169 | struct rb_root_cached *tree = (struct rb_root_cached *)&sec->symbol_tree; |
170 | struct symbol *iter; | |
2a362ecc | 171 | |
5da6aea3 PZ |
172 | __sym_for_each(iter, tree, offset, offset) { |
173 | if (iter->offset == offset && iter->type != STT_SECTION) | |
174 | return iter; | |
2a362ecc | 175 | } |
7acfe531 JP |
176 | |
177 | return NULL; | |
178 | } | |
179 | ||
180 | struct symbol *find_func_by_offset(struct section *sec, unsigned long offset) | |
181 | { | |
5da6aea3 PZ |
182 | struct rb_root_cached *tree = (struct rb_root_cached *)&sec->symbol_tree; |
183 | struct symbol *iter; | |
7acfe531 | 184 | |
5da6aea3 PZ |
185 | __sym_for_each(iter, tree, offset, offset) { |
186 | if (iter->offset == offset && iter->type == STT_FUNC) | |
187 | return iter; | |
2a362ecc | 188 | } |
442f04c3 JP |
189 | |
190 | return NULL; | |
191 | } | |
192 | ||
b490f453 | 193 | struct symbol *find_symbol_containing(const struct section *sec, unsigned long offset) |
13810435 | 194 | { |
5da6aea3 PZ |
195 | struct rb_root_cached *tree = (struct rb_root_cached *)&sec->symbol_tree; |
196 | struct symbol *iter; | |
2a362ecc | 197 | |
5da6aea3 PZ |
198 | __sym_for_each(iter, tree, offset, offset) { |
199 | if (iter->type != STT_SECTION) | |
200 | return iter; | |
2a362ecc | 201 | } |
13810435 JP |
202 | |
203 | return NULL; | |
204 | } | |
205 | ||
4adb2368 PZ |
206 | /* |
207 | * Returns size of hole starting at @offset. | |
208 | */ | |
209 | int find_symbol_hole_containing(const struct section *sec, unsigned long offset) | |
210 | { | |
211 | struct symbol_hole hole = { | |
212 | .key = offset, | |
213 | .sym = NULL, | |
214 | }; | |
215 | struct rb_node *n; | |
216 | struct symbol *s; | |
217 | ||
218 | /* | |
219 | * Find the rightmost symbol for which @offset is after it. | |
220 | */ | |
5da6aea3 | 221 | n = rb_find(&hole, &sec->symbol_tree.rb_root, symbol_hole_by_offset); |
4adb2368 PZ |
222 | |
223 | /* found a symbol that contains @offset */ | |
224 | if (n) | |
225 | return 0; /* not a hole */ | |
226 | ||
227 | /* didn't find a symbol for which @offset is after it */ | |
228 | if (!hole.sym) | |
229 | return 0; /* not a hole */ | |
230 | ||
231 | /* @offset >= sym->offset + sym->len, find symbol after it */ | |
232 | n = rb_next(&hole.sym->node); | |
233 | if (!n) | |
234 | return -1; /* until end of address space */ | |
235 | ||
236 | /* hole until start of next symbol */ | |
237 | s = rb_entry(n, struct symbol, node); | |
238 | return s->offset - offset; | |
239 | } | |
240 | ||
53d20720 | 241 | struct symbol *find_func_containing(struct section *sec, unsigned long offset) |
2a362ecc | 242 | { |
5da6aea3 PZ |
243 | struct rb_root_cached *tree = (struct rb_root_cached *)&sec->symbol_tree; |
244 | struct symbol *iter; | |
2a362ecc | 245 | |
5da6aea3 PZ |
246 | __sym_for_each(iter, tree, offset, offset) { |
247 | if (iter->type == STT_FUNC) | |
248 | return iter; | |
2a362ecc PZ |
249 | } |
250 | ||
251 | return NULL; | |
252 | } | |
253 | ||
894e48ca | 254 | struct symbol *find_symbol_by_name(const struct elf *elf, const char *name) |
5c51f4ae JP |
255 | { |
256 | struct symbol *sym; | |
257 | ||
25cf0d8a | 258 | elf_hash_for_each_possible(symbol_name, sym, name_hash, str_hash(name)) { |
cdb3d057 PZ |
259 | if (!strcmp(sym->name, name)) |
260 | return sym; | |
25cf0d8a | 261 | } |
5c51f4ae JP |
262 | |
263 | return NULL; | |
264 | } | |
265 | ||
f1974222 | 266 | struct reloc *find_reloc_by_dest_range(const struct elf *elf, struct section *sec, |
8b5fa6bc | 267 | unsigned long offset, unsigned int len) |
442f04c3 | 268 | { |
f1974222 | 269 | struct reloc *reloc, *r = NULL; |
a5bd6236 | 270 | struct section *rsec; |
042ba73f | 271 | unsigned long o; |
442f04c3 | 272 | |
a5bd6236 JP |
273 | rsec = sec->rsec; |
274 | if (!rsec) | |
442f04c3 JP |
275 | return NULL; |
276 | ||
74b873e4 | 277 | for_offset_range(o, offset, offset + len) { |
25cf0d8a | 278 | elf_hash_for_each_possible(reloc, reloc, hash, |
a5bd6236 JP |
279 | sec_offset_hash(rsec, o)) { |
280 | if (reloc->sec != rsec) | |
74b873e4 PZ |
281 | continue; |
282 | ||
e4cbb9b8 JP |
283 | if (reloc_offset(reloc) >= offset && |
284 | reloc_offset(reloc) < offset + len) { | |
285 | if (!r || reloc_offset(reloc) < reloc_offset(r)) | |
f1974222 | 286 | r = reloc; |
74b873e4 | 287 | } |
8b5fa6bc | 288 | } |
74b873e4 PZ |
289 | if (r) |
290 | return r; | |
8b5fa6bc | 291 | } |
442f04c3 JP |
292 | |
293 | return NULL; | |
294 | } | |
295 | ||
f1974222 | 296 | struct reloc *find_reloc_by_dest(const struct elf *elf, struct section *sec, unsigned long offset) |
442f04c3 | 297 | { |
f1974222 | 298 | return find_reloc_by_dest_range(elf, sec, offset, 1); |
442f04c3 JP |
299 | } |
300 | ||
b4c96ef0 JP |
301 | static bool is_dwarf_section(struct section *sec) |
302 | { | |
303 | return !strncmp(sec->name, ".debug_", 7); | |
304 | } | |
305 | ||
442f04c3 JP |
306 | static int read_sections(struct elf *elf) |
307 | { | |
308 | Elf_Scn *s = NULL; | |
309 | struct section *sec; | |
310 | size_t shstrndx, sections_nr; | |
311 | int i; | |
312 | ||
313 | if (elf_getshdrnum(elf->elf, §ions_nr)) { | |
baa41469 | 314 | WARN_ELF("elf_getshdrnum"); |
442f04c3 JP |
315 | return -1; |
316 | } | |
317 | ||
318 | if (elf_getshdrstrndx(elf->elf, &shstrndx)) { | |
baa41469 | 319 | WARN_ELF("elf_getshdrstrndx"); |
442f04c3 JP |
320 | return -1; |
321 | } | |
322 | ||
25cf0d8a PZ |
323 | if (!elf_alloc_hash(section, sections_nr) || |
324 | !elf_alloc_hash(section_name, sections_nr)) | |
325 | return -1; | |
326 | ||
8045b8f0 TW |
327 | elf->section_data = calloc(sections_nr, sizeof(*sec)); |
328 | if (!elf->section_data) { | |
329 | perror("calloc"); | |
330 | return -1; | |
331 | } | |
442f04c3 | 332 | for (i = 0; i < sections_nr; i++) { |
8045b8f0 | 333 | sec = &elf->section_data[i]; |
442f04c3 | 334 | |
a196e171 | 335 | INIT_LIST_HEAD(&sec->symbol_list); |
442f04c3 | 336 | |
442f04c3 JP |
337 | s = elf_getscn(elf->elf, i); |
338 | if (!s) { | |
baa41469 | 339 | WARN_ELF("elf_getscn"); |
442f04c3 JP |
340 | return -1; |
341 | } | |
342 | ||
343 | sec->idx = elf_ndxscn(s); | |
344 | ||
345 | if (!gelf_getshdr(s, &sec->sh)) { | |
baa41469 | 346 | WARN_ELF("gelf_getshdr"); |
442f04c3 JP |
347 | return -1; |
348 | } | |
349 | ||
350 | sec->name = elf_strptr(elf->elf, shstrndx, sec->sh.sh_name); | |
351 | if (!sec->name) { | |
baa41469 | 352 | WARN_ELF("elf_strptr"); |
442f04c3 JP |
353 | return -1; |
354 | } | |
355 | ||
b4c96ef0 | 356 | if (sec->sh.sh_size != 0 && !is_dwarf_section(sec)) { |
df968c93 PV |
357 | sec->data = elf_getdata(s, NULL); |
358 | if (!sec->data) { | |
359 | WARN_ELF("elf_getdata"); | |
360 | return -1; | |
361 | } | |
362 | if (sec->data->d_off != 0 || | |
363 | sec->data->d_size != sec->sh.sh_size) { | |
364 | WARN("unexpected data attributes for %s", | |
365 | sec->name); | |
366 | return -1; | |
367 | } | |
442f04c3 | 368 | } |
53038996 PZ |
369 | |
370 | list_add_tail(&sec->list, &elf->sections); | |
25cf0d8a PZ |
371 | elf_hash_add(section, &sec->hash, sec->idx); |
372 | elf_hash_add(section_name, &sec->name_hash, str_hash(sec->name)); | |
eb0481bb JP |
373 | |
374 | if (is_reloc_sec(sec)) | |
ebcef730 | 375 | elf->num_relocs += sec_num_entries(sec); |
442f04c3 JP |
376 | } |
377 | ||
2daf7fab | 378 | if (opts.stats) { |
1e11f3fd | 379 | printf("nr_sections: %lu\n", (unsigned long)sections_nr); |
25cf0d8a PZ |
380 | printf("section_bits: %d\n", elf->section_bits); |
381 | } | |
1e11f3fd | 382 | |
442f04c3 JP |
383 | /* sanity check, one more call to elf_nextscn() should return NULL */ |
384 | if (elf_nextscn(elf->elf, s)) { | |
385 | WARN("section entry mismatch"); | |
386 | return -1; | |
387 | } | |
388 | ||
389 | return 0; | |
390 | } | |
391 | ||
9a7827b7 PZ |
392 | static void elf_add_symbol(struct elf *elf, struct symbol *sym) |
393 | { | |
394 | struct list_head *entry; | |
395 | struct rb_node *pnode; | |
5da6aea3 | 396 | struct symbol *iter; |
9a7827b7 | 397 | |
ead165fa PZ |
398 | INIT_LIST_HEAD(&sym->pv_target); |
399 | sym->alias = sym; | |
400 | ||
9a7827b7 PZ |
401 | sym->type = GELF_ST_TYPE(sym->sym.st_info); |
402 | sym->bind = GELF_ST_BIND(sym->sym.st_info); | |
403 | ||
753da417 JP |
404 | if (sym->type == STT_FILE) |
405 | elf->num_files++; | |
406 | ||
9a7827b7 PZ |
407 | sym->offset = sym->sym.st_value; |
408 | sym->len = sym->sym.st_size; | |
409 | ||
5da6aea3 PZ |
410 | __sym_for_each(iter, &sym->sec->symbol_tree, sym->offset, sym->offset) { |
411 | if (iter->offset == sym->offset && iter->type == sym->type) | |
412 | iter->alias = sym; | |
413 | } | |
414 | ||
415 | __sym_insert(sym, &sym->sec->symbol_tree); | |
9a7827b7 PZ |
416 | pnode = rb_prev(&sym->node); |
417 | if (pnode) | |
418 | entry = &rb_entry(pnode, struct symbol, node)->list; | |
419 | else | |
420 | entry = &sym->sec->symbol_list; | |
421 | list_add(&sym->list, entry); | |
25cf0d8a PZ |
422 | elf_hash_add(symbol, &sym->hash, sym->idx); |
423 | elf_hash_add(symbol_name, &sym->name_hash, str_hash(sym->name)); | |
9a7827b7 PZ |
424 | |
425 | /* | |
426 | * Don't store empty STT_NOTYPE symbols in the rbtree. They | |
427 | * can exist within a function, confusing the sorting. | |
428 | */ | |
429 | if (!sym->len) | |
5da6aea3 | 430 | __sym_remove(sym, &sym->sec->symbol_tree); |
9a7827b7 PZ |
431 | } |
432 | ||
442f04c3 JP |
433 | static int read_symbols(struct elf *elf) |
434 | { | |
28fe1d7b | 435 | struct section *symtab, *symtab_shndx, *sec; |
2a362ecc | 436 | struct symbol *sym, *pfunc; |
442f04c3 | 437 | int symbols_nr, i; |
13810435 | 438 | char *coldstr; |
28fe1d7b ST |
439 | Elf_Data *shndx_data = NULL; |
440 | Elf32_Word shndx; | |
442f04c3 JP |
441 | |
442 | symtab = find_section_by_name(elf, ".symtab"); | |
25cf0d8a PZ |
443 | if (symtab) { |
444 | symtab_shndx = find_section_by_name(elf, ".symtab_shndx"); | |
445 | if (symtab_shndx) | |
446 | shndx_data = symtab_shndx->data; | |
447 | ||
ebcef730 | 448 | symbols_nr = sec_num_entries(symtab); |
25cf0d8a | 449 | } else { |
1d489151 JP |
450 | /* |
451 | * A missing symbol table is actually possible if it's an empty | |
25cf0d8a PZ |
452 | * .o file. This can happen for thunk_64.o. Make sure to at |
453 | * least allocate the symbol hash tables so we can do symbol | |
454 | * lookups without crashing. | |
1d489151 | 455 | */ |
25cf0d8a | 456 | symbols_nr = 0; |
442f04c3 JP |
457 | } |
458 | ||
25cf0d8a PZ |
459 | if (!elf_alloc_hash(symbol, symbols_nr) || |
460 | !elf_alloc_hash(symbol_name, symbols_nr)) | |
461 | return -1; | |
442f04c3 | 462 | |
8045b8f0 TW |
463 | elf->symbol_data = calloc(symbols_nr, sizeof(*sym)); |
464 | if (!elf->symbol_data) { | |
465 | perror("calloc"); | |
466 | return -1; | |
467 | } | |
442f04c3 | 468 | for (i = 0; i < symbols_nr; i++) { |
8045b8f0 | 469 | sym = &elf->symbol_data[i]; |
442f04c3 JP |
470 | |
471 | sym->idx = i; | |
472 | ||
28fe1d7b ST |
473 | if (!gelf_getsymshndx(symtab->data, shndx_data, i, &sym->sym, |
474 | &shndx)) { | |
475 | WARN_ELF("gelf_getsymshndx"); | |
442f04c3 JP |
476 | goto err; |
477 | } | |
478 | ||
479 | sym->name = elf_strptr(elf->elf, symtab->sh.sh_link, | |
480 | sym->sym.st_name); | |
481 | if (!sym->name) { | |
baa41469 | 482 | WARN_ELF("elf_strptr"); |
442f04c3 JP |
483 | goto err; |
484 | } | |
485 | ||
28fe1d7b ST |
486 | if ((sym->sym.st_shndx > SHN_UNDEF && |
487 | sym->sym.st_shndx < SHN_LORESERVE) || | |
488 | (shndx_data && sym->sym.st_shndx == SHN_XINDEX)) { | |
489 | if (sym->sym.st_shndx != SHN_XINDEX) | |
490 | shndx = sym->sym.st_shndx; | |
491 | ||
492 | sym->sec = find_section_by_index(elf, shndx); | |
442f04c3 JP |
493 | if (!sym->sec) { |
494 | WARN("couldn't find section for symbol %s", | |
495 | sym->name); | |
496 | goto err; | |
497 | } | |
9a7827b7 | 498 | if (GELF_ST_TYPE(sym->sym.st_info) == STT_SECTION) { |
442f04c3 JP |
499 | sym->name = sym->sec->name; |
500 | sym->sec->sym = sym; | |
501 | } | |
502 | } else | |
503 | sym->sec = find_section_by_index(elf, 0); | |
504 | ||
9a7827b7 | 505 | elf_add_symbol(elf, sym); |
442f04c3 JP |
506 | } |
507 | ||
2daf7fab | 508 | if (opts.stats) { |
1e11f3fd | 509 | printf("nr_symbols: %lu\n", (unsigned long)symbols_nr); |
25cf0d8a PZ |
510 | printf("symbol_bits: %d\n", elf->symbol_bits); |
511 | } | |
1e11f3fd | 512 | |
13810435 JP |
513 | /* Create parent/child links for any cold subfunctions */ |
514 | list_for_each_entry(sec, &elf->sections, list) { | |
9290e772 | 515 | sec_for_each_sym(sec, sym) { |
f404a58d | 516 | char *pname; |
22566c16 | 517 | size_t pnamelen; |
13810435 JP |
518 | if (sym->type != STT_FUNC) |
519 | continue; | |
e000acc1 KCA |
520 | |
521 | if (sym->pfunc == NULL) | |
522 | sym->pfunc = sym; | |
523 | ||
524 | if (sym->cfunc == NULL) | |
525 | sym->cfunc = sym; | |
526 | ||
bcb6fb5d | 527 | coldstr = strstr(sym->name, ".cold"); |
08b393d0 JP |
528 | if (!coldstr) |
529 | continue; | |
530 | ||
22566c16 | 531 | pnamelen = coldstr - sym->name; |
f404a58d AP |
532 | pname = strndup(sym->name, pnamelen); |
533 | if (!pname) { | |
534 | WARN("%s(): failed to allocate memory", | |
535 | sym->name); | |
22566c16 AS |
536 | return -1; |
537 | } | |
538 | ||
22566c16 | 539 | pfunc = find_symbol_by_name(elf, pname); |
f404a58d | 540 | free(pname); |
08b393d0 JP |
541 | |
542 | if (!pfunc) { | |
543 | WARN("%s(): can't find parent function", | |
544 | sym->name); | |
0b9301fb | 545 | return -1; |
08b393d0 JP |
546 | } |
547 | ||
548 | sym->pfunc = pfunc; | |
549 | pfunc->cfunc = sym; | |
550 | ||
551 | /* | |
552 | * Unfortunately, -fnoreorder-functions puts the child | |
553 | * inside the parent. Remove the overlap so we can | |
554 | * have sane assumptions. | |
555 | * | |
556 | * Note that pfunc->len now no longer matches | |
557 | * pfunc->sym.st_size. | |
558 | */ | |
559 | if (sym->sec == pfunc->sec && | |
560 | sym->offset >= pfunc->offset && | |
561 | sym->offset + sym->len == pfunc->offset + pfunc->len) { | |
562 | pfunc->len -= sym->len; | |
13810435 JP |
563 | } |
564 | } | |
565 | } | |
566 | ||
442f04c3 JP |
567 | return 0; |
568 | ||
569 | err: | |
570 | free(sym); | |
571 | return -1; | |
572 | } | |
573 | ||
4abff6d4 | 574 | /* |
fcf93355 | 575 | * @sym's idx has changed. Update the relocs which reference it. |
4abff6d4 | 576 | */ |
fcf93355 | 577 | static int elf_update_sym_relocs(struct elf *elf, struct symbol *sym) |
ef47cc01 | 578 | { |
19526717 | 579 | struct reloc *reloc; |
4abff6d4 | 580 | |
ec24b927 JP |
581 | for (reloc = sym->relocs; reloc; reloc = reloc->sym_next_reloc) |
582 | set_reloc_sym(elf, reloc, reloc->sym->idx); | |
fcf93355 JP |
583 | |
584 | return 0; | |
4abff6d4 PZ |
585 | } |
586 | ||
587 | /* | |
ead165fa PZ |
588 | * The libelf API is terrible; gelf_update_sym*() takes a data block relative |
589 | * index value, *NOT* the symbol index. As such, iterate the data blocks and | |
590 | * adjust index until it fits. | |
591 | * | |
592 | * If no data block is found, allow adding a new data block provided the index | |
593 | * is only one past the end. | |
4abff6d4 | 594 | */ |
ead165fa PZ |
595 | static int elf_update_symbol(struct elf *elf, struct section *symtab, |
596 | struct section *symtab_shndx, struct symbol *sym) | |
4abff6d4 | 597 | { |
ead165fa PZ |
598 | Elf32_Word shndx = sym->sec ? sym->sec->idx : SHN_UNDEF; |
599 | Elf_Data *symtab_data = NULL, *shndx_data = NULL; | |
600 | Elf64_Xword entsize = symtab->sh.sh_entsize; | |
601 | int max_idx, idx = sym->idx; | |
602 | Elf_Scn *s, *t = NULL; | |
5141d3a0 ST |
603 | bool is_special_shndx = sym->sym.st_shndx >= SHN_LORESERVE && |
604 | sym->sym.st_shndx != SHN_XINDEX; | |
605 | ||
606 | if (is_special_shndx) | |
607 | shndx = sym->sym.st_shndx; | |
4abff6d4 PZ |
608 | |
609 | s = elf_getscn(elf->elf, symtab->idx); | |
610 | if (!s) { | |
611 | WARN_ELF("elf_getscn"); | |
612 | return -1; | |
613 | } | |
614 | ||
ead165fa PZ |
615 | if (symtab_shndx) { |
616 | t = elf_getscn(elf->elf, symtab_shndx->idx); | |
617 | if (!t) { | |
618 | WARN_ELF("elf_getscn"); | |
619 | return -1; | |
620 | } | |
4abff6d4 PZ |
621 | } |
622 | ||
ead165fa PZ |
623 | for (;;) { |
624 | /* get next data descriptor for the relevant sections */ | |
625 | symtab_data = elf_getdata(s, symtab_data); | |
626 | if (t) | |
627 | shndx_data = elf_getdata(t, shndx_data); | |
4abff6d4 | 628 | |
ead165fa PZ |
629 | /* end-of-list */ |
630 | if (!symtab_data) { | |
13f60e80 PZ |
631 | /* |
632 | * Over-allocate to avoid O(n^2) symbol creation | |
633 | * behaviour. The down side is that libelf doesn't | |
634 | * like this; see elf_truncate_section() for the fixup. | |
635 | */ | |
636 | int num = max(1U, sym->idx/3); | |
ead165fa | 637 | void *buf; |
4abff6d4 | 638 | |
ead165fa PZ |
639 | if (idx) { |
640 | /* we don't do holes in symbol tables */ | |
641 | WARN("index out of range"); | |
642 | return -1; | |
643 | } | |
4abff6d4 | 644 | |
ead165fa PZ |
645 | /* if @idx == 0, it's the next contiguous entry, create it */ |
646 | symtab_data = elf_newdata(s); | |
647 | if (t) | |
648 | shndx_data = elf_newdata(t); | |
649 | ||
13f60e80 | 650 | buf = calloc(num, entsize); |
ead165fa PZ |
651 | if (!buf) { |
652 | WARN("malloc"); | |
653 | return -1; | |
654 | } | |
655 | ||
656 | symtab_data->d_buf = buf; | |
13f60e80 | 657 | symtab_data->d_size = num * entsize; |
ead165fa PZ |
658 | symtab_data->d_align = 1; |
659 | symtab_data->d_type = ELF_T_SYM; | |
660 | ||
ff408273 | 661 | mark_sec_changed(elf, symtab, true); |
13f60e80 | 662 | symtab->truncate = true; |
ead165fa PZ |
663 | |
664 | if (t) { | |
13f60e80 PZ |
665 | buf = calloc(num, sizeof(Elf32_Word)); |
666 | if (!buf) { | |
667 | WARN("malloc"); | |
668 | return -1; | |
669 | } | |
670 | ||
671 | shndx_data->d_buf = buf; | |
672 | shndx_data->d_size = num * sizeof(Elf32_Word); | |
ead165fa PZ |
673 | shndx_data->d_align = sizeof(Elf32_Word); |
674 | shndx_data->d_type = ELF_T_WORD; | |
675 | ||
ff408273 | 676 | mark_sec_changed(elf, symtab_shndx, true); |
13f60e80 | 677 | symtab_shndx->truncate = true; |
ead165fa PZ |
678 | } |
679 | ||
680 | break; | |
681 | } | |
682 | ||
683 | /* empty blocks should not happen */ | |
684 | if (!symtab_data->d_size) { | |
685 | WARN("zero size data"); | |
4abff6d4 | 686 | return -1; |
ef47cc01 PZ |
687 | } |
688 | ||
ead165fa PZ |
689 | /* is this the right block? */ |
690 | max_idx = symtab_data->d_size / entsize; | |
691 | if (idx < max_idx) | |
692 | break; | |
693 | ||
694 | /* adjust index and try again */ | |
695 | idx -= max_idx; | |
696 | } | |
697 | ||
698 | /* something went side-ways */ | |
699 | if (idx < 0) { | |
700 | WARN("negative index"); | |
701 | return -1; | |
702 | } | |
703 | ||
704 | /* setup extended section index magic and write the symbol */ | |
5141d3a0 | 705 | if ((shndx >= SHN_UNDEF && shndx < SHN_LORESERVE) || is_special_shndx) { |
ead165fa PZ |
706 | sym->sym.st_shndx = shndx; |
707 | if (!shndx_data) | |
708 | shndx = 0; | |
709 | } else { | |
710 | sym->sym.st_shndx = SHN_XINDEX; | |
4abff6d4 | 711 | if (!shndx_data) { |
ead165fa | 712 | WARN("no .symtab_shndx"); |
ef47cc01 PZ |
713 | return -1; |
714 | } | |
ead165fa | 715 | } |
ef47cc01 | 716 | |
ead165fa PZ |
717 | if (!gelf_update_symshndx(symtab_data, shndx_data, idx, &sym->sym, shndx)) { |
718 | WARN_ELF("gelf_update_symshndx"); | |
719 | return -1; | |
4abff6d4 PZ |
720 | } |
721 | ||
ead165fa | 722 | return 0; |
4abff6d4 PZ |
723 | } |
724 | ||
725 | static struct symbol * | |
4c91be8e | 726 | __elf_create_symbol(struct elf *elf, struct symbol *sym) |
4abff6d4 PZ |
727 | { |
728 | struct section *symtab, *symtab_shndx; | |
ead165fa | 729 | Elf32_Word first_non_local, new_idx; |
4c91be8e | 730 | struct symbol *old; |
4abff6d4 PZ |
731 | |
732 | symtab = find_section_by_name(elf, ".symtab"); | |
733 | if (symtab) { | |
734 | symtab_shndx = find_section_by_name(elf, ".symtab_shndx"); | |
4abff6d4 PZ |
735 | } else { |
736 | WARN("no .symtab"); | |
737 | return NULL; | |
738 | } | |
739 | ||
ebcef730 | 740 | new_idx = sec_num_entries(symtab); |
4abff6d4 | 741 | |
4c91be8e PZ |
742 | if (GELF_ST_BIND(sym->sym.st_info) != STB_LOCAL) |
743 | goto non_local; | |
ead165fa PZ |
744 | |
745 | /* | |
746 | * Move the first global symbol, as per sh_info, into a new, higher | |
747 | * symbol index. This fees up a spot for a new local symbol. | |
748 | */ | |
749 | first_non_local = symtab->sh.sh_info; | |
ead165fa PZ |
750 | old = find_symbol_by_index(elf, first_non_local); |
751 | if (old) { | |
ead165fa | 752 | |
02b54001 JP |
753 | elf_hash_del(symbol, &old->hash, old->idx); |
754 | elf_hash_add(symbol, &old->hash, new_idx); | |
755 | old->idx = new_idx; | |
ead165fa | 756 | |
ead165fa PZ |
757 | if (elf_update_symbol(elf, symtab, symtab_shndx, old)) { |
758 | WARN("elf_update_symbol move"); | |
4abff6d4 PZ |
759 | return NULL; |
760 | } | |
ead165fa | 761 | |
fcf93355 JP |
762 | if (elf_update_sym_relocs(elf, old)) |
763 | return NULL; | |
764 | ||
ead165fa | 765 | new_idx = first_non_local; |
4abff6d4 PZ |
766 | } |
767 | ||
4c91be8e PZ |
768 | /* |
769 | * Either way, we will add a LOCAL symbol. | |
770 | */ | |
771 | symtab->sh.sh_info += 1; | |
772 | ||
773 | non_local: | |
ead165fa PZ |
774 | sym->idx = new_idx; |
775 | if (elf_update_symbol(elf, symtab, symtab_shndx, sym)) { | |
776 | WARN("elf_update_symbol"); | |
4abff6d4 PZ |
777 | return NULL; |
778 | } | |
779 | ||
13f60e80 | 780 | symtab->sh.sh_size += symtab->sh.sh_entsize; |
ff408273 | 781 | mark_sec_changed(elf, symtab, true); |
13f60e80 PZ |
782 | |
783 | if (symtab_shndx) { | |
784 | symtab_shndx->sh.sh_size += sizeof(Elf32_Word); | |
ff408273 | 785 | mark_sec_changed(elf, symtab_shndx, true); |
13f60e80 PZ |
786 | } |
787 | ||
4c91be8e PZ |
788 | return sym; |
789 | } | |
790 | ||
791 | static struct symbol * | |
792 | elf_create_section_symbol(struct elf *elf, struct section *sec) | |
793 | { | |
794 | struct symbol *sym = calloc(1, sizeof(*sym)); | |
795 | ||
796 | if (!sym) { | |
797 | perror("malloc"); | |
798 | return NULL; | |
799 | } | |
ead165fa | 800 | |
4c91be8e PZ |
801 | sym->name = sec->name; |
802 | sym->sec = sec; | |
803 | ||
804 | // st_name 0 | |
805 | sym->sym.st_info = GELF_ST_INFO(STB_LOCAL, STT_SECTION); | |
806 | // st_other 0 | |
807 | // st_value 0 | |
808 | // st_size 0 | |
809 | ||
810 | sym = __elf_create_symbol(elf, sym); | |
811 | if (sym) | |
812 | elf_add_symbol(elf, sym); | |
4abff6d4 PZ |
813 | |
814 | return sym; | |
815 | } | |
816 | ||
9f2899fe PZ |
817 | static int elf_add_string(struct elf *elf, struct section *strtab, char *str); |
818 | ||
819 | struct symbol * | |
820 | elf_create_prefix_symbol(struct elf *elf, struct symbol *orig, long size) | |
821 | { | |
822 | struct symbol *sym = calloc(1, sizeof(*sym)); | |
823 | size_t namelen = strlen(orig->name) + sizeof("__pfx_"); | |
824 | char *name = malloc(namelen); | |
825 | ||
826 | if (!sym || !name) { | |
827 | perror("malloc"); | |
828 | return NULL; | |
829 | } | |
830 | ||
831 | snprintf(name, namelen, "__pfx_%s", orig->name); | |
832 | ||
833 | sym->name = name; | |
834 | sym->sec = orig->sec; | |
835 | ||
836 | sym->sym.st_name = elf_add_string(elf, NULL, name); | |
837 | sym->sym.st_info = orig->sym.st_info; | |
838 | sym->sym.st_value = orig->sym.st_value - size; | |
839 | sym->sym.st_size = size; | |
840 | ||
841 | sym = __elf_create_symbol(elf, sym); | |
842 | if (sym) | |
843 | elf_add_symbol(elf, sym); | |
844 | ||
845 | return sym; | |
846 | } | |
847 | ||
6342a20e JP |
848 | static struct reloc *elf_init_reloc(struct elf *elf, struct section *rsec, |
849 | unsigned int reloc_idx, | |
850 | unsigned long offset, struct symbol *sym, | |
851 | s64 addend, unsigned int type) | |
852 | { | |
e0a9349b | 853 | struct reloc *reloc, empty = { 0 }; |
6342a20e | 854 | |
ebcef730 JP |
855 | if (reloc_idx >= sec_num_entries(rsec)) { |
856 | WARN("%s: bad reloc_idx %u for %s with %d relocs", | |
857 | __func__, reloc_idx, rsec->name, sec_num_entries(rsec)); | |
6342a20e JP |
858 | return NULL; |
859 | } | |
860 | ||
ebcef730 | 861 | reloc = &rsec->relocs[reloc_idx]; |
e0a9349b JP |
862 | |
863 | if (memcmp(reloc, &empty, sizeof(empty))) { | |
864 | WARN("%s: %s: reloc %d already initialized!", | |
865 | __func__, rsec->name, reloc_idx); | |
6342a20e JP |
866 | return NULL; |
867 | } | |
6342a20e | 868 | |
6342a20e | 869 | reloc->sec = rsec; |
6342a20e | 870 | reloc->sym = sym; |
6342a20e | 871 | |
ec24b927 JP |
872 | set_reloc_offset(elf, reloc, offset); |
873 | set_reloc_sym(elf, reloc, sym->idx); | |
874 | set_reloc_type(elf, reloc, type); | |
875 | set_reloc_addend(elf, reloc, addend); | |
fcf93355 | 876 | |
6342a20e | 877 | elf_hash_add(reloc, &reloc->hash, reloc_hash(reloc)); |
890f10a4 JP |
878 | reloc->sym_next_reloc = sym->relocs; |
879 | sym->relocs = reloc; | |
6342a20e | 880 | |
6342a20e JP |
881 | return reloc; |
882 | } | |
883 | ||
884 | struct reloc *elf_init_reloc_text_sym(struct elf *elf, struct section *sec, | |
885 | unsigned long offset, | |
886 | unsigned int reloc_idx, | |
887 | struct section *insn_sec, | |
888 | unsigned long insn_off) | |
4abff6d4 PZ |
889 | { |
890 | struct symbol *sym = insn_sec->sym; | |
891 | int addend = insn_off; | |
892 | ||
6342a20e JP |
893 | if (!(insn_sec->sh.sh_flags & SHF_EXECINSTR)) { |
894 | WARN("bad call to %s() for data symbol %s", | |
895 | __func__, sym->name); | |
896 | return NULL; | |
897 | } | |
898 | ||
4abff6d4 PZ |
899 | if (!sym) { |
900 | /* | |
901 | * Due to how weak functions work, we must use section based | |
902 | * relocations. Symbol based relocations would result in the | |
903 | * weak and non-weak function annotations being overlaid on the | |
904 | * non-weak function after linking. | |
905 | */ | |
906 | sym = elf_create_section_symbol(elf, insn_sec); | |
907 | if (!sym) | |
6342a20e | 908 | return NULL; |
4abff6d4 PZ |
909 | |
910 | insn_sec->sym = sym; | |
ef47cc01 PZ |
911 | } |
912 | ||
6342a20e JP |
913 | return elf_init_reloc(elf, sec->rsec, reloc_idx, offset, sym, addend, |
914 | elf_text_rela_type(elf)); | |
915 | } | |
916 | ||
917 | struct reloc *elf_init_reloc_data_sym(struct elf *elf, struct section *sec, | |
918 | unsigned long offset, | |
919 | unsigned int reloc_idx, | |
920 | struct symbol *sym, | |
921 | s64 addend) | |
922 | { | |
923 | if (sym->sec && (sec->sh.sh_flags & SHF_EXECINSTR)) { | |
924 | WARN("bad call to %s() for text symbol %s", | |
925 | __func__, sym->name); | |
926 | return NULL; | |
927 | } | |
928 | ||
929 | return elf_init_reloc(elf, sec->rsec, reloc_idx, offset, sym, addend, | |
930 | elf_data_rela_type(elf)); | |
34f7c96d PZ |
931 | } |
932 | ||
f1974222 | 933 | static int read_relocs(struct elf *elf) |
442f04c3 | 934 | { |
eb0481bb | 935 | unsigned long nr_reloc, max_reloc = 0; |
a5bd6236 | 936 | struct section *rsec; |
f1974222 | 937 | struct reloc *reloc; |
442f04c3 | 938 | unsigned int symndx; |
19526717 PZ |
939 | struct symbol *sym; |
940 | int i; | |
442f04c3 | 941 | |
eb0481bb | 942 | if (!elf_alloc_hash(reloc, elf->num_relocs)) |
25cf0d8a PZ |
943 | return -1; |
944 | ||
a5bd6236 | 945 | list_for_each_entry(rsec, &elf->sections, list) { |
eb0481bb | 946 | if (!is_reloc_sec(rsec)) |
442f04c3 JP |
947 | continue; |
948 | ||
a5bd6236 JP |
949 | rsec->base = find_section_by_index(elf, rsec->sh.sh_info); |
950 | if (!rsec->base) { | |
f1974222 | 951 | WARN("can't find base section for reloc section %s", |
a5bd6236 | 952 | rsec->name); |
442f04c3 JP |
953 | return -1; |
954 | } | |
955 | ||
a5bd6236 | 956 | rsec->base->rsec = rsec; |
442f04c3 | 957 | |
f1974222 | 958 | nr_reloc = 0; |
ebcef730 JP |
959 | rsec->relocs = calloc(sec_num_entries(rsec), sizeof(*reloc)); |
960 | if (!rsec->relocs) { | |
8045b8f0 TW |
961 | perror("calloc"); |
962 | return -1; | |
963 | } | |
ebcef730 JP |
964 | for (i = 0; i < sec_num_entries(rsec); i++) { |
965 | reloc = &rsec->relocs[i]; | |
53257a97 | 966 | |
a5bd6236 | 967 | reloc->sec = rsec; |
ec24b927 | 968 | symndx = reloc_sym(reloc); |
19526717 | 969 | reloc->sym = sym = find_symbol_by_index(elf, symndx); |
f1974222 MH |
970 | if (!reloc->sym) { |
971 | WARN("can't find reloc entry symbol %d for %s", | |
a5bd6236 | 972 | symndx, rsec->name); |
442f04c3 JP |
973 | return -1; |
974 | } | |
042ba73f | 975 | |
25cf0d8a | 976 | elf_hash_add(reloc, &reloc->hash, reloc_hash(reloc)); |
890f10a4 JP |
977 | reloc->sym_next_reloc = sym->relocs; |
978 | sym->relocs = reloc; | |
3a647607 | 979 | |
f1974222 | 980 | nr_reloc++; |
442f04c3 | 981 | } |
f1974222 | 982 | max_reloc = max(max_reloc, nr_reloc); |
1e11f3fd PZ |
983 | } |
984 | ||
2daf7fab | 985 | if (opts.stats) { |
f1974222 | 986 | printf("max_reloc: %lu\n", max_reloc); |
eb0481bb | 987 | printf("num_relocs: %lu\n", elf->num_relocs); |
25cf0d8a | 988 | printf("reloc_bits: %d\n", elf->reloc_bits); |
442f04c3 JP |
989 | } |
990 | ||
991 | return 0; | |
992 | } | |
993 | ||
bc359ff2 | 994 | struct elf *elf_open_read(const char *name, int flags) |
442f04c3 JP |
995 | { |
996 | struct elf *elf; | |
627fce14 | 997 | Elf_Cmd cmd; |
442f04c3 JP |
998 | |
999 | elf_version(EV_CURRENT); | |
1000 | ||
1001 | elf = malloc(sizeof(*elf)); | |
1002 | if (!elf) { | |
1003 | perror("malloc"); | |
1004 | return NULL; | |
1005 | } | |
9f71fbcd | 1006 | memset(elf, 0, sizeof(*elf)); |
442f04c3 JP |
1007 | |
1008 | INIT_LIST_HEAD(&elf->sections); | |
1009 | ||
627fce14 | 1010 | elf->fd = open(name, flags); |
442f04c3 | 1011 | if (elf->fd == -1) { |
385d11b1 JP |
1012 | fprintf(stderr, "objtool: Can't open '%s': %s\n", |
1013 | name, strerror(errno)); | |
442f04c3 JP |
1014 | goto err; |
1015 | } | |
1016 | ||
627fce14 JP |
1017 | if ((flags & O_ACCMODE) == O_RDONLY) |
1018 | cmd = ELF_C_READ_MMAP; | |
1019 | else if ((flags & O_ACCMODE) == O_RDWR) | |
1020 | cmd = ELF_C_RDWR; | |
1021 | else /* O_WRONLY */ | |
1022 | cmd = ELF_C_WRITE; | |
1023 | ||
1024 | elf->elf = elf_begin(elf->fd, cmd, NULL); | |
442f04c3 | 1025 | if (!elf->elf) { |
baa41469 | 1026 | WARN_ELF("elf_begin"); |
442f04c3 JP |
1027 | goto err; |
1028 | } | |
1029 | ||
1030 | if (!gelf_getehdr(elf->elf, &elf->ehdr)) { | |
baa41469 | 1031 | WARN_ELF("gelf_getehdr"); |
442f04c3 JP |
1032 | goto err; |
1033 | } | |
1034 | ||
1035 | if (read_sections(elf)) | |
1036 | goto err; | |
1037 | ||
1038 | if (read_symbols(elf)) | |
1039 | goto err; | |
1040 | ||
f1974222 | 1041 | if (read_relocs(elf)) |
442f04c3 JP |
1042 | goto err; |
1043 | ||
1044 | return elf; | |
1045 | ||
1046 | err: | |
1047 | elf_close(elf); | |
1048 | return NULL; | |
1049 | } | |
1050 | ||
417a4dc9 PZ |
1051 | static int elf_add_string(struct elf *elf, struct section *strtab, char *str) |
1052 | { | |
1053 | Elf_Data *data; | |
1054 | Elf_Scn *s; | |
1055 | int len; | |
1056 | ||
1057 | if (!strtab) | |
1058 | strtab = find_section_by_name(elf, ".strtab"); | |
1059 | if (!strtab) { | |
1060 | WARN("can't find .strtab section"); | |
1061 | return -1; | |
1062 | } | |
1063 | ||
1064 | s = elf_getscn(elf->elf, strtab->idx); | |
1065 | if (!s) { | |
1066 | WARN_ELF("elf_getscn"); | |
1067 | return -1; | |
1068 | } | |
1069 | ||
1070 | data = elf_newdata(s); | |
1071 | if (!data) { | |
1072 | WARN_ELF("elf_newdata"); | |
1073 | return -1; | |
1074 | } | |
1075 | ||
1076 | data->d_buf = str; | |
1077 | data->d_size = strlen(str) + 1; | |
1078 | data->d_align = 1; | |
1079 | ||
fe255fe6 JL |
1080 | len = strtab->sh.sh_size; |
1081 | strtab->sh.sh_size += data->d_size; | |
ff408273 JP |
1082 | |
1083 | mark_sec_changed(elf, strtab, true); | |
417a4dc9 PZ |
1084 | |
1085 | return len; | |
1086 | } | |
1087 | ||
627fce14 | 1088 | struct section *elf_create_section(struct elf *elf, const char *name, |
6342a20e | 1089 | size_t entsize, unsigned int nr) |
627fce14 JP |
1090 | { |
1091 | struct section *sec, *shstrtab; | |
1092 | size_t size = entsize * nr; | |
3c3ea503 | 1093 | Elf_Scn *s; |
627fce14 JP |
1094 | |
1095 | sec = malloc(sizeof(*sec)); | |
1096 | if (!sec) { | |
1097 | perror("malloc"); | |
1098 | return NULL; | |
1099 | } | |
1100 | memset(sec, 0, sizeof(*sec)); | |
1101 | ||
1102 | INIT_LIST_HEAD(&sec->symbol_list); | |
627fce14 | 1103 | |
627fce14 JP |
1104 | s = elf_newscn(elf->elf); |
1105 | if (!s) { | |
1106 | WARN_ELF("elf_newscn"); | |
1107 | return NULL; | |
1108 | } | |
1109 | ||
1110 | sec->name = strdup(name); | |
1111 | if (!sec->name) { | |
1112 | perror("strdup"); | |
1113 | return NULL; | |
1114 | } | |
1115 | ||
1116 | sec->idx = elf_ndxscn(s); | |
627fce14 JP |
1117 | |
1118 | sec->data = elf_newdata(s); | |
1119 | if (!sec->data) { | |
1120 | WARN_ELF("elf_newdata"); | |
1121 | return NULL; | |
1122 | } | |
1123 | ||
1124 | sec->data->d_size = size; | |
1125 | sec->data->d_align = 1; | |
1126 | ||
1127 | if (size) { | |
1128 | sec->data->d_buf = malloc(size); | |
1129 | if (!sec->data->d_buf) { | |
1130 | perror("malloc"); | |
1131 | return NULL; | |
1132 | } | |
1133 | memset(sec->data->d_buf, 0, size); | |
1134 | } | |
1135 | ||
1136 | if (!gelf_getshdr(s, &sec->sh)) { | |
1137 | WARN_ELF("gelf_getshdr"); | |
1138 | return NULL; | |
1139 | } | |
1140 | ||
1141 | sec->sh.sh_size = size; | |
1142 | sec->sh.sh_entsize = entsize; | |
1143 | sec->sh.sh_type = SHT_PROGBITS; | |
1144 | sec->sh.sh_addralign = 1; | |
2707579d | 1145 | sec->sh.sh_flags = SHF_ALLOC; |
627fce14 | 1146 | |
6d77d3b4 | 1147 | /* Add section name to .shstrtab (or .strtab for Clang) */ |
627fce14 | 1148 | shstrtab = find_section_by_name(elf, ".shstrtab"); |
6d77d3b4 SS |
1149 | if (!shstrtab) |
1150 | shstrtab = find_section_by_name(elf, ".strtab"); | |
627fce14 | 1151 | if (!shstrtab) { |
6d77d3b4 | 1152 | WARN("can't find .shstrtab or .strtab section"); |
627fce14 JP |
1153 | return NULL; |
1154 | } | |
417a4dc9 PZ |
1155 | sec->sh.sh_name = elf_add_string(elf, shstrtab, sec->name); |
1156 | if (sec->sh.sh_name == -1) | |
627fce14 | 1157 | return NULL; |
627fce14 | 1158 | |
53038996 | 1159 | list_add_tail(&sec->list, &elf->sections); |
25cf0d8a PZ |
1160 | elf_hash_add(section, &sec->hash, sec->idx); |
1161 | elf_hash_add(section_name, &sec->name_hash, str_hash(sec->name)); | |
53038996 | 1162 | |
ff408273 | 1163 | mark_sec_changed(elf, sec, true); |
2b10be23 | 1164 | |
627fce14 JP |
1165 | return sec; |
1166 | } | |
1167 | ||
53257a97 | 1168 | static struct section *elf_create_rela_section(struct elf *elf, |
6342a20e JP |
1169 | struct section *sec, |
1170 | unsigned int reloc_nr) | |
fb414783 | 1171 | { |
a5bd6236 | 1172 | struct section *rsec; |
53257a97 | 1173 | char *rsec_name; |
fb414783 | 1174 | |
53257a97 JP |
1175 | rsec_name = malloc(strlen(sec->name) + strlen(".rela") + 1); |
1176 | if (!rsec_name) { | |
fb414783 MH |
1177 | perror("malloc"); |
1178 | return NULL; | |
1179 | } | |
53257a97 JP |
1180 | strcpy(rsec_name, ".rela"); |
1181 | strcat(rsec_name, sec->name); | |
fb414783 | 1182 | |
6342a20e | 1183 | rsec = elf_create_section(elf, rsec_name, elf_rela_size(elf), reloc_nr); |
53257a97 | 1184 | free(rsec_name); |
a5bd6236 | 1185 | if (!rsec) |
fb414783 MH |
1186 | return NULL; |
1187 | ||
6342a20e | 1188 | rsec->data->d_type = ELF_T_RELA; |
a5bd6236 | 1189 | rsec->sh.sh_type = SHT_RELA; |
53257a97 | 1190 | rsec->sh.sh_addralign = elf_addr_size(elf); |
a5bd6236 | 1191 | rsec->sh.sh_link = find_section_by_name(elf, ".symtab")->idx; |
53257a97 | 1192 | rsec->sh.sh_info = sec->idx; |
a5bd6236 | 1193 | rsec->sh.sh_flags = SHF_INFO_LINK; |
627fce14 | 1194 | |
ebcef730 JP |
1195 | rsec->relocs = calloc(sec_num_entries(rsec), sizeof(struct reloc)); |
1196 | if (!rsec->relocs) { | |
e0a9349b JP |
1197 | perror("calloc"); |
1198 | return NULL; | |
1199 | } | |
1200 | ||
6342a20e JP |
1201 | sec->rsec = rsec; |
1202 | rsec->base = sec; | |
1203 | ||
a5bd6236 | 1204 | return rsec; |
627fce14 JP |
1205 | } |
1206 | ||
6342a20e JP |
1207 | struct section *elf_create_section_pair(struct elf *elf, const char *name, |
1208 | size_t entsize, unsigned int nr, | |
1209 | unsigned int reloc_nr) | |
1210 | { | |
1211 | struct section *sec; | |
1212 | ||
1213 | sec = elf_create_section(elf, name, entsize, nr); | |
1214 | if (!sec) | |
1215 | return NULL; | |
1216 | ||
1217 | if (!elf_create_rela_section(elf, sec, reloc_nr)) | |
1218 | return NULL; | |
1219 | ||
1220 | return sec; | |
1221 | } | |
1222 | ||
fdabdd0b PZ |
1223 | int elf_write_insn(struct elf *elf, struct section *sec, |
1224 | unsigned long offset, unsigned int len, | |
1225 | const char *insn) | |
1226 | { | |
1227 | Elf_Data *data = sec->data; | |
1228 | ||
1229 | if (data->d_type != ELF_T_BYTE || data->d_off) { | |
1230 | WARN("write to unexpected data for section: %s", sec->name); | |
1231 | return -1; | |
1232 | } | |
1233 | ||
1234 | memcpy(data->d_buf + offset, insn, len); | |
fdabdd0b | 1235 | |
ff408273 | 1236 | mark_sec_changed(elf, sec, true); |
fdabdd0b PZ |
1237 | |
1238 | return 0; | |
1239 | } | |
1240 | ||
13f60e80 PZ |
1241 | /* |
1242 | * When Elf_Scn::sh_size is smaller than the combined Elf_Data::d_size | |
1243 | * do you: | |
1244 | * | |
1245 | * A) adhere to the section header and truncate the data, or | |
1246 | * B) ignore the section header and write out all the data you've got? | |
1247 | * | |
1248 | * Yes, libelf sucks and we need to manually truncate if we over-allocate data. | |
1249 | */ | |
1250 | static int elf_truncate_section(struct elf *elf, struct section *sec) | |
1251 | { | |
1252 | u64 size = sec->sh.sh_size; | |
1253 | bool truncated = false; | |
1254 | Elf_Data *data = NULL; | |
1255 | Elf_Scn *s; | |
1256 | ||
1257 | s = elf_getscn(elf->elf, sec->idx); | |
1258 | if (!s) { | |
1259 | WARN_ELF("elf_getscn"); | |
1260 | return -1; | |
1261 | } | |
1262 | ||
1263 | for (;;) { | |
1264 | /* get next data descriptor for the relevant section */ | |
1265 | data = elf_getdata(s, data); | |
1266 | ||
1267 | if (!data) { | |
1268 | if (size) { | |
1269 | WARN("end of section data but non-zero size left\n"); | |
1270 | return -1; | |
1271 | } | |
1272 | return 0; | |
1273 | } | |
1274 | ||
1275 | if (truncated) { | |
1276 | /* when we remove symbols */ | |
1277 | WARN("truncated; but more data\n"); | |
1278 | return -1; | |
1279 | } | |
1280 | ||
1281 | if (!data->d_size) { | |
1282 | WARN("zero size data"); | |
1283 | return -1; | |
1284 | } | |
1285 | ||
1286 | if (data->d_size > size) { | |
1287 | truncated = true; | |
1288 | data->d_size = size; | |
1289 | } | |
1290 | ||
1291 | size -= data->d_size; | |
1292 | } | |
1293 | } | |
1294 | ||
2b10be23 | 1295 | int elf_write(struct elf *elf) |
627fce14 JP |
1296 | { |
1297 | struct section *sec; | |
1298 | Elf_Scn *s; | |
1299 | ||
2daf7fab | 1300 | if (opts.dryrun) |
f2d3a250 PZ |
1301 | return 0; |
1302 | ||
3a647607 | 1303 | /* Update changed relocation sections and section headers: */ |
627fce14 | 1304 | list_for_each_entry(sec, &elf->sections, list) { |
13f60e80 PZ |
1305 | if (sec->truncate) |
1306 | elf_truncate_section(elf, sec); | |
1307 | ||
ff408273 | 1308 | if (sec_changed(sec)) { |
627fce14 JP |
1309 | s = elf_getscn(elf->elf, sec->idx); |
1310 | if (!s) { | |
1311 | WARN_ELF("elf_getscn"); | |
1312 | return -1; | |
1313 | } | |
ff408273 JP |
1314 | |
1315 | /* Note this also flags the section dirty */ | |
97dab2ae | 1316 | if (!gelf_update_shdr(s, &sec->sh)) { |
627fce14 JP |
1317 | WARN_ELF("gelf_update_shdr"); |
1318 | return -1; | |
1319 | } | |
2b10be23 | 1320 | |
ff408273 | 1321 | mark_sec_changed(elf, sec, false); |
627fce14 JP |
1322 | } |
1323 | } | |
1324 | ||
97dab2ae JP |
1325 | /* Make sure the new section header entries get updated properly. */ |
1326 | elf_flagelf(elf->elf, ELF_C_SET, ELF_F_DIRTY); | |
1327 | ||
1328 | /* Write all changes to the file. */ | |
627fce14 JP |
1329 | if (elf_update(elf->elf, ELF_C_WRITE) < 0) { |
1330 | WARN_ELF("elf_update"); | |
1331 | return -1; | |
1332 | } | |
1333 | ||
2b10be23 PZ |
1334 | elf->changed = false; |
1335 | ||
627fce14 JP |
1336 | return 0; |
1337 | } | |
1338 | ||
442f04c3 JP |
1339 | void elf_close(struct elf *elf) |
1340 | { | |
baa41469 JP |
1341 | if (elf->elf) |
1342 | elf_end(elf->elf); | |
1343 | ||
1344 | if (elf->fd > 0) | |
1345 | close(elf->fd); | |
1346 | ||
5201a9bc JP |
1347 | /* |
1348 | * NOTE: All remaining allocations are leaked on purpose. Objtool is | |
1349 | * about to exit anyway. | |
1350 | */ | |
442f04c3 | 1351 | } |