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 rela *find_rela_by_dest_range(const struct elf *elf, struct section *sec, 232 unsigned long offset, unsigned int len) 233 { 234 struct rela *rela, *r = NULL; 235 unsigned long o; 236 237 if (!sec->rela) 238 return NULL; 239 240 sec = sec->rela; 241 242 for_offset_range(o, offset, offset + len) { 243 elf_hash_for_each_possible(elf->rela_hash, rela, hash, 244 sec_offset_hash(sec, o)) { 245 if (rela->sec != sec) 246 continue; 247 248 if (rela->offset >= offset && rela->offset < offset + len) { 249 if (!r || rela->offset < r->offset) 250 r = rela; 251 } 252 } 253 if (r) 254 return r; 255 } 256 257 return NULL; 258 } 259 260 struct rela *find_rela_by_dest(const struct elf *elf, struct section *sec, unsigned long offset) 261 { 262 return find_rela_by_dest_range(elf, sec, offset, 1); 263 } 264 265 static int read_sections(struct elf *elf) 266 { 267 Elf_Scn *s = NULL; 268 struct section *sec; 269 size_t shstrndx, sections_nr; 270 int i; 271 272 if (elf_getshdrnum(elf->elf, §ions_nr)) { 273 WARN_ELF("elf_getshdrnum"); 274 return -1; 275 } 276 277 if (elf_getshdrstrndx(elf->elf, &shstrndx)) { 278 WARN_ELF("elf_getshdrstrndx"); 279 return -1; 280 } 281 282 for (i = 0; i < sections_nr; i++) { 283 sec = malloc(sizeof(*sec)); 284 if (!sec) { 285 perror("malloc"); 286 return -1; 287 } 288 memset(sec, 0, sizeof(*sec)); 289 290 INIT_LIST_HEAD(&sec->symbol_list); 291 INIT_LIST_HEAD(&sec->rela_list); 292 293 s = elf_getscn(elf->elf, i); 294 if (!s) { 295 WARN_ELF("elf_getscn"); 296 return -1; 297 } 298 299 sec->idx = elf_ndxscn(s); 300 301 if (!gelf_getshdr(s, &sec->sh)) { 302 WARN_ELF("gelf_getshdr"); 303 return -1; 304 } 305 306 sec->name = elf_strptr(elf->elf, shstrndx, sec->sh.sh_name); 307 if (!sec->name) { 308 WARN_ELF("elf_strptr"); 309 return -1; 310 } 311 312 if (sec->sh.sh_size != 0) { 313 sec->data = elf_getdata(s, NULL); 314 if (!sec->data) { 315 WARN_ELF("elf_getdata"); 316 return -1; 317 } 318 if (sec->data->d_off != 0 || 319 sec->data->d_size != sec->sh.sh_size) { 320 WARN("unexpected data attributes for %s", 321 sec->name); 322 return -1; 323 } 324 } 325 sec->len = sec->sh.sh_size; 326 327 list_add_tail(&sec->list, &elf->sections); 328 elf_hash_add(elf->section_hash, &sec->hash, sec->idx); 329 elf_hash_add(elf->section_name_hash, &sec->name_hash, str_hash(sec->name)); 330 } 331 332 if (stats) 333 printf("nr_sections: %lu\n", (unsigned long)sections_nr); 334 335 /* sanity check, one more call to elf_nextscn() should return NULL */ 336 if (elf_nextscn(elf->elf, s)) { 337 WARN("section entry mismatch"); 338 return -1; 339 } 340 341 return 0; 342 } 343 344 static int read_symbols(struct elf *elf) 345 { 346 struct section *symtab, *sec; 347 struct symbol *sym, *pfunc; 348 struct list_head *entry; 349 struct rb_node *pnode; 350 int symbols_nr, i; 351 char *coldstr; 352 353 symtab = find_section_by_name(elf, ".symtab"); 354 if (!symtab) { 355 WARN("missing symbol table"); 356 return -1; 357 } 358 359 symbols_nr = symtab->sh.sh_size / symtab->sh.sh_entsize; 360 361 for (i = 0; i < symbols_nr; i++) { 362 sym = malloc(sizeof(*sym)); 363 if (!sym) { 364 perror("malloc"); 365 return -1; 366 } 367 memset(sym, 0, sizeof(*sym)); 368 sym->alias = sym; 369 370 sym->idx = i; 371 372 if (!gelf_getsym(symtab->data, i, &sym->sym)) { 373 WARN_ELF("gelf_getsym"); 374 goto err; 375 } 376 377 sym->name = elf_strptr(elf->elf, symtab->sh.sh_link, 378 sym->sym.st_name); 379 if (!sym->name) { 380 WARN_ELF("elf_strptr"); 381 goto err; 382 } 383 384 sym->type = GELF_ST_TYPE(sym->sym.st_info); 385 sym->bind = GELF_ST_BIND(sym->sym.st_info); 386 387 if (sym->sym.st_shndx > SHN_UNDEF && 388 sym->sym.st_shndx < SHN_LORESERVE) { 389 sym->sec = find_section_by_index(elf, 390 sym->sym.st_shndx); 391 if (!sym->sec) { 392 WARN("couldn't find section for symbol %s", 393 sym->name); 394 goto err; 395 } 396 if (sym->type == STT_SECTION) { 397 sym->name = sym->sec->name; 398 sym->sec->sym = sym; 399 } 400 } else 401 sym->sec = find_section_by_index(elf, 0); 402 403 sym->offset = sym->sym.st_value; 404 sym->len = sym->sym.st_size; 405 406 rb_add(&sym->sec->symbol_tree, &sym->node, symbol_to_offset); 407 pnode = rb_prev(&sym->node); 408 if (pnode) 409 entry = &rb_entry(pnode, struct symbol, node)->list; 410 else 411 entry = &sym->sec->symbol_list; 412 list_add(&sym->list, entry); 413 elf_hash_add(elf->symbol_hash, &sym->hash, sym->idx); 414 elf_hash_add(elf->symbol_name_hash, &sym->name_hash, str_hash(sym->name)); 415 } 416 417 if (stats) 418 printf("nr_symbols: %lu\n", (unsigned long)symbols_nr); 419 420 /* Create parent/child links for any cold subfunctions */ 421 list_for_each_entry(sec, &elf->sections, list) { 422 list_for_each_entry(sym, &sec->symbol_list, list) { 423 char pname[MAX_NAME_LEN + 1]; 424 size_t pnamelen; 425 if (sym->type != STT_FUNC) 426 continue; 427 sym->pfunc = sym->cfunc = sym; 428 coldstr = strstr(sym->name, ".cold"); 429 if (!coldstr) 430 continue; 431 432 pnamelen = coldstr - sym->name; 433 if (pnamelen > MAX_NAME_LEN) { 434 WARN("%s(): parent function name exceeds maximum length of %d characters", 435 sym->name, MAX_NAME_LEN); 436 return -1; 437 } 438 439 strncpy(pname, sym->name, pnamelen); 440 pname[pnamelen] = '\0'; 441 pfunc = find_symbol_by_name(elf, pname); 442 443 if (!pfunc) { 444 WARN("%s(): can't find parent function", 445 sym->name); 446 return -1; 447 } 448 449 sym->pfunc = pfunc; 450 pfunc->cfunc = sym; 451 452 /* 453 * Unfortunately, -fnoreorder-functions puts the child 454 * inside the parent. Remove the overlap so we can 455 * have sane assumptions. 456 * 457 * Note that pfunc->len now no longer matches 458 * pfunc->sym.st_size. 459 */ 460 if (sym->sec == pfunc->sec && 461 sym->offset >= pfunc->offset && 462 sym->offset + sym->len == pfunc->offset + pfunc->len) { 463 pfunc->len -= sym->len; 464 } 465 } 466 } 467 468 return 0; 469 470 err: 471 free(sym); 472 return -1; 473 } 474 475 void elf_add_rela(struct elf *elf, struct rela *rela) 476 { 477 struct section *sec = rela->sec; 478 479 list_add_tail(&rela->list, &sec->rela_list); 480 elf_hash_add(elf->rela_hash, &rela->hash, rela_hash(rela)); 481 } 482 483 static int read_relas(struct elf *elf) 484 { 485 struct section *sec; 486 struct rela *rela; 487 int i; 488 unsigned int symndx; 489 unsigned long nr_rela, max_rela = 0, tot_rela = 0; 490 491 list_for_each_entry(sec, &elf->sections, list) { 492 if (sec->sh.sh_type != SHT_RELA) 493 continue; 494 495 sec->base = find_section_by_name(elf, sec->name + 5); 496 if (!sec->base) { 497 WARN("can't find base section for rela section %s", 498 sec->name); 499 return -1; 500 } 501 502 sec->base->rela = sec; 503 504 nr_rela = 0; 505 for (i = 0; i < sec->sh.sh_size / sec->sh.sh_entsize; i++) { 506 rela = malloc(sizeof(*rela)); 507 if (!rela) { 508 perror("malloc"); 509 return -1; 510 } 511 memset(rela, 0, sizeof(*rela)); 512 513 if (!gelf_getrela(sec->data, i, &rela->rela)) { 514 WARN_ELF("gelf_getrela"); 515 return -1; 516 } 517 518 rela->type = GELF_R_TYPE(rela->rela.r_info); 519 rela->addend = rela->rela.r_addend; 520 rela->offset = rela->rela.r_offset; 521 symndx = GELF_R_SYM(rela->rela.r_info); 522 rela->sym = find_symbol_by_index(elf, symndx); 523 rela->sec = sec; 524 if (!rela->sym) { 525 WARN("can't find rela entry symbol %d for %s", 526 symndx, sec->name); 527 return -1; 528 } 529 530 elf_add_rela(elf, rela); 531 nr_rela++; 532 } 533 max_rela = max(max_rela, nr_rela); 534 tot_rela += nr_rela; 535 } 536 537 if (stats) { 538 printf("max_rela: %lu\n", max_rela); 539 printf("tot_rela: %lu\n", tot_rela); 540 } 541 542 return 0; 543 } 544 545 struct elf *elf_open_read(const char *name, int flags) 546 { 547 struct elf *elf; 548 Elf_Cmd cmd; 549 550 elf_version(EV_CURRENT); 551 552 elf = malloc(sizeof(*elf)); 553 if (!elf) { 554 perror("malloc"); 555 return NULL; 556 } 557 memset(elf, 0, offsetof(struct elf, sections)); 558 559 INIT_LIST_HEAD(&elf->sections); 560 561 elf_hash_init(elf->symbol_hash); 562 elf_hash_init(elf->symbol_name_hash); 563 elf_hash_init(elf->section_hash); 564 elf_hash_init(elf->section_name_hash); 565 elf_hash_init(elf->rela_hash); 566 567 elf->fd = open(name, flags); 568 if (elf->fd == -1) { 569 fprintf(stderr, "objtool: Can't open '%s': %s\n", 570 name, strerror(errno)); 571 goto err; 572 } 573 574 if ((flags & O_ACCMODE) == O_RDONLY) 575 cmd = ELF_C_READ_MMAP; 576 else if ((flags & O_ACCMODE) == O_RDWR) 577 cmd = ELF_C_RDWR; 578 else /* O_WRONLY */ 579 cmd = ELF_C_WRITE; 580 581 elf->elf = elf_begin(elf->fd, cmd, NULL); 582 if (!elf->elf) { 583 WARN_ELF("elf_begin"); 584 goto err; 585 } 586 587 if (!gelf_getehdr(elf->elf, &elf->ehdr)) { 588 WARN_ELF("gelf_getehdr"); 589 goto err; 590 } 591 592 if (read_sections(elf)) 593 goto err; 594 595 if (read_symbols(elf)) 596 goto err; 597 598 if (read_relas(elf)) 599 goto err; 600 601 return elf; 602 603 err: 604 elf_close(elf); 605 return NULL; 606 } 607 608 struct section *elf_create_section(struct elf *elf, const char *name, 609 size_t entsize, int nr) 610 { 611 struct section *sec, *shstrtab; 612 size_t size = entsize * nr; 613 Elf_Scn *s; 614 Elf_Data *data; 615 616 sec = malloc(sizeof(*sec)); 617 if (!sec) { 618 perror("malloc"); 619 return NULL; 620 } 621 memset(sec, 0, sizeof(*sec)); 622 623 INIT_LIST_HEAD(&sec->symbol_list); 624 INIT_LIST_HEAD(&sec->rela_list); 625 626 s = elf_newscn(elf->elf); 627 if (!s) { 628 WARN_ELF("elf_newscn"); 629 return NULL; 630 } 631 632 sec->name = strdup(name); 633 if (!sec->name) { 634 perror("strdup"); 635 return NULL; 636 } 637 638 sec->idx = elf_ndxscn(s); 639 sec->len = size; 640 sec->changed = true; 641 642 sec->data = elf_newdata(s); 643 if (!sec->data) { 644 WARN_ELF("elf_newdata"); 645 return NULL; 646 } 647 648 sec->data->d_size = size; 649 sec->data->d_align = 1; 650 651 if (size) { 652 sec->data->d_buf = malloc(size); 653 if (!sec->data->d_buf) { 654 perror("malloc"); 655 return NULL; 656 } 657 memset(sec->data->d_buf, 0, size); 658 } 659 660 if (!gelf_getshdr(s, &sec->sh)) { 661 WARN_ELF("gelf_getshdr"); 662 return NULL; 663 } 664 665 sec->sh.sh_size = size; 666 sec->sh.sh_entsize = entsize; 667 sec->sh.sh_type = SHT_PROGBITS; 668 sec->sh.sh_addralign = 1; 669 sec->sh.sh_flags = SHF_ALLOC; 670 671 672 /* Add section name to .shstrtab (or .strtab for Clang) */ 673 shstrtab = find_section_by_name(elf, ".shstrtab"); 674 if (!shstrtab) 675 shstrtab = find_section_by_name(elf, ".strtab"); 676 if (!shstrtab) { 677 WARN("can't find .shstrtab or .strtab section"); 678 return NULL; 679 } 680 681 s = elf_getscn(elf->elf, shstrtab->idx); 682 if (!s) { 683 WARN_ELF("elf_getscn"); 684 return NULL; 685 } 686 687 data = elf_newdata(s); 688 if (!data) { 689 WARN_ELF("elf_newdata"); 690 return NULL; 691 } 692 693 data->d_buf = sec->name; 694 data->d_size = strlen(name) + 1; 695 data->d_align = 1; 696 697 sec->sh.sh_name = shstrtab->len; 698 699 shstrtab->len += strlen(name) + 1; 700 shstrtab->changed = true; 701 702 list_add_tail(&sec->list, &elf->sections); 703 elf_hash_add(elf->section_hash, &sec->hash, sec->idx); 704 elf_hash_add(elf->section_name_hash, &sec->name_hash, str_hash(sec->name)); 705 706 return sec; 707 } 708 709 struct section *elf_create_rela_section(struct elf *elf, struct section *base) 710 { 711 char *relaname; 712 struct section *sec; 713 714 relaname = malloc(strlen(base->name) + strlen(".rela") + 1); 715 if (!relaname) { 716 perror("malloc"); 717 return NULL; 718 } 719 strcpy(relaname, ".rela"); 720 strcat(relaname, base->name); 721 722 sec = elf_create_section(elf, relaname, sizeof(GElf_Rela), 0); 723 free(relaname); 724 if (!sec) 725 return NULL; 726 727 base->rela = sec; 728 sec->base = base; 729 730 sec->sh.sh_type = SHT_RELA; 731 sec->sh.sh_addralign = 8; 732 sec->sh.sh_link = find_section_by_name(elf, ".symtab")->idx; 733 sec->sh.sh_info = base->idx; 734 sec->sh.sh_flags = SHF_INFO_LINK; 735 736 return sec; 737 } 738 739 int elf_rebuild_rela_section(struct section *sec) 740 { 741 struct rela *rela; 742 int nr, idx = 0, size; 743 GElf_Rela *relas; 744 745 nr = 0; 746 list_for_each_entry(rela, &sec->rela_list, list) 747 nr++; 748 749 size = nr * sizeof(*relas); 750 relas = malloc(size); 751 if (!relas) { 752 perror("malloc"); 753 return -1; 754 } 755 756 sec->data->d_buf = relas; 757 sec->data->d_size = size; 758 759 sec->sh.sh_size = size; 760 761 idx = 0; 762 list_for_each_entry(rela, &sec->rela_list, list) { 763 relas[idx].r_offset = rela->offset; 764 relas[idx].r_addend = rela->addend; 765 relas[idx].r_info = GELF_R_INFO(rela->sym->idx, rela->type); 766 idx++; 767 } 768 769 return 0; 770 } 771 772 int elf_write(const struct elf *elf) 773 { 774 struct section *sec; 775 Elf_Scn *s; 776 777 /* Update section headers for changed sections: */ 778 list_for_each_entry(sec, &elf->sections, list) { 779 if (sec->changed) { 780 s = elf_getscn(elf->elf, sec->idx); 781 if (!s) { 782 WARN_ELF("elf_getscn"); 783 return -1; 784 } 785 if (!gelf_update_shdr(s, &sec->sh)) { 786 WARN_ELF("gelf_update_shdr"); 787 return -1; 788 } 789 } 790 } 791 792 /* Make sure the new section header entries get updated properly. */ 793 elf_flagelf(elf->elf, ELF_C_SET, ELF_F_DIRTY); 794 795 /* Write all changes to the file. */ 796 if (elf_update(elf->elf, ELF_C_WRITE) < 0) { 797 WARN_ELF("elf_update"); 798 return -1; 799 } 800 801 return 0; 802 } 803 804 void elf_close(struct elf *elf) 805 { 806 struct section *sec, *tmpsec; 807 struct symbol *sym, *tmpsym; 808 struct rela *rela, *tmprela; 809 810 if (elf->elf) 811 elf_end(elf->elf); 812 813 if (elf->fd > 0) 814 close(elf->fd); 815 816 list_for_each_entry_safe(sec, tmpsec, &elf->sections, list) { 817 list_for_each_entry_safe(sym, tmpsym, &sec->symbol_list, list) { 818 list_del(&sym->list); 819 hash_del(&sym->hash); 820 free(sym); 821 } 822 list_for_each_entry_safe(rela, tmprela, &sec->rela_list, list) { 823 list_del(&rela->list); 824 hash_del(&rela->hash); 825 free(rela); 826 } 827 list_del(&sec->list); 828 free(sec); 829 } 830 831 free(elf); 832 } 833