xref: /linux/tools/objtool/elf.c (revision 37744feebc086908fd89760650f458ab19071750) 
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 void rb_add(struct rb_root *tree, struct rb_node *node,
31 		   int (*cmp)(struct rb_node *, const struct rb_node *))
32 {
33 	struct rb_node **link = &tree->rb_node;
34 	struct rb_node *parent = NULL;
35 
36 	while (*link) {
37 		parent = *link;
38 		if (cmp(node, parent) < 0)
39 			link = &parent->rb_left;
40 		else
41 			link = &parent->rb_right;
42 	}
43 
44 	rb_link_node(node, parent, link);
45 	rb_insert_color(node, tree);
46 }
47 
48 static struct rb_node *rb_find_first(struct rb_root *tree, const void *key,
49 			       int (*cmp)(const void *key, const struct rb_node *))
50 {
51 	struct rb_node *node = tree->rb_node;
52 	struct rb_node *match = NULL;
53 
54 	while (node) {
55 		int c = cmp(key, node);
56 		if (c <= 0) {
57 			if (!c)
58 				match = node;
59 			node = node->rb_left;
60 		} else if (c > 0) {
61 			node = node->rb_right;
62 		}
63 	}
64 
65 	return match;
66 }
67 
68 static struct rb_node *rb_next_match(struct rb_node *node, const void *key,
69 				    int (*cmp)(const void *key, const struct rb_node *))
70 {
71 	node = rb_next(node);
72 	if (node && cmp(key, node))
73 		node = NULL;
74 	return node;
75 }
76 
77 #define rb_for_each(tree, node, key, cmp) \
78 	for ((node) = rb_find_first((tree), (key), (cmp)); \
79 	     (node); (node) = rb_next_match((node), (key), (cmp)))
80 
81 static int symbol_to_offset(struct rb_node *a, const struct rb_node *b)
82 {
83 	struct symbol *sa = rb_entry(a, struct symbol, node);
84 	struct symbol *sb = rb_entry(b, struct symbol, node);
85 
86 	if (sa->offset < sb->offset)
87 		return -1;
88 	if (sa->offset > sb->offset)
89 		return 1;
90 
91 	if (sa->len < sb->len)
92 		return -1;
93 	if (sa->len > sb->len)
94 		return 1;
95 
96 	sa->alias = sb;
97 
98 	return 0;
99 }
100 
101 static int symbol_by_offset(const void *key, const struct rb_node *node)
102 {
103 	const struct symbol *s = rb_entry(node, struct symbol, node);
104 	const unsigned long *o = key;
105 
106 	if (*o < s->offset)
107 		return -1;
108 	if (*o >= s->offset + s->len)
109 		return 1;
110 
111 	return 0;
112 }
113 
114 struct section *find_section_by_name(struct elf *elf, const char *name)
115 {
116 	struct section *sec;
117 
118 	hash_for_each_possible(elf->section_name_hash, sec, name_hash, str_hash(name))
119 		if (!strcmp(sec->name, name))
120 			return sec;
121 
122 	return NULL;
123 }
124 
125 static struct section *find_section_by_index(struct elf *elf,
126 					     unsigned int idx)
127 {
128 	struct section *sec;
129 
130 	hash_for_each_possible(elf->section_hash, sec, hash, idx)
131 		if (sec->idx == idx)
132 			return sec;
133 
134 	return NULL;
135 }
136 
137 static struct symbol *find_symbol_by_index(struct elf *elf, unsigned int idx)
138 {
139 	struct symbol *sym;
140 
141 	hash_for_each_possible(elf->symbol_hash, sym, hash, idx)
142 		if (sym->idx == idx)
143 			return sym;
144 
145 	return NULL;
146 }
147 
148 struct symbol *find_symbol_by_offset(struct section *sec, unsigned long offset)
149 {
150 	struct rb_node *node;
151 
152 	rb_for_each(&sec->symbol_tree, node, &offset, symbol_by_offset) {
153 		struct symbol *s = rb_entry(node, struct symbol, node);
154 
155 		if (s->offset == offset && s->type != STT_SECTION)
156 			return s;
157 	}
158 
159 	return NULL;
160 }
161 
162 struct symbol *find_func_by_offset(struct section *sec, unsigned long offset)
163 {
164 	struct rb_node *node;
165 
166 	rb_for_each(&sec->symbol_tree, node, &offset, symbol_by_offset) {
167 		struct symbol *s = rb_entry(node, struct symbol, node);
168 
169 		if (s->offset == offset && s->type == STT_FUNC)
170 			return s;
171 	}
172 
173 	return NULL;
174 }
175 
176 struct symbol *find_symbol_containing(struct section *sec, unsigned long offset)
177 {
178 	struct rb_node *node;
179 
180 	rb_for_each(&sec->symbol_tree, node, &offset, symbol_by_offset) {
181 		struct symbol *s = rb_entry(node, struct symbol, node);
182 
183 		if (s->type != STT_SECTION)
184 			return s;
185 	}
186 
187 	return NULL;
188 }
189 
190 struct symbol *find_func_containing(struct section *sec, unsigned long offset)
191 {
192 	struct rb_node *node;
193 
194 	rb_for_each(&sec->symbol_tree, node, &offset, symbol_by_offset) {
195 		struct symbol *s = rb_entry(node, struct symbol, node);
196 
197 		if (s->type == STT_FUNC)
198 			return s;
199 	}
200 
201 	return NULL;
202 }
203 
204 struct symbol *find_symbol_by_name(struct elf *elf, const char *name)
205 {
206 	struct symbol *sym;
207 
208 	hash_for_each_possible(elf->symbol_name_hash, sym, name_hash, str_hash(name))
209 		if (!strcmp(sym->name, name))
210 			return sym;
211 
212 	return NULL;
213 }
214 
215 struct rela *find_rela_by_dest_range(struct elf *elf, struct section *sec,
216 				     unsigned long offset, unsigned int len)
217 {
218 	struct rela *rela, *r = NULL;
219 	unsigned long o;
220 
221 	if (!sec->rela)
222 		return NULL;
223 
224 	sec = sec->rela;
225 
226 	for_offset_range(o, offset, offset + len) {
227 		hash_for_each_possible(elf->rela_hash, rela, hash,
228 				       sec_offset_hash(sec, o)) {
229 			if (rela->sec != sec)
230 				continue;
231 
232 			if (rela->offset >= offset && rela->offset < offset + len) {
233 				if (!r || rela->offset < r->offset)
234 					r = rela;
235 			}
236 		}
237 		if (r)
238 			return r;
239 	}
240 
241 	return NULL;
242 }
243 
244 struct rela *find_rela_by_dest(struct elf *elf, struct section *sec, unsigned long offset)
245 {
246 	return find_rela_by_dest_range(elf, sec, offset, 1);
247 }
248 
249 static int read_sections(struct elf *elf)
250 {
251 	Elf_Scn *s = NULL;
252 	struct section *sec;
253 	size_t shstrndx, sections_nr;
254 	int i;
255 
256 	if (elf_getshdrnum(elf->elf, &sections_nr)) {
257 		WARN_ELF("elf_getshdrnum");
258 		return -1;
259 	}
260 
261 	if (elf_getshdrstrndx(elf->elf, &shstrndx)) {
262 		WARN_ELF("elf_getshdrstrndx");
263 		return -1;
264 	}
265 
266 	for (i = 0; i < sections_nr; i++) {
267 		sec = malloc(sizeof(*sec));
268 		if (!sec) {
269 			perror("malloc");
270 			return -1;
271 		}
272 		memset(sec, 0, sizeof(*sec));
273 
274 		INIT_LIST_HEAD(&sec->symbol_list);
275 		INIT_LIST_HEAD(&sec->rela_list);
276 
277 		s = elf_getscn(elf->elf, i);
278 		if (!s) {
279 			WARN_ELF("elf_getscn");
280 			return -1;
281 		}
282 
283 		sec->idx = elf_ndxscn(s);
284 
285 		if (!gelf_getshdr(s, &sec->sh)) {
286 			WARN_ELF("gelf_getshdr");
287 			return -1;
288 		}
289 
290 		sec->name = elf_strptr(elf->elf, shstrndx, sec->sh.sh_name);
291 		if (!sec->name) {
292 			WARN_ELF("elf_strptr");
293 			return -1;
294 		}
295 
296 		if (sec->sh.sh_size != 0) {
297 			sec->data = elf_getdata(s, NULL);
298 			if (!sec->data) {
299 				WARN_ELF("elf_getdata");
300 				return -1;
301 			}
302 			if (sec->data->d_off != 0 ||
303 			    sec->data->d_size != sec->sh.sh_size) {
304 				WARN("unexpected data attributes for %s",
305 				     sec->name);
306 				return -1;
307 			}
308 		}
309 		sec->len = sec->sh.sh_size;
310 
311 		list_add_tail(&sec->list, &elf->sections);
312 		hash_add(elf->section_hash, &sec->hash, sec->idx);
313 		hash_add(elf->section_name_hash, &sec->name_hash, str_hash(sec->name));
314 	}
315 
316 	if (stats)
317 		printf("nr_sections: %lu\n", (unsigned long)sections_nr);
318 
319 	/* sanity check, one more call to elf_nextscn() should return NULL */
320 	if (elf_nextscn(elf->elf, s)) {
321 		WARN("section entry mismatch");
322 		return -1;
323 	}
324 
325 	return 0;
326 }
327 
328 static int read_symbols(struct elf *elf)
329 {
330 	struct section *symtab, *sec;
331 	struct symbol *sym, *pfunc;
332 	struct list_head *entry;
333 	struct rb_node *pnode;
334 	int symbols_nr, i;
335 	char *coldstr;
336 
337 	symtab = find_section_by_name(elf, ".symtab");
338 	if (!symtab) {
339 		WARN("missing symbol table");
340 		return -1;
341 	}
342 
343 	symbols_nr = symtab->sh.sh_size / symtab->sh.sh_entsize;
344 
345 	for (i = 0; i < symbols_nr; i++) {
346 		sym = malloc(sizeof(*sym));
347 		if (!sym) {
348 			perror("malloc");
349 			return -1;
350 		}
351 		memset(sym, 0, sizeof(*sym));
352 		sym->alias = sym;
353 
354 		sym->idx = i;
355 
356 		if (!gelf_getsym(symtab->data, i, &sym->sym)) {
357 			WARN_ELF("gelf_getsym");
358 			goto err;
359 		}
360 
361 		sym->name = elf_strptr(elf->elf, symtab->sh.sh_link,
362 				       sym->sym.st_name);
363 		if (!sym->name) {
364 			WARN_ELF("elf_strptr");
365 			goto err;
366 		}
367 
368 		sym->type = GELF_ST_TYPE(sym->sym.st_info);
369 		sym->bind = GELF_ST_BIND(sym->sym.st_info);
370 
371 		if (sym->sym.st_shndx > SHN_UNDEF &&
372 		    sym->sym.st_shndx < SHN_LORESERVE) {
373 			sym->sec = find_section_by_index(elf,
374 							 sym->sym.st_shndx);
375 			if (!sym->sec) {
376 				WARN("couldn't find section for symbol %s",
377 				     sym->name);
378 				goto err;
379 			}
380 			if (sym->type == STT_SECTION) {
381 				sym->name = sym->sec->name;
382 				sym->sec->sym = sym;
383 			}
384 		} else
385 			sym->sec = find_section_by_index(elf, 0);
386 
387 		sym->offset = sym->sym.st_value;
388 		sym->len = sym->sym.st_size;
389 
390 		rb_add(&sym->sec->symbol_tree, &sym->node, symbol_to_offset);
391 		pnode = rb_prev(&sym->node);
392 		if (pnode)
393 			entry = &rb_entry(pnode, struct symbol, node)->list;
394 		else
395 			entry = &sym->sec->symbol_list;
396 		list_add(&sym->list, entry);
397 		hash_add(elf->symbol_hash, &sym->hash, sym->idx);
398 		hash_add(elf->symbol_name_hash, &sym->name_hash, str_hash(sym->name));
399 	}
400 
401 	if (stats)
402 		printf("nr_symbols: %lu\n", (unsigned long)symbols_nr);
403 
404 	/* Create parent/child links for any cold subfunctions */
405 	list_for_each_entry(sec, &elf->sections, list) {
406 		list_for_each_entry(sym, &sec->symbol_list, list) {
407 			char pname[MAX_NAME_LEN + 1];
408 			size_t pnamelen;
409 			if (sym->type != STT_FUNC)
410 				continue;
411 			sym->pfunc = sym->cfunc = sym;
412 			coldstr = strstr(sym->name, ".cold");
413 			if (!coldstr)
414 				continue;
415 
416 			pnamelen = coldstr - sym->name;
417 			if (pnamelen > MAX_NAME_LEN) {
418 				WARN("%s(): parent function name exceeds maximum length of %d characters",
419 				     sym->name, MAX_NAME_LEN);
420 				return -1;
421 			}
422 
423 			strncpy(pname, sym->name, pnamelen);
424 			pname[pnamelen] = '\0';
425 			pfunc = find_symbol_by_name(elf, pname);
426 
427 			if (!pfunc) {
428 				WARN("%s(): can't find parent function",
429 				     sym->name);
430 				return -1;
431 			}
432 
433 			sym->pfunc = pfunc;
434 			pfunc->cfunc = sym;
435 
436 			/*
437 			 * Unfortunately, -fnoreorder-functions puts the child
438 			 * inside the parent.  Remove the overlap so we can
439 			 * have sane assumptions.
440 			 *
441 			 * Note that pfunc->len now no longer matches
442 			 * pfunc->sym.st_size.
443 			 */
444 			if (sym->sec == pfunc->sec &&
445 			    sym->offset >= pfunc->offset &&
446 			    sym->offset + sym->len == pfunc->offset + pfunc->len) {
447 				pfunc->len -= sym->len;
448 			}
449 		}
450 	}
451 
452 	return 0;
453 
454 err:
455 	free(sym);
456 	return -1;
457 }
458 
459 static int read_relas(struct elf *elf)
460 {
461 	struct section *sec;
462 	struct rela *rela;
463 	int i;
464 	unsigned int symndx;
465 	unsigned long nr_rela, max_rela = 0, tot_rela = 0;
466 
467 	list_for_each_entry(sec, &elf->sections, list) {
468 		if (sec->sh.sh_type != SHT_RELA)
469 			continue;
470 
471 		sec->base = find_section_by_name(elf, sec->name + 5);
472 		if (!sec->base) {
473 			WARN("can't find base section for rela section %s",
474 			     sec->name);
475 			return -1;
476 		}
477 
478 		sec->base->rela = sec;
479 
480 		nr_rela = 0;
481 		for (i = 0; i < sec->sh.sh_size / sec->sh.sh_entsize; i++) {
482 			rela = malloc(sizeof(*rela));
483 			if (!rela) {
484 				perror("malloc");
485 				return -1;
486 			}
487 			memset(rela, 0, sizeof(*rela));
488 
489 			if (!gelf_getrela(sec->data, i, &rela->rela)) {
490 				WARN_ELF("gelf_getrela");
491 				return -1;
492 			}
493 
494 			rela->type = GELF_R_TYPE(rela->rela.r_info);
495 			rela->addend = rela->rela.r_addend;
496 			rela->offset = rela->rela.r_offset;
497 			symndx = GELF_R_SYM(rela->rela.r_info);
498 			rela->sym = find_symbol_by_index(elf, symndx);
499 			rela->sec = sec;
500 			if (!rela->sym) {
501 				WARN("can't find rela entry symbol %d for %s",
502 				     symndx, sec->name);
503 				return -1;
504 			}
505 
506 			list_add_tail(&rela->list, &sec->rela_list);
507 			hash_add(elf->rela_hash, &rela->hash, rela_hash(rela));
508 			nr_rela++;
509 		}
510 		max_rela = max(max_rela, nr_rela);
511 		tot_rela += nr_rela;
512 	}
513 
514 	if (stats) {
515 		printf("max_rela: %lu\n", max_rela);
516 		printf("tot_rela: %lu\n", tot_rela);
517 	}
518 
519 	return 0;
520 }
521 
522 struct elf *elf_read(const char *name, int flags)
523 {
524 	struct elf *elf;
525 	Elf_Cmd cmd;
526 
527 	elf_version(EV_CURRENT);
528 
529 	elf = malloc(sizeof(*elf));
530 	if (!elf) {
531 		perror("malloc");
532 		return NULL;
533 	}
534 	memset(elf, 0, sizeof(*elf));
535 
536 	hash_init(elf->symbol_hash);
537 	hash_init(elf->symbol_name_hash);
538 	hash_init(elf->section_hash);
539 	hash_init(elf->section_name_hash);
540 	hash_init(elf->rela_hash);
541 	INIT_LIST_HEAD(&elf->sections);
542 
543 	elf->fd = open(name, flags);
544 	if (elf->fd == -1) {
545 		fprintf(stderr, "objtool: Can't open '%s': %s\n",
546 			name, strerror(errno));
547 		goto err;
548 	}
549 
550 	if ((flags & O_ACCMODE) == O_RDONLY)
551 		cmd = ELF_C_READ_MMAP;
552 	else if ((flags & O_ACCMODE) == O_RDWR)
553 		cmd = ELF_C_RDWR;
554 	else /* O_WRONLY */
555 		cmd = ELF_C_WRITE;
556 
557 	elf->elf = elf_begin(elf->fd, cmd, NULL);
558 	if (!elf->elf) {
559 		WARN_ELF("elf_begin");
560 		goto err;
561 	}
562 
563 	if (!gelf_getehdr(elf->elf, &elf->ehdr)) {
564 		WARN_ELF("gelf_getehdr");
565 		goto err;
566 	}
567 
568 	if (read_sections(elf))
569 		goto err;
570 
571 	if (read_symbols(elf))
572 		goto err;
573 
574 	if (read_relas(elf))
575 		goto err;
576 
577 	return elf;
578 
579 err:
580 	elf_close(elf);
581 	return NULL;
582 }
583 
584 struct section *elf_create_section(struct elf *elf, const char *name,
585 				   size_t entsize, int nr)
586 {
587 	struct section *sec, *shstrtab;
588 	size_t size = entsize * nr;
589 	Elf_Scn *s;
590 	Elf_Data *data;
591 
592 	sec = malloc(sizeof(*sec));
593 	if (!sec) {
594 		perror("malloc");
595 		return NULL;
596 	}
597 	memset(sec, 0, sizeof(*sec));
598 
599 	INIT_LIST_HEAD(&sec->symbol_list);
600 	INIT_LIST_HEAD(&sec->rela_list);
601 
602 	s = elf_newscn(elf->elf);
603 	if (!s) {
604 		WARN_ELF("elf_newscn");
605 		return NULL;
606 	}
607 
608 	sec->name = strdup(name);
609 	if (!sec->name) {
610 		perror("strdup");
611 		return NULL;
612 	}
613 
614 	sec->idx = elf_ndxscn(s);
615 	sec->len = size;
616 	sec->changed = true;
617 
618 	sec->data = elf_newdata(s);
619 	if (!sec->data) {
620 		WARN_ELF("elf_newdata");
621 		return NULL;
622 	}
623 
624 	sec->data->d_size = size;
625 	sec->data->d_align = 1;
626 
627 	if (size) {
628 		sec->data->d_buf = malloc(size);
629 		if (!sec->data->d_buf) {
630 			perror("malloc");
631 			return NULL;
632 		}
633 		memset(sec->data->d_buf, 0, size);
634 	}
635 
636 	if (!gelf_getshdr(s, &sec->sh)) {
637 		WARN_ELF("gelf_getshdr");
638 		return NULL;
639 	}
640 
641 	sec->sh.sh_size = size;
642 	sec->sh.sh_entsize = entsize;
643 	sec->sh.sh_type = SHT_PROGBITS;
644 	sec->sh.sh_addralign = 1;
645 	sec->sh.sh_flags = SHF_ALLOC;
646 
647 
648 	/* Add section name to .shstrtab (or .strtab for Clang) */
649 	shstrtab = find_section_by_name(elf, ".shstrtab");
650 	if (!shstrtab)
651 		shstrtab = find_section_by_name(elf, ".strtab");
652 	if (!shstrtab) {
653 		WARN("can't find .shstrtab or .strtab section");
654 		return NULL;
655 	}
656 
657 	s = elf_getscn(elf->elf, shstrtab->idx);
658 	if (!s) {
659 		WARN_ELF("elf_getscn");
660 		return NULL;
661 	}
662 
663 	data = elf_newdata(s);
664 	if (!data) {
665 		WARN_ELF("elf_newdata");
666 		return NULL;
667 	}
668 
669 	data->d_buf = sec->name;
670 	data->d_size = strlen(name) + 1;
671 	data->d_align = 1;
672 
673 	sec->sh.sh_name = shstrtab->len;
674 
675 	shstrtab->len += strlen(name) + 1;
676 	shstrtab->changed = true;
677 
678 	list_add_tail(&sec->list, &elf->sections);
679 	hash_add(elf->section_hash, &sec->hash, sec->idx);
680 	hash_add(elf->section_name_hash, &sec->name_hash, str_hash(sec->name));
681 
682 	return sec;
683 }
684 
685 struct section *elf_create_rela_section(struct elf *elf, struct section *base)
686 {
687 	char *relaname;
688 	struct section *sec;
689 
690 	relaname = malloc(strlen(base->name) + strlen(".rela") + 1);
691 	if (!relaname) {
692 		perror("malloc");
693 		return NULL;
694 	}
695 	strcpy(relaname, ".rela");
696 	strcat(relaname, base->name);
697 
698 	sec = elf_create_section(elf, relaname, sizeof(GElf_Rela), 0);
699 	free(relaname);
700 	if (!sec)
701 		return NULL;
702 
703 	base->rela = sec;
704 	sec->base = base;
705 
706 	sec->sh.sh_type = SHT_RELA;
707 	sec->sh.sh_addralign = 8;
708 	sec->sh.sh_link = find_section_by_name(elf, ".symtab")->idx;
709 	sec->sh.sh_info = base->idx;
710 	sec->sh.sh_flags = SHF_INFO_LINK;
711 
712 	return sec;
713 }
714 
715 int elf_rebuild_rela_section(struct section *sec)
716 {
717 	struct rela *rela;
718 	int nr, idx = 0, size;
719 	GElf_Rela *relas;
720 
721 	nr = 0;
722 	list_for_each_entry(rela, &sec->rela_list, list)
723 		nr++;
724 
725 	size = nr * sizeof(*relas);
726 	relas = malloc(size);
727 	if (!relas) {
728 		perror("malloc");
729 		return -1;
730 	}
731 
732 	sec->data->d_buf = relas;
733 	sec->data->d_size = size;
734 
735 	sec->sh.sh_size = size;
736 
737 	idx = 0;
738 	list_for_each_entry(rela, &sec->rela_list, list) {
739 		relas[idx].r_offset = rela->offset;
740 		relas[idx].r_addend = rela->addend;
741 		relas[idx].r_info = GELF_R_INFO(rela->sym->idx, rela->type);
742 		idx++;
743 	}
744 
745 	return 0;
746 }
747 
748 int elf_write(struct elf *elf)
749 {
750 	struct section *sec;
751 	Elf_Scn *s;
752 
753 	/* Update section headers for changed sections: */
754 	list_for_each_entry(sec, &elf->sections, list) {
755 		if (sec->changed) {
756 			s = elf_getscn(elf->elf, sec->idx);
757 			if (!s) {
758 				WARN_ELF("elf_getscn");
759 				return -1;
760 			}
761 			if (!gelf_update_shdr(s, &sec->sh)) {
762 				WARN_ELF("gelf_update_shdr");
763 				return -1;
764 			}
765 		}
766 	}
767 
768 	/* Make sure the new section header entries get updated properly. */
769 	elf_flagelf(elf->elf, ELF_C_SET, ELF_F_DIRTY);
770 
771 	/* Write all changes to the file. */
772 	if (elf_update(elf->elf, ELF_C_WRITE) < 0) {
773 		WARN_ELF("elf_update");
774 		return -1;
775 	}
776 
777 	return 0;
778 }
779 
780 void elf_close(struct elf *elf)
781 {
782 	struct section *sec, *tmpsec;
783 	struct symbol *sym, *tmpsym;
784 	struct rela *rela, *tmprela;
785 
786 	if (elf->elf)
787 		elf_end(elf->elf);
788 
789 	if (elf->fd > 0)
790 		close(elf->fd);
791 
792 	list_for_each_entry_safe(sec, tmpsec, &elf->sections, list) {
793 		list_for_each_entry_safe(sym, tmpsym, &sec->symbol_list, list) {
794 			list_del(&sym->list);
795 			hash_del(&sym->hash);
796 			free(sym);
797 		}
798 		list_for_each_entry_safe(rela, tmprela, &sec->rela_list, list) {
799 			list_del(&rela->list);
800 			hash_del(&rela->hash);
801 			free(rela);
802 		}
803 		list_del(&sec->list);
804 		free(sec);
805 	}
806 
807 	free(elf);
808 }
809