xref: /openbmc/linux/tools/objtool/elf.c (revision 5b06931d7f8b8059bec8563b2e8d531218e03e2f)
1 // SPDX-License-Identifier: GPL-2.0-or-later
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>
8  */
9 
10 #include <sys/types.h>
11 #include <sys/stat.h>
12 #include <fcntl.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <unistd.h>
17 #include <errno.h>
18 #include "builtin.h"
19 
20 #include "elf.h"
21 #include "warn.h"
22 
23 #define MAX_NAME_LEN 128
24 
25 static inline u32 str_hash(const char *str)
26 {
27 	return jhash(str, strlen(str), 0);
28 }
29 
30 static inline int elf_hash_bits(void)
31 {
32 	return vmlinux ? ELF_HASH_BITS : 16;
33 }
34 
35 #define elf_hash_add(hashtable, node, key) \
36 	hlist_add_head(node, &hashtable[hash_min(key, elf_hash_bits())])
37 
38 static void elf_hash_init(struct hlist_head *table)
39 {
40 	__hash_init(table, 1U << elf_hash_bits());
41 }
42 
43 #define elf_hash_for_each_possible(name, obj, member, key)			\
44 	hlist_for_each_entry(obj, &name[hash_min(key, elf_hash_bits())], member)
45 
46 static void rb_add(struct rb_root *tree, struct rb_node *node,
47 		   int (*cmp)(struct rb_node *, const struct rb_node *))
48 {
49 	struct rb_node **link = &tree->rb_node;
50 	struct rb_node *parent = NULL;
51 
52 	while (*link) {
53 		parent = *link;
54 		if (cmp(node, parent) < 0)
55 			link = &parent->rb_left;
56 		else
57 			link = &parent->rb_right;
58 	}
59 
60 	rb_link_node(node, parent, link);
61 	rb_insert_color(node, tree);
62 }
63 
64 static struct rb_node *rb_find_first(const struct rb_root *tree, const void *key,
65 			       int (*cmp)(const void *key, const struct rb_node *))
66 {
67 	struct rb_node *node = tree->rb_node;
68 	struct rb_node *match = NULL;
69 
70 	while (node) {
71 		int c = cmp(key, node);
72 		if (c <= 0) {
73 			if (!c)
74 				match = node;
75 			node = node->rb_left;
76 		} else if (c > 0) {
77 			node = node->rb_right;
78 		}
79 	}
80 
81 	return match;
82 }
83 
84 static struct rb_node *rb_next_match(struct rb_node *node, const void *key,
85 				    int (*cmp)(const void *key, const struct rb_node *))
86 {
87 	node = rb_next(node);
88 	if (node && cmp(key, node))
89 		node = NULL;
90 	return node;
91 }
92 
93 #define rb_for_each(tree, node, key, cmp) \
94 	for ((node) = rb_find_first((tree), (key), (cmp)); \
95 	     (node); (node) = rb_next_match((node), (key), (cmp)))
96 
97 static int symbol_to_offset(struct rb_node *a, const struct rb_node *b)
98 {
99 	struct symbol *sa = rb_entry(a, struct symbol, node);
100 	struct symbol *sb = rb_entry(b, struct symbol, node);
101 
102 	if (sa->offset < sb->offset)
103 		return -1;
104 	if (sa->offset > sb->offset)
105 		return 1;
106 
107 	if (sa->len < sb->len)
108 		return -1;
109 	if (sa->len > sb->len)
110 		return 1;
111 
112 	sa->alias = sb;
113 
114 	return 0;
115 }
116 
117 static int symbol_by_offset(const void *key, const struct rb_node *node)
118 {
119 	const struct symbol *s = rb_entry(node, struct symbol, node);
120 	const unsigned long *o = key;
121 
122 	if (*o < s->offset)
123 		return -1;
124 	if (*o >= s->offset + s->len)
125 		return 1;
126 
127 	return 0;
128 }
129 
130 struct section *find_section_by_name(const struct elf *elf, const char *name)
131 {
132 	struct section *sec;
133 
134 	elf_hash_for_each_possible(elf->section_name_hash, sec, name_hash, str_hash(name))
135 		if (!strcmp(sec->name, name))
136 			return sec;
137 
138 	return NULL;
139 }
140 
141 static struct section *find_section_by_index(struct elf *elf,
142 					     unsigned int idx)
143 {
144 	struct section *sec;
145 
146 	elf_hash_for_each_possible(elf->section_hash, sec, hash, idx)
147 		if (sec->idx == idx)
148 			return sec;
149 
150 	return NULL;
151 }
152 
153 static struct symbol *find_symbol_by_index(struct elf *elf, unsigned int idx)
154 {
155 	struct symbol *sym;
156 
157 	elf_hash_for_each_possible(elf->symbol_hash, sym, hash, idx)
158 		if (sym->idx == idx)
159 			return sym;
160 
161 	return NULL;
162 }
163 
164 struct symbol *find_symbol_by_offset(struct section *sec, unsigned long offset)
165 {
166 	struct rb_node *node;
167 
168 	rb_for_each(&sec->symbol_tree, node, &offset, symbol_by_offset) {
169 		struct symbol *s = rb_entry(node, struct symbol, node);
170 
171 		if (s->offset == offset && s->type != STT_SECTION)
172 			return s;
173 	}
174 
175 	return NULL;
176 }
177 
178 struct symbol *find_func_by_offset(struct section *sec, unsigned long offset)
179 {
180 	struct rb_node *node;
181 
182 	rb_for_each(&sec->symbol_tree, node, &offset, symbol_by_offset) {
183 		struct symbol *s = rb_entry(node, struct symbol, node);
184 
185 		if (s->offset == offset && s->type == STT_FUNC)
186 			return s;
187 	}
188 
189 	return NULL;
190 }
191 
192 struct symbol *find_symbol_containing(const struct section *sec, unsigned long offset)
193 {
194 	struct rb_node *node;
195 
196 	rb_for_each(&sec->symbol_tree, node, &offset, symbol_by_offset) {
197 		struct symbol *s = rb_entry(node, struct symbol, node);
198 
199 		if (s->type != STT_SECTION)
200 			return s;
201 	}
202 
203 	return NULL;
204 }
205 
206 struct symbol *find_func_containing(struct section *sec, unsigned long offset)
207 {
208 	struct rb_node *node;
209 
210 	rb_for_each(&sec->symbol_tree, node, &offset, symbol_by_offset) {
211 		struct symbol *s = rb_entry(node, struct symbol, node);
212 
213 		if (s->type == STT_FUNC)
214 			return s;
215 	}
216 
217 	return NULL;
218 }
219 
220 struct symbol *find_symbol_by_name(const struct elf *elf, const char *name)
221 {
222 	struct symbol *sym;
223 
224 	elf_hash_for_each_possible(elf->symbol_name_hash, sym, name_hash, str_hash(name))
225 		if (!strcmp(sym->name, name))
226 			return sym;
227 
228 	return NULL;
229 }
230 
231 struct reloc *find_reloc_by_dest_range(const struct elf *elf, struct section *sec,
232 				     unsigned long offset, unsigned int len)
233 {
234 	struct reloc *reloc, *r = NULL;
235 	unsigned long o;
236 
237 	if (!sec->reloc)
238 		return NULL;
239 
240 	sec = sec->reloc;
241 
242 	for_offset_range(o, offset, offset + len) {
243 		elf_hash_for_each_possible(elf->reloc_hash, reloc, hash,
244 				       sec_offset_hash(sec, o)) {
245 			if (reloc->sec != sec)
246 				continue;
247 
248 			if (reloc->offset >= offset && reloc->offset < offset + len) {
249 				if (!r || reloc->offset < r->offset)
250 					r = reloc;
251 			}
252 		}
253 		if (r)
254 			return r;
255 	}
256 
257 	return NULL;
258 }
259 
260 struct reloc *find_reloc_by_dest(const struct elf *elf, struct section *sec, unsigned long offset)
261 {
262 	return find_reloc_by_dest_range(elf, sec, offset, 1);
263 }
264 
265 void insn_to_reloc_sym_addend(struct section *sec, unsigned long offset,
266 			      struct reloc *reloc)
267 {
268 	if (sec->sym) {
269 		reloc->sym = sec->sym;
270 		reloc->addend = offset;
271 		return;
272 	}
273 
274 	/*
275 	 * The Clang assembler strips section symbols, so we have to reference
276 	 * the function symbol instead:
277 	 */
278 	reloc->sym = find_symbol_containing(sec, offset);
279 	if (!reloc->sym) {
280 		/*
281 		 * Hack alert.  This happens when we need to reference the NOP
282 		 * pad insn immediately after the function.
283 		 */
284 		reloc->sym = find_symbol_containing(sec, offset - 1);
285 	}
286 
287 	if (reloc->sym)
288 		reloc->addend = offset - reloc->sym->offset;
289 }
290 
291 static int read_sections(struct elf *elf)
292 {
293 	Elf_Scn *s = NULL;
294 	struct section *sec;
295 	size_t shstrndx, sections_nr;
296 	int i;
297 
298 	if (elf_getshdrnum(elf->elf, &sections_nr)) {
299 		WARN_ELF("elf_getshdrnum");
300 		return -1;
301 	}
302 
303 	if (elf_getshdrstrndx(elf->elf, &shstrndx)) {
304 		WARN_ELF("elf_getshdrstrndx");
305 		return -1;
306 	}
307 
308 	for (i = 0; i < sections_nr; i++) {
309 		sec = malloc(sizeof(*sec));
310 		if (!sec) {
311 			perror("malloc");
312 			return -1;
313 		}
314 		memset(sec, 0, sizeof(*sec));
315 
316 		INIT_LIST_HEAD(&sec->symbol_list);
317 		INIT_LIST_HEAD(&sec->reloc_list);
318 
319 		s = elf_getscn(elf->elf, i);
320 		if (!s) {
321 			WARN_ELF("elf_getscn");
322 			return -1;
323 		}
324 
325 		sec->idx = elf_ndxscn(s);
326 
327 		if (!gelf_getshdr(s, &sec->sh)) {
328 			WARN_ELF("gelf_getshdr");
329 			return -1;
330 		}
331 
332 		sec->name = elf_strptr(elf->elf, shstrndx, sec->sh.sh_name);
333 		if (!sec->name) {
334 			WARN_ELF("elf_strptr");
335 			return -1;
336 		}
337 
338 		if (sec->sh.sh_size != 0) {
339 			sec->data = elf_getdata(s, NULL);
340 			if (!sec->data) {
341 				WARN_ELF("elf_getdata");
342 				return -1;
343 			}
344 			if (sec->data->d_off != 0 ||
345 			    sec->data->d_size != sec->sh.sh_size) {
346 				WARN("unexpected data attributes for %s",
347 				     sec->name);
348 				return -1;
349 			}
350 		}
351 		sec->len = sec->sh.sh_size;
352 
353 		list_add_tail(&sec->list, &elf->sections);
354 		elf_hash_add(elf->section_hash, &sec->hash, sec->idx);
355 		elf_hash_add(elf->section_name_hash, &sec->name_hash, str_hash(sec->name));
356 	}
357 
358 	if (stats)
359 		printf("nr_sections: %lu\n", (unsigned long)sections_nr);
360 
361 	/* sanity check, one more call to elf_nextscn() should return NULL */
362 	if (elf_nextscn(elf->elf, s)) {
363 		WARN("section entry mismatch");
364 		return -1;
365 	}
366 
367 	return 0;
368 }
369 
370 static int read_symbols(struct elf *elf)
371 {
372 	struct section *symtab, *symtab_shndx, *sec;
373 	struct symbol *sym, *pfunc;
374 	struct list_head *entry;
375 	struct rb_node *pnode;
376 	int symbols_nr, i;
377 	char *coldstr;
378 	Elf_Data *shndx_data = NULL;
379 	Elf32_Word shndx;
380 
381 	symtab = find_section_by_name(elf, ".symtab");
382 	if (!symtab) {
383 		/*
384 		 * A missing symbol table is actually possible if it's an empty
385 		 * .o file.  This can happen for thunk_64.o.
386 		 */
387 		return 0;
388 	}
389 
390 	symtab_shndx = find_section_by_name(elf, ".symtab_shndx");
391 	if (symtab_shndx)
392 		shndx_data = symtab_shndx->data;
393 
394 	symbols_nr = symtab->sh.sh_size / symtab->sh.sh_entsize;
395 
396 	for (i = 0; i < symbols_nr; i++) {
397 		sym = malloc(sizeof(*sym));
398 		if (!sym) {
399 			perror("malloc");
400 			return -1;
401 		}
402 		memset(sym, 0, sizeof(*sym));
403 		sym->alias = sym;
404 
405 		sym->idx = i;
406 
407 		if (!gelf_getsymshndx(symtab->data, shndx_data, i, &sym->sym,
408 				      &shndx)) {
409 			WARN_ELF("gelf_getsymshndx");
410 			goto err;
411 		}
412 
413 		sym->name = elf_strptr(elf->elf, symtab->sh.sh_link,
414 				       sym->sym.st_name);
415 		if (!sym->name) {
416 			WARN_ELF("elf_strptr");
417 			goto err;
418 		}
419 
420 		sym->type = GELF_ST_TYPE(sym->sym.st_info);
421 		sym->bind = GELF_ST_BIND(sym->sym.st_info);
422 
423 		if ((sym->sym.st_shndx > SHN_UNDEF &&
424 		     sym->sym.st_shndx < SHN_LORESERVE) ||
425 		    (shndx_data && sym->sym.st_shndx == SHN_XINDEX)) {
426 			if (sym->sym.st_shndx != SHN_XINDEX)
427 				shndx = sym->sym.st_shndx;
428 
429 			sym->sec = find_section_by_index(elf, shndx);
430 			if (!sym->sec) {
431 				WARN("couldn't find section for symbol %s",
432 				     sym->name);
433 				goto err;
434 			}
435 			if (sym->type == STT_SECTION) {
436 				sym->name = sym->sec->name;
437 				sym->sec->sym = sym;
438 			}
439 		} else
440 			sym->sec = find_section_by_index(elf, 0);
441 
442 		sym->offset = sym->sym.st_value;
443 		sym->len = sym->sym.st_size;
444 
445 		rb_add(&sym->sec->symbol_tree, &sym->node, symbol_to_offset);
446 		pnode = rb_prev(&sym->node);
447 		if (pnode)
448 			entry = &rb_entry(pnode, struct symbol, node)->list;
449 		else
450 			entry = &sym->sec->symbol_list;
451 		list_add(&sym->list, entry);
452 		elf_hash_add(elf->symbol_hash, &sym->hash, sym->idx);
453 		elf_hash_add(elf->symbol_name_hash, &sym->name_hash, str_hash(sym->name));
454 
455 		/*
456 		 * Don't store empty STT_NOTYPE symbols in the rbtree.  They
457 		 * can exist within a function, confusing the sorting.
458 		 */
459 		if (!sym->len)
460 			rb_erase(&sym->node, &sym->sec->symbol_tree);
461 	}
462 
463 	if (stats)
464 		printf("nr_symbols: %lu\n", (unsigned long)symbols_nr);
465 
466 	/* Create parent/child links for any cold subfunctions */
467 	list_for_each_entry(sec, &elf->sections, list) {
468 		list_for_each_entry(sym, &sec->symbol_list, list) {
469 			char pname[MAX_NAME_LEN + 1];
470 			size_t pnamelen;
471 			if (sym->type != STT_FUNC)
472 				continue;
473 
474 			if (sym->pfunc == NULL)
475 				sym->pfunc = sym;
476 
477 			if (sym->cfunc == NULL)
478 				sym->cfunc = sym;
479 
480 			coldstr = strstr(sym->name, ".cold");
481 			if (!coldstr)
482 				continue;
483 
484 			pnamelen = coldstr - sym->name;
485 			if (pnamelen > MAX_NAME_LEN) {
486 				WARN("%s(): parent function name exceeds maximum length of %d characters",
487 				     sym->name, MAX_NAME_LEN);
488 				return -1;
489 			}
490 
491 			strncpy(pname, sym->name, pnamelen);
492 			pname[pnamelen] = '\0';
493 			pfunc = find_symbol_by_name(elf, pname);
494 
495 			if (!pfunc) {
496 				WARN("%s(): can't find parent function",
497 				     sym->name);
498 				return -1;
499 			}
500 
501 			sym->pfunc = pfunc;
502 			pfunc->cfunc = sym;
503 
504 			/*
505 			 * Unfortunately, -fnoreorder-functions puts the child
506 			 * inside the parent.  Remove the overlap so we can
507 			 * have sane assumptions.
508 			 *
509 			 * Note that pfunc->len now no longer matches
510 			 * pfunc->sym.st_size.
511 			 */
512 			if (sym->sec == pfunc->sec &&
513 			    sym->offset >= pfunc->offset &&
514 			    sym->offset + sym->len == pfunc->offset + pfunc->len) {
515 				pfunc->len -= sym->len;
516 			}
517 		}
518 	}
519 
520 	return 0;
521 
522 err:
523 	free(sym);
524 	return -1;
525 }
526 
527 void elf_add_reloc(struct elf *elf, struct reloc *reloc)
528 {
529 	struct section *sec = reloc->sec;
530 
531 	list_add_tail(&reloc->list, &sec->reloc_list);
532 	elf_hash_add(elf->reloc_hash, &reloc->hash, reloc_hash(reloc));
533 }
534 
535 static int read_rel_reloc(struct section *sec, int i, struct reloc *reloc, unsigned int *symndx)
536 {
537 	if (!gelf_getrel(sec->data, i, &reloc->rel)) {
538 		WARN_ELF("gelf_getrel");
539 		return -1;
540 	}
541 	reloc->type = GELF_R_TYPE(reloc->rel.r_info);
542 	reloc->addend = 0;
543 	reloc->offset = reloc->rel.r_offset;
544 	*symndx = GELF_R_SYM(reloc->rel.r_info);
545 	return 0;
546 }
547 
548 static int read_rela_reloc(struct section *sec, int i, struct reloc *reloc, unsigned int *symndx)
549 {
550 	if (!gelf_getrela(sec->data, i, &reloc->rela)) {
551 		WARN_ELF("gelf_getrela");
552 		return -1;
553 	}
554 	reloc->type = GELF_R_TYPE(reloc->rela.r_info);
555 	reloc->addend = reloc->rela.r_addend;
556 	reloc->offset = reloc->rela.r_offset;
557 	*symndx = GELF_R_SYM(reloc->rela.r_info);
558 	return 0;
559 }
560 
561 static int read_relocs(struct elf *elf)
562 {
563 	struct section *sec;
564 	struct reloc *reloc;
565 	int i;
566 	unsigned int symndx;
567 	unsigned long nr_reloc, max_reloc = 0, tot_reloc = 0;
568 
569 	list_for_each_entry(sec, &elf->sections, list) {
570 		if ((sec->sh.sh_type != SHT_RELA) &&
571 		    (sec->sh.sh_type != SHT_REL))
572 			continue;
573 
574 		sec->base = find_section_by_index(elf, sec->sh.sh_info);
575 		if (!sec->base) {
576 			WARN("can't find base section for reloc section %s",
577 			     sec->name);
578 			return -1;
579 		}
580 
581 		sec->base->reloc = sec;
582 
583 		nr_reloc = 0;
584 		for (i = 0; i < sec->sh.sh_size / sec->sh.sh_entsize; i++) {
585 			reloc = malloc(sizeof(*reloc));
586 			if (!reloc) {
587 				perror("malloc");
588 				return -1;
589 			}
590 			memset(reloc, 0, sizeof(*reloc));
591 			switch (sec->sh.sh_type) {
592 			case SHT_REL:
593 				if (read_rel_reloc(sec, i, reloc, &symndx))
594 					return -1;
595 				break;
596 			case SHT_RELA:
597 				if (read_rela_reloc(sec, i, reloc, &symndx))
598 					return -1;
599 				break;
600 			default: return -1;
601 			}
602 
603 			reloc->sec = sec;
604 			reloc->idx = i;
605 			reloc->sym = find_symbol_by_index(elf, symndx);
606 			if (!reloc->sym) {
607 				WARN("can't find reloc entry symbol %d for %s",
608 				     symndx, sec->name);
609 				return -1;
610 			}
611 
612 			elf_add_reloc(elf, reloc);
613 			nr_reloc++;
614 		}
615 		max_reloc = max(max_reloc, nr_reloc);
616 		tot_reloc += nr_reloc;
617 	}
618 
619 	if (stats) {
620 		printf("max_reloc: %lu\n", max_reloc);
621 		printf("tot_reloc: %lu\n", tot_reloc);
622 	}
623 
624 	return 0;
625 }
626 
627 struct elf *elf_open_read(const char *name, int flags)
628 {
629 	struct elf *elf;
630 	Elf_Cmd cmd;
631 
632 	elf_version(EV_CURRENT);
633 
634 	elf = malloc(sizeof(*elf));
635 	if (!elf) {
636 		perror("malloc");
637 		return NULL;
638 	}
639 	memset(elf, 0, offsetof(struct elf, sections));
640 
641 	INIT_LIST_HEAD(&elf->sections);
642 
643 	elf_hash_init(elf->symbol_hash);
644 	elf_hash_init(elf->symbol_name_hash);
645 	elf_hash_init(elf->section_hash);
646 	elf_hash_init(elf->section_name_hash);
647 	elf_hash_init(elf->reloc_hash);
648 
649 	elf->fd = open(name, flags);
650 	if (elf->fd == -1) {
651 		fprintf(stderr, "objtool: Can't open '%s': %s\n",
652 			name, strerror(errno));
653 		goto err;
654 	}
655 
656 	if ((flags & O_ACCMODE) == O_RDONLY)
657 		cmd = ELF_C_READ_MMAP;
658 	else if ((flags & O_ACCMODE) == O_RDWR)
659 		cmd = ELF_C_RDWR;
660 	else /* O_WRONLY */
661 		cmd = ELF_C_WRITE;
662 
663 	elf->elf = elf_begin(elf->fd, cmd, NULL);
664 	if (!elf->elf) {
665 		WARN_ELF("elf_begin");
666 		goto err;
667 	}
668 
669 	if (!gelf_getehdr(elf->elf, &elf->ehdr)) {
670 		WARN_ELF("gelf_getehdr");
671 		goto err;
672 	}
673 
674 	if (read_sections(elf))
675 		goto err;
676 
677 	if (read_symbols(elf))
678 		goto err;
679 
680 	if (read_relocs(elf))
681 		goto err;
682 
683 	return elf;
684 
685 err:
686 	elf_close(elf);
687 	return NULL;
688 }
689 
690 struct section *elf_create_section(struct elf *elf, const char *name,
691 				   unsigned int sh_flags, size_t entsize, int nr)
692 {
693 	struct section *sec, *shstrtab;
694 	size_t size = entsize * nr;
695 	Elf_Scn *s;
696 	Elf_Data *data;
697 
698 	sec = malloc(sizeof(*sec));
699 	if (!sec) {
700 		perror("malloc");
701 		return NULL;
702 	}
703 	memset(sec, 0, sizeof(*sec));
704 
705 	INIT_LIST_HEAD(&sec->symbol_list);
706 	INIT_LIST_HEAD(&sec->reloc_list);
707 
708 	s = elf_newscn(elf->elf);
709 	if (!s) {
710 		WARN_ELF("elf_newscn");
711 		return NULL;
712 	}
713 
714 	sec->name = strdup(name);
715 	if (!sec->name) {
716 		perror("strdup");
717 		return NULL;
718 	}
719 
720 	sec->idx = elf_ndxscn(s);
721 	sec->len = size;
722 	sec->changed = true;
723 
724 	sec->data = elf_newdata(s);
725 	if (!sec->data) {
726 		WARN_ELF("elf_newdata");
727 		return NULL;
728 	}
729 
730 	sec->data->d_size = size;
731 	sec->data->d_align = 1;
732 
733 	if (size) {
734 		sec->data->d_buf = malloc(size);
735 		if (!sec->data->d_buf) {
736 			perror("malloc");
737 			return NULL;
738 		}
739 		memset(sec->data->d_buf, 0, size);
740 	}
741 
742 	if (!gelf_getshdr(s, &sec->sh)) {
743 		WARN_ELF("gelf_getshdr");
744 		return NULL;
745 	}
746 
747 	sec->sh.sh_size = size;
748 	sec->sh.sh_entsize = entsize;
749 	sec->sh.sh_type = SHT_PROGBITS;
750 	sec->sh.sh_addralign = 1;
751 	sec->sh.sh_flags = SHF_ALLOC | sh_flags;
752 
753 
754 	/* Add section name to .shstrtab (or .strtab for Clang) */
755 	shstrtab = find_section_by_name(elf, ".shstrtab");
756 	if (!shstrtab)
757 		shstrtab = find_section_by_name(elf, ".strtab");
758 	if (!shstrtab) {
759 		WARN("can't find .shstrtab or .strtab section");
760 		return NULL;
761 	}
762 
763 	s = elf_getscn(elf->elf, shstrtab->idx);
764 	if (!s) {
765 		WARN_ELF("elf_getscn");
766 		return NULL;
767 	}
768 
769 	data = elf_newdata(s);
770 	if (!data) {
771 		WARN_ELF("elf_newdata");
772 		return NULL;
773 	}
774 
775 	data->d_buf = sec->name;
776 	data->d_size = strlen(name) + 1;
777 	data->d_align = 1;
778 
779 	sec->sh.sh_name = shstrtab->len;
780 
781 	shstrtab->len += strlen(name) + 1;
782 	shstrtab->changed = true;
783 
784 	list_add_tail(&sec->list, &elf->sections);
785 	elf_hash_add(elf->section_hash, &sec->hash, sec->idx);
786 	elf_hash_add(elf->section_name_hash, &sec->name_hash, str_hash(sec->name));
787 
788 	elf->changed = true;
789 
790 	return sec;
791 }
792 
793 static struct section *elf_create_rel_reloc_section(struct elf *elf, struct section *base)
794 {
795 	char *relocname;
796 	struct section *sec;
797 
798 	relocname = malloc(strlen(base->name) + strlen(".rel") + 1);
799 	if (!relocname) {
800 		perror("malloc");
801 		return NULL;
802 	}
803 	strcpy(relocname, ".rel");
804 	strcat(relocname, base->name);
805 
806 	sec = elf_create_section(elf, relocname, 0, sizeof(GElf_Rel), 0);
807 	free(relocname);
808 	if (!sec)
809 		return NULL;
810 
811 	base->reloc = sec;
812 	sec->base = base;
813 
814 	sec->sh.sh_type = SHT_REL;
815 	sec->sh.sh_addralign = 8;
816 	sec->sh.sh_link = find_section_by_name(elf, ".symtab")->idx;
817 	sec->sh.sh_info = base->idx;
818 	sec->sh.sh_flags = SHF_INFO_LINK;
819 
820 	return sec;
821 }
822 
823 static struct section *elf_create_rela_reloc_section(struct elf *elf, struct section *base)
824 {
825 	char *relocname;
826 	struct section *sec;
827 
828 	relocname = malloc(strlen(base->name) + strlen(".rela") + 1);
829 	if (!relocname) {
830 		perror("malloc");
831 		return NULL;
832 	}
833 	strcpy(relocname, ".rela");
834 	strcat(relocname, base->name);
835 
836 	sec = elf_create_section(elf, relocname, 0, sizeof(GElf_Rela), 0);
837 	free(relocname);
838 	if (!sec)
839 		return NULL;
840 
841 	base->reloc = sec;
842 	sec->base = base;
843 
844 	sec->sh.sh_type = SHT_RELA;
845 	sec->sh.sh_addralign = 8;
846 	sec->sh.sh_link = find_section_by_name(elf, ".symtab")->idx;
847 	sec->sh.sh_info = base->idx;
848 	sec->sh.sh_flags = SHF_INFO_LINK;
849 
850 	return sec;
851 }
852 
853 struct section *elf_create_reloc_section(struct elf *elf,
854 					 struct section *base,
855 					 int reltype)
856 {
857 	switch (reltype) {
858 	case SHT_REL:  return elf_create_rel_reloc_section(elf, base);
859 	case SHT_RELA: return elf_create_rela_reloc_section(elf, base);
860 	default:       return NULL;
861 	}
862 }
863 
864 static int elf_rebuild_rel_reloc_section(struct section *sec, int nr)
865 {
866 	struct reloc *reloc;
867 	int idx = 0, size;
868 	GElf_Rel *relocs;
869 
870 	/* Allocate a buffer for relocations */
871 	size = nr * sizeof(*relocs);
872 	relocs = malloc(size);
873 	if (!relocs) {
874 		perror("malloc");
875 		return -1;
876 	}
877 
878 	sec->data->d_buf = relocs;
879 	sec->data->d_size = size;
880 
881 	sec->sh.sh_size = size;
882 
883 	idx = 0;
884 	list_for_each_entry(reloc, &sec->reloc_list, list) {
885 		relocs[idx].r_offset = reloc->offset;
886 		relocs[idx].r_info = GELF_R_INFO(reloc->sym->idx, reloc->type);
887 		idx++;
888 	}
889 
890 	return 0;
891 }
892 
893 static int elf_rebuild_rela_reloc_section(struct section *sec, int nr)
894 {
895 	struct reloc *reloc;
896 	int idx = 0, size;
897 	GElf_Rela *relocs;
898 
899 	/* Allocate a buffer for relocations with addends */
900 	size = nr * sizeof(*relocs);
901 	relocs = malloc(size);
902 	if (!relocs) {
903 		perror("malloc");
904 		return -1;
905 	}
906 
907 	sec->data->d_buf = relocs;
908 	sec->data->d_size = size;
909 
910 	sec->sh.sh_size = size;
911 
912 	idx = 0;
913 	list_for_each_entry(reloc, &sec->reloc_list, list) {
914 		relocs[idx].r_offset = reloc->offset;
915 		relocs[idx].r_addend = reloc->addend;
916 		relocs[idx].r_info = GELF_R_INFO(reloc->sym->idx, reloc->type);
917 		idx++;
918 	}
919 
920 	return 0;
921 }
922 
923 int elf_rebuild_reloc_section(struct elf *elf, struct section *sec)
924 {
925 	struct reloc *reloc;
926 	int nr;
927 
928 	sec->changed = true;
929 	elf->changed = true;
930 
931 	nr = 0;
932 	list_for_each_entry(reloc, &sec->reloc_list, list)
933 		nr++;
934 
935 	switch (sec->sh.sh_type) {
936 	case SHT_REL:  return elf_rebuild_rel_reloc_section(sec, nr);
937 	case SHT_RELA: return elf_rebuild_rela_reloc_section(sec, nr);
938 	default:       return -1;
939 	}
940 }
941 
942 int elf_write_insn(struct elf *elf, struct section *sec,
943 		   unsigned long offset, unsigned int len,
944 		   const char *insn)
945 {
946 	Elf_Data *data = sec->data;
947 
948 	if (data->d_type != ELF_T_BYTE || data->d_off) {
949 		WARN("write to unexpected data for section: %s", sec->name);
950 		return -1;
951 	}
952 
953 	memcpy(data->d_buf + offset, insn, len);
954 	elf_flagdata(data, ELF_C_SET, ELF_F_DIRTY);
955 
956 	elf->changed = true;
957 
958 	return 0;
959 }
960 
961 int elf_write_reloc(struct elf *elf, struct reloc *reloc)
962 {
963 	struct section *sec = reloc->sec;
964 
965 	if (sec->sh.sh_type == SHT_REL) {
966 		reloc->rel.r_info = GELF_R_INFO(reloc->sym->idx, reloc->type);
967 		reloc->rel.r_offset = reloc->offset;
968 
969 		if (!gelf_update_rel(sec->data, reloc->idx, &reloc->rel)) {
970 			WARN_ELF("gelf_update_rel");
971 			return -1;
972 		}
973 	} else {
974 		reloc->rela.r_info = GELF_R_INFO(reloc->sym->idx, reloc->type);
975 		reloc->rela.r_addend = reloc->addend;
976 		reloc->rela.r_offset = reloc->offset;
977 
978 		if (!gelf_update_rela(sec->data, reloc->idx, &reloc->rela)) {
979 			WARN_ELF("gelf_update_rela");
980 			return -1;
981 		}
982 	}
983 
984 	elf->changed = true;
985 
986 	return 0;
987 }
988 
989 int elf_write(struct elf *elf)
990 {
991 	struct section *sec;
992 	Elf_Scn *s;
993 
994 	/* Update section headers for changed sections: */
995 	list_for_each_entry(sec, &elf->sections, list) {
996 		if (sec->changed) {
997 			s = elf_getscn(elf->elf, sec->idx);
998 			if (!s) {
999 				WARN_ELF("elf_getscn");
1000 				return -1;
1001 			}
1002 			if (!gelf_update_shdr(s, &sec->sh)) {
1003 				WARN_ELF("gelf_update_shdr");
1004 				return -1;
1005 			}
1006 
1007 			sec->changed = false;
1008 		}
1009 	}
1010 
1011 	/* Make sure the new section header entries get updated properly. */
1012 	elf_flagelf(elf->elf, ELF_C_SET, ELF_F_DIRTY);
1013 
1014 	/* Write all changes to the file. */
1015 	if (elf_update(elf->elf, ELF_C_WRITE) < 0) {
1016 		WARN_ELF("elf_update");
1017 		return -1;
1018 	}
1019 
1020 	elf->changed = false;
1021 
1022 	return 0;
1023 }
1024 
1025 void elf_close(struct elf *elf)
1026 {
1027 	struct section *sec, *tmpsec;
1028 	struct symbol *sym, *tmpsym;
1029 	struct reloc *reloc, *tmpreloc;
1030 
1031 	if (elf->elf)
1032 		elf_end(elf->elf);
1033 
1034 	if (elf->fd > 0)
1035 		close(elf->fd);
1036 
1037 	list_for_each_entry_safe(sec, tmpsec, &elf->sections, list) {
1038 		list_for_each_entry_safe(sym, tmpsym, &sec->symbol_list, list) {
1039 			list_del(&sym->list);
1040 			hash_del(&sym->hash);
1041 			free(sym);
1042 		}
1043 		list_for_each_entry_safe(reloc, tmpreloc, &sec->reloc_list, list) {
1044 			list_del(&reloc->list);
1045 			hash_del(&reloc->hash);
1046 			free(reloc);
1047 		}
1048 		list_del(&sec->list);
1049 		free(sec);
1050 	}
1051 
1052 	free(elf);
1053 }
1054