tools/objtool/elf.c

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