tools/perf/util/symbol.c

   1 #include "util.h"
   2 #include "../perf.h"
   3 #include "string.h"
   4 #include "symbol.h"
   5
   6 #include <libelf.h>
   7 #include <gelf.h>
   8 #include <elf.h>
   9
  10 #ifndef NO_DEMANGLE
  11 #include <bfd.h>
  12 #else
  13 static inline
  14 char *bfd_demangle(void __used *v, const char __used *c, int __used i)
  15 {
  16         return NULL;
  17 }
  18 #endif
  19
  20 const char *sym_hist_filter;
  21
  22 #ifndef DMGL_PARAMS
  23 #define DMGL_PARAMS      (1 << 0)       /* Include function args */
  24 #define DMGL_ANSI        (1 << 1)       /* Include const, volatile, etc */
  25 #endif
  26
  27 enum dso_origin {
  28         DSO__ORIG_KERNEL = 0,
  29         DSO__ORIG_JAVA_JIT,
  30         DSO__ORIG_FEDORA,
  31         DSO__ORIG_UBUNTU,
  32         DSO__ORIG_BUILDID,
  33         DSO__ORIG_DSO,
  34         DSO__ORIG_NOT_FOUND,
  35 };
  36
  37 static struct symbol *symbol__new(u64 start, u64 len,
  38                                   const char *name, unsigned int priv_size,
  39                                   u64 obj_start, int verbose)
  40 {
  41         size_t namelen = strlen(name) + 1;
  42         struct symbol *self = calloc(1, priv_size + sizeof(*self) + namelen);
  43
  44         if (!self)
  45                 return NULL;
  46
  47         if (verbose >= 2)
  48                 printf("new symbol: %016Lx [%08lx]: %s, hist: %p, obj_start: %p\n",
  49                         (u64)start, (unsigned long)len, name, self->hist, (void *)(unsigned long)obj_start);
  50
  51         self->obj_start= obj_start;
  52         self->hist = NULL;
  53         self->hist_sum = 0;
  54
  55         if (sym_hist_filter && !strcmp(name, sym_hist_filter))
  56                 self->hist = calloc(sizeof(u64), len);
  57
  58         if (priv_size) {
  59                 memset(self, 0, priv_size);
  60                 self = ((void *)self) + priv_size;
  61         }
  62         self->start = start;
  63         self->end   = len ? start + len - 1 : start;
  64         memcpy(self->name, name, namelen);
  65
  66         return self;
  67 }
  68
  69 static void symbol__delete(struct symbol *self, unsigned int priv_size)
  70 {
  71         free(((void *)self) - priv_size);
  72 }
  73
  74 static size_t symbol__fprintf(struct symbol *self, FILE *fp)
  75 {
  76         if (!self->module)
  77                 return fprintf(fp, " %llx-%llx %s\n",
  78                        self->start, self->end, self->name);
  79         else
  80                 return fprintf(fp, " %llx-%llx %s \t[%s]\n",
  81                        self->start, self->end, self->name, self->module->name);
  82 }
  83
  84 struct dso *dso__new(const char *name, unsigned int sym_priv_size)
  85 {
  86         struct dso *self = malloc(sizeof(*self) + strlen(name) + 1);
  87
  88         if (self != NULL) {
  89                 strcpy(self->name, name);
  90                 self->syms = RB_ROOT;
  91                 self->sym_priv_size = sym_priv_size;
  92                 self->find_symbol = dso__find_symbol;
  93                 self->slen_calculated = 0;
  94                 self->origin = DSO__ORIG_NOT_FOUND;
  95         }
  96
  97         return self;
  98 }
  99
 100 static void dso__delete_symbols(struct dso *self)
 101 {
 102         struct symbol *pos;
 103         struct rb_node *next = rb_first(&self->syms);
 104
 105         while (next) {
 106                 pos = rb_entry(next, struct symbol, rb_node);
 107                 next = rb_next(&pos->rb_node);
 108                 rb_erase(&pos->rb_node, &self->syms);
 109                 symbol__delete(pos, self->sym_priv_size);
 110         }
 111 }
 112
 113 void dso__delete(struct dso *self)
 114 {
 115         dso__delete_symbols(self);
 116         free(self);
 117 }
 118
 119 static void dso__insert_symbol(struct dso *self, struct symbol *sym)
 120 {
 121         struct rb_node **p = &self->syms.rb_node;
 122         struct rb_node *parent = NULL;
 123         const u64 ip = sym->start;
 124         struct symbol *s;
 125
 126         while (*p != NULL) {
 127                 parent = *p;
 128                 s = rb_entry(parent, struct symbol, rb_node);
 129                 if (ip < s->start)
 130                         p = &(*p)->rb_left;
 131                 else
 132                         p = &(*p)->rb_right;
 133         }
 134         rb_link_node(&sym->rb_node, parent, p);
 135         rb_insert_color(&sym->rb_node, &self->syms);
 136 }
 137
 138 struct symbol *dso__find_symbol(struct dso *self, u64 ip)
 139 {
 140         struct rb_node *n;
 141
 142         if (self == NULL)
 143                 return NULL;
 144
 145         n = self->syms.rb_node;
 146
 147         while (n) {
 148                 struct symbol *s = rb_entry(n, struct symbol, rb_node);
 149
 150                 if (ip < s->start)
 151                         n = n->rb_left;
 152                 else if (ip > s->end)
 153                         n = n->rb_right;
 154                 else
 155                         return s;
 156         }
 157
 158         return NULL;
 159 }
 160
 161 size_t dso__fprintf(struct dso *self, FILE *fp)
 162 {
 163         size_t ret = fprintf(fp, "dso: %s\n", self->name);
 164
 165         struct rb_node *nd;
 166         for (nd = rb_first(&self->syms); nd; nd = rb_next(nd)) {
 167                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 168                 ret += symbol__fprintf(pos, fp);
 169         }
 170
 171         return ret;
 172 }
 173
 174 static int dso__load_kallsyms(struct dso *self, symbol_filter_t filter, int verbose)
 175 {
 176         struct rb_node *nd, *prevnd;
 177         char *line = NULL;
 178         size_t n;
 179         FILE *file = fopen("/proc/kallsyms", "r");
 180         int count = 0;
 181
 182         if (file == NULL)
 183                 goto out_failure;
 184
 185         while (!feof(file)) {
 186                 u64 start;
 187                 struct symbol *sym;
 188                 int line_len, len;
 189                 char symbol_type;
 190
 191                 line_len = getline(&line, &n, file);
 192                 if (line_len < 0)
 193                         break;
 194
 195                 if (!line)
 196                         goto out_failure;
 197
 198                 line[--line_len] = '\0'; /* \n */
 199
 200                 len = hex2u64(line, &start);
 201
 202                 len++;
 203                 if (len + 2 >= line_len)
 204                         continue;
 205
 206                 symbol_type = toupper(line[len]);
 207                 /*
 208                  * We're interested only in code ('T'ext)
 209                  */
 210                 if (symbol_type != 'T' && symbol_type != 'W')
 211                         continue;
 212                 /*
 213                  * Well fix up the end later, when we have all sorted.
 214                  */
 215                 sym = symbol__new(start, 0xdead, line + len + 2,
 216                                   self->sym_priv_size, 0, verbose);
 217
 218                 if (sym == NULL)
 219                         goto out_delete_line;
 220
 221                 if (filter && filter(self, sym))
 222                         symbol__delete(sym, self->sym_priv_size);
 223                 else {
 224                         dso__insert_symbol(self, sym);
 225                         count++;
 226                 }
 227         }
 228
 229         /*
 230          * Now that we have all sorted out, just set the ->end of all
 231          * symbols
 232          */
 233         prevnd = rb_first(&self->syms);
 234
 235         if (prevnd == NULL)
 236                 goto out_delete_line;
 237
 238         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 239                 struct symbol *prev = rb_entry(prevnd, struct symbol, rb_node),
 240                               *curr = rb_entry(nd, struct symbol, rb_node);
 241
 242                 prev->end = curr->start - 1;
 243                 prevnd = nd;
 244         }
 245
 246         free(line);
 247         fclose(file);
 248
 249         return count;
 250
 251 out_delete_line:
 252         free(line);
 253 out_failure:
 254         return -1;
 255 }
 256
 257 static int dso__load_perf_map(struct dso *self, symbol_filter_t filter, int verbose)
 258 {
 259         char *line = NULL;
 260         size_t n;
 261         FILE *file;
 262         int nr_syms = 0;
 263
 264         file = fopen(self->name, "r");
 265         if (file == NULL)
 266                 goto out_failure;
 267
 268         while (!feof(file)) {
 269                 u64 start, size;
 270                 struct symbol *sym;
 271                 int line_len, len;
 272
 273                 line_len = getline(&line, &n, file);
 274                 if (line_len < 0)
 275                         break;
 276
 277                 if (!line)
 278                         goto out_failure;
 279
 280                 line[--line_len] = '\0'; /* \n */
 281
 282                 len = hex2u64(line, &start);
 283
 284                 len++;
 285                 if (len + 2 >= line_len)
 286                         continue;
 287
 288                 len += hex2u64(line + len, &size);
 289
 290                 len++;
 291                 if (len + 2 >= line_len)
 292                         continue;
 293
 294                 sym = symbol__new(start, size, line + len,
 295                                   self->sym_priv_size, start, verbose);
 296
 297                 if (sym == NULL)
 298                         goto out_delete_line;
 299
 300                 if (filter && filter(self, sym))
 301                         symbol__delete(sym, self->sym_priv_size);
 302                 else {
 303                         dso__insert_symbol(self, sym);
 304                         nr_syms++;
 305                 }
 306         }
 307
 308         free(line);
 309         fclose(file);
 310
 311         return nr_syms;
 312
 313 out_delete_line:
 314         free(line);
 315 out_failure:
 316         return -1;
 317 }
 318
 319 /**
 320  * elf_symtab__for_each_symbol - iterate thru all the symbols
 321  *
 322  * @self: struct elf_symtab instance to iterate
 323  * @index: uint32_t index
 324  * @sym: GElf_Sym iterator
 325  */
 326 #define elf_symtab__for_each_symbol(syms, nr_syms, index, sym) \
 327         for (index = 0, gelf_getsym(syms, index, &sym);\
 328              index < nr_syms; \
 329              index++, gelf_getsym(syms, index, &sym))
 330
 331 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
 332 {
 333         return GELF_ST_TYPE(sym->st_info);
 334 }
 335
 336 static inline int elf_sym__is_function(const GElf_Sym *sym)
 337 {
 338         return elf_sym__type(sym) == STT_FUNC &&
 339                sym->st_name != 0 &&
 340                sym->st_shndx != SHN_UNDEF &&
 341                sym->st_size != 0;
 342 }
 343
 344 static inline int elf_sym__is_label(const GElf_Sym *sym)
 345 {
 346         return elf_sym__type(sym) == STT_NOTYPE &&
 347                 sym->st_name != 0 &&
 348                 sym->st_shndx != SHN_UNDEF &&
 349                 sym->st_shndx != SHN_ABS;
 350 }
 351
 352 static inline const char *elf_sec__name(const GElf_Shdr *shdr,
 353                                         const Elf_Data *secstrs)
 354 {
 355         return secstrs->d_buf + shdr->sh_name;
 356 }
 357
 358 static inline int elf_sec__is_text(const GElf_Shdr *shdr,
 359                                         const Elf_Data *secstrs)
 360 {
 361         return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
 362 }
 363
 364 static inline const char *elf_sym__name(const GElf_Sym *sym,
 365                                         const Elf_Data *symstrs)
 366 {
 367         return symstrs->d_buf + sym->st_name;
 368 }
 369
 370 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
 371                                     GElf_Shdr *shp, const char *name,
 372                                     size_t *index)
 373 {
 374         Elf_Scn *sec = NULL;
 375         size_t cnt = 1;
 376
 377         while ((sec = elf_nextscn(elf, sec)) != NULL) {
 378                 char *str;
 379
 380                 gelf_getshdr(sec, shp);
 381                 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
 382                 if (!strcmp(name, str)) {
 383                         if (index)
 384                                 *index = cnt;
 385                         break;
 386                 }
 387                 ++cnt;
 388         }
 389
 390         return sec;
 391 }
 392
 393 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
 394         for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
 395              idx < nr_entries; \
 396              ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
 397
 398 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
 399         for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
 400              idx < nr_entries; \
 401              ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
 402
 403 /*
 404  * We need to check if we have a .dynsym, so that we can handle the
 405  * .plt, synthesizing its symbols, that aren't on the symtabs (be it
 406  * .dynsym or .symtab).
 407  * And always look at the original dso, not at debuginfo packages, that
 408  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
 409  */
 410 static int dso__synthesize_plt_symbols(struct  dso *self, int verbose)
 411 {
 412         uint32_t nr_rel_entries, idx;
 413         GElf_Sym sym;
 414         u64 plt_offset;
 415         GElf_Shdr shdr_plt;
 416         struct symbol *f;
 417         GElf_Shdr shdr_rel_plt, shdr_dynsym;
 418         Elf_Data *reldata, *syms, *symstrs;
 419         Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
 420         size_t dynsym_idx;
 421         GElf_Ehdr ehdr;
 422         char sympltname[1024];
 423         Elf *elf;
 424         int nr = 0, symidx, fd, err = 0;
 425
 426         fd = open(self->name, O_RDONLY);
 427         if (fd < 0)
 428                 goto out;
 429
 430         elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
 431         if (elf == NULL)
 432                 goto out_close;
 433
 434         if (gelf_getehdr(elf, &ehdr) == NULL)
 435                 goto out_elf_end;
 436
 437         scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
 438                                          ".dynsym", &dynsym_idx);
 439         if (scn_dynsym == NULL)
 440                 goto out_elf_end;
 441
 442         scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 443                                           ".rela.plt", NULL);
 444         if (scn_plt_rel == NULL) {
 445                 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 446                                                   ".rel.plt", NULL);
 447                 if (scn_plt_rel == NULL)
 448                         goto out_elf_end;
 449         }
 450
 451         err = -1;
 452
 453         if (shdr_rel_plt.sh_link != dynsym_idx)
 454                 goto out_elf_end;
 455
 456         if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
 457                 goto out_elf_end;
 458
 459         /*
 460          * Fetch the relocation section to find the indexes to the GOT
 461          * and the symbols in the .dynsym they refer to.
 462          */
 463         reldata = elf_getdata(scn_plt_rel, NULL);
 464         if (reldata == NULL)
 465                 goto out_elf_end;
 466
 467         syms = elf_getdata(scn_dynsym, NULL);
 468         if (syms == NULL)
 469                 goto out_elf_end;
 470
 471         scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
 472         if (scn_symstrs == NULL)
 473                 goto out_elf_end;
 474
 475         symstrs = elf_getdata(scn_symstrs, NULL);
 476         if (symstrs == NULL)
 477                 goto out_elf_end;
 478
 479         nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
 480         plt_offset = shdr_plt.sh_offset;
 481
 482         if (shdr_rel_plt.sh_type == SHT_RELA) {
 483                 GElf_Rela pos_mem, *pos;
 484
 485                 elf_section__for_each_rela(reldata, pos, pos_mem, idx,
 486                                            nr_rel_entries) {
 487                         symidx = GELF_R_SYM(pos->r_info);
 488                         plt_offset += shdr_plt.sh_entsize;
 489                         gelf_getsym(syms, symidx, &sym);
 490                         snprintf(sympltname, sizeof(sympltname),
 491                                  "%s@plt", elf_sym__name(&sym, symstrs));
 492
 493                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
 494                                         sympltname, self->sym_priv_size, 0, verbose);
 495                         if (!f)
 496                                 goto out_elf_end;
 497
 498                         dso__insert_symbol(self, f);
 499                         ++nr;
 500                 }
 501         } else if (shdr_rel_plt.sh_type == SHT_REL) {
 502                 GElf_Rel pos_mem, *pos;
 503                 elf_section__for_each_rel(reldata, pos, pos_mem, idx,
 504                                           nr_rel_entries) {
 505                         symidx = GELF_R_SYM(pos->r_info);
 506                         plt_offset += shdr_plt.sh_entsize;
 507                         gelf_getsym(syms, symidx, &sym);
 508                         snprintf(sympltname, sizeof(sympltname),
 509                                  "%s@plt", elf_sym__name(&sym, symstrs));
 510
 511                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
 512                                         sympltname, self->sym_priv_size, 0, verbose);
 513                         if (!f)
 514                                 goto out_elf_end;
 515
 516                         dso__insert_symbol(self, f);
 517                         ++nr;
 518                 }
 519         }
 520
 521         err = 0;
 522 out_elf_end:
 523         elf_end(elf);
 524 out_close:
 525         close(fd);
 526
 527         if (err == 0)
 528                 return nr;
 529 out:
 530         fprintf(stderr, "%s: problems reading %s PLT info.\n",
 531                 __func__, self->name);
 532         return 0;
 533 }
 534
 535 static int dso__load_sym(struct dso *self, int fd, const char *name,
 536                          symbol_filter_t filter, int verbose, struct module *mod)
 537 {
 538         Elf_Data *symstrs, *secstrs;
 539         uint32_t nr_syms;
 540         int err = -1;
 541         uint32_t index;
 542         GElf_Ehdr ehdr;
 543         GElf_Shdr shdr;
 544         Elf_Data *syms;
 545         GElf_Sym sym;
 546         Elf_Scn *sec, *sec_strndx;
 547         Elf *elf;
 548         int nr = 0, kernel = !strcmp("[kernel]", self->name);
 549
 550         elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
 551         if (elf == NULL) {
 552                 if (verbose)
 553                         fprintf(stderr, "%s: cannot read %s ELF file.\n",
 554                                 __func__, name);
 555                 goto out_close;
 556         }
 557
 558         if (gelf_getehdr(elf, &ehdr) == NULL) {
 559                 if (verbose)
 560                         fprintf(stderr, "%s: cannot get elf header.\n", __func__);
 561                 goto out_elf_end;
 562         }
 563
 564         sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
 565         if (sec == NULL) {
 566                 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
 567                 if (sec == NULL)
 568                         goto out_elf_end;
 569         }
 570
 571         syms = elf_getdata(sec, NULL);
 572         if (syms == NULL)
 573                 goto out_elf_end;
 574
 575         sec = elf_getscn(elf, shdr.sh_link);
 576         if (sec == NULL)
 577                 goto out_elf_end;
 578
 579         symstrs = elf_getdata(sec, NULL);
 580         if (symstrs == NULL)
 581                 goto out_elf_end;
 582
 583         sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
 584         if (sec_strndx == NULL)
 585                 goto out_elf_end;
 586
 587         secstrs = elf_getdata(sec_strndx, NULL);
 588         if (secstrs == NULL)
 589                 goto out_elf_end;
 590
 591         nr_syms = shdr.sh_size / shdr.sh_entsize;
 592
 593         memset(&sym, 0, sizeof(sym));
 594         if (!kernel) {
 595                 self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
 596                                 elf_section_by_name(elf, &ehdr, &shdr,
 597                                                      ".gnu.prelink_undo",
 598                                                      NULL) != NULL);
 599         } else self->adjust_symbols = 0;
 600
 601         elf_symtab__for_each_symbol(syms, nr_syms, index, sym) {
 602                 struct symbol *f;
 603                 const char *name;
 604                 char *demangled;
 605                 u64 obj_start;
 606                 struct section *section = NULL;
 607                 int is_label = elf_sym__is_label(&sym);
 608                 const char *section_name;
 609
 610                 if (!is_label && !elf_sym__is_function(&sym))
 611                         continue;
 612
 613                 sec = elf_getscn(elf, sym.st_shndx);
 614                 if (!sec)
 615                         goto out_elf_end;
 616
 617                 gelf_getshdr(sec, &shdr);
 618
 619                 if (is_label && !elf_sec__is_text(&shdr, secstrs))
 620                         continue;
 621
 622                 section_name = elf_sec__name(&shdr, secstrs);
 623                 obj_start = sym.st_value;
 624
 625                 if (self->adjust_symbols) {
 626                         if (verbose >= 2)
 627                                 printf("adjusting symbol: st_value: %Lx sh_addr: %Lx sh_offset: %Lx\n",
 628                                         (u64)sym.st_value, (u64)shdr.sh_addr, (u64)shdr.sh_offset);
 629
 630                         sym.st_value -= shdr.sh_addr - shdr.sh_offset;
 631                 }
 632
 633                 if (mod) {
 634                         section = mod->sections->find_section(mod->sections, section_name);
 635                         if (section)
 636                                 sym.st_value += section->vma;
 637                         else {
 638                                 fprintf(stderr, "dso__load_sym() module %s lookup of %s failed\n",
 639                                         mod->name, section_name);
 640                                 goto out_elf_end;
 641                         }
 642                 }
 643                 /*
 644                  * We need to figure out if the object was created from C++ sources
 645                  * DWARF DW_compile_unit has this, but we don't always have access
 646                  * to it...
 647                  */
 648                 name = elf_sym__name(&sym, symstrs);
 649                 demangled = bfd_demangle(NULL, name, DMGL_PARAMS | DMGL_ANSI);
 650                 if (demangled != NULL)
 651                         name = demangled;
 652
 653                 f = symbol__new(sym.st_value, sym.st_size, name,
 654                                 self->sym_priv_size, obj_start, verbose);
 655                 free(demangled);
 656                 if (!f)
 657                         goto out_elf_end;
 658
 659                 if (filter && filter(self, f))
 660                         symbol__delete(f, self->sym_priv_size);
 661                 else {
 662                         f->module = mod;
 663                         dso__insert_symbol(self, f);
 664                         nr++;
 665                 }
 666         }
 667
 668         err = nr;
 669 out_elf_end:
 670         elf_end(elf);
 671 out_close:
 672         return err;
 673 }
 674
 675 #define BUILD_ID_SIZE 128
 676
 677 static char *dso__read_build_id(struct dso *self, int verbose)
 678 {
 679         int i;
 680         GElf_Ehdr ehdr;
 681         GElf_Shdr shdr;
 682         Elf_Data *build_id_data;
 683         Elf_Scn *sec;
 684         char *build_id = NULL, *bid;
 685         unsigned char *raw;
 686         Elf *elf;
 687         int fd = open(self->name, O_RDONLY);
 688
 689         if (fd < 0)
 690                 goto out;
 691
 692         elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
 693         if (elf == NULL) {
 694                 if (verbose)
 695                         fprintf(stderr, "%s: cannot read %s ELF file.\n",
 696                                 __func__, self->name);
 697                 goto out_close;
 698         }
 699
 700         if (gelf_getehdr(elf, &ehdr) == NULL) {
 701                 if (verbose)
 702                         fprintf(stderr, "%s: cannot get elf header.\n", __func__);
 703                 goto out_elf_end;
 704         }
 705
 706         sec = elf_section_by_name(elf, &ehdr, &shdr, ".note.gnu.build-id", NULL);
 707         if (sec == NULL)
 708                 goto out_elf_end;
 709
 710         build_id_data = elf_getdata(sec, NULL);
 711         if (build_id_data == NULL)
 712                 goto out_elf_end;
 713         build_id = malloc(BUILD_ID_SIZE);
 714         if (build_id == NULL)
 715                 goto out_elf_end;
 716         raw = build_id_data->d_buf + 16;
 717         bid = build_id;
 718
 719         for (i = 0; i < 20; ++i) {
 720                 sprintf(bid, "%02x", *raw);
 721                 ++raw;
 722                 bid += 2;
 723         }
 724         if (verbose >= 2)
 725                 printf("%s(%s): %s\n", __func__, self->name, build_id);
 726 out_elf_end:
 727         elf_end(elf);
 728 out_close:
 729         close(fd);
 730 out:
 731         return build_id;
 732 }
 733
 734 char dso__symtab_origin(const struct dso *self)
 735 {
 736         static const char origin[] = {
 737                 [DSO__ORIG_KERNEL] =   'k',
 738                 [DSO__ORIG_JAVA_JIT] = 'j',
 739                 [DSO__ORIG_FEDORA] =   'f',
 740                 [DSO__ORIG_UBUNTU] =   'u',
 741                 [DSO__ORIG_BUILDID] =  'b',
 742                 [DSO__ORIG_DSO] =      'd',
 743         };
 744
 745         if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
 746                 return '!';
 747         return origin[self->origin];
 748 }
 749
 750 int dso__load(struct dso *self, symbol_filter_t filter, int verbose)
 751 {
 752         int size = PATH_MAX;
 753         char *name = malloc(size), *build_id = NULL;
 754         int ret = -1;
 755         int fd;
 756
 757         if (!name)
 758                 return -1;
 759
 760         self->adjust_symbols = 0;
 761
 762         if (strncmp(self->name, "/tmp/perf-", 10) == 0) {
 763                 ret = dso__load_perf_map(self, filter, verbose);
 764                 self->origin = ret > 0 ? DSO__ORIG_JAVA_JIT :
 765                                          DSO__ORIG_NOT_FOUND;
 766                 return ret;
 767         }
 768
 769         self->origin = DSO__ORIG_FEDORA - 1;
 770
 771 more:
 772         do {
 773                 self->origin++;
 774                 switch (self->origin) {
 775                 case DSO__ORIG_FEDORA:
 776                         snprintf(name, size, "/usr/lib/debug%s.debug", self->name);
 777                         break;
 778                 case DSO__ORIG_UBUNTU:
 779                         snprintf(name, size, "/usr/lib/debug%s", self->name);
 780                         break;
 781                 case DSO__ORIG_BUILDID:
 782                         build_id = dso__read_build_id(self, verbose);
 783                         if (build_id != NULL) {
 784                                 snprintf(name, size,
 785                                          "/usr/lib/debug/.build-id/%.2s/%s.debug",
 786                                         build_id, build_id + 2);
 787                                 free(build_id);
 788                                 break;
 789                         }
 790                         self->origin++;
 791                         /* Fall thru */
 792                 case DSO__ORIG_DSO:
 793                         snprintf(name, size, "%s", self->name);
 794                         break;
 795
 796                 default:
 797                         goto out;
 798                 }
 799
 800                 fd = open(name, O_RDONLY);
 801         } while (fd < 0);
 802
 803         ret = dso__load_sym(self, fd, name, filter, verbose, NULL);
 804         close(fd);
 805
 806         /*
 807          * Some people seem to have debuginfo files _WITHOUT_ debug info!?!?
 808          */
 809         if (!ret)
 810                 goto more;
 811
 812         if (ret > 0) {
 813                 int nr_plt = dso__synthesize_plt_symbols(self, verbose);
 814                 if (nr_plt > 0)
 815                         ret += nr_plt;
 816         }
 817 out:
 818         free(name);
 819         return ret;
 820 }
 821
 822 static int dso__load_module(struct dso *self, struct mod_dso *mods, const char *name,
 823                              symbol_filter_t filter, int verbose)
 824 {
 825         struct module *mod = mod_dso__find_module(mods, name);
 826         int err = 0, fd;
 827
 828         if (mod == NULL || !mod->active)
 829                 return err;
 830
 831         fd = open(mod->path, O_RDONLY);
 832
 833         if (fd < 0)
 834                 return err;
 835
 836         err = dso__load_sym(self, fd, name, filter, verbose, mod);
 837         close(fd);
 838
 839         return err;
 840 }
 841
 842 int dso__load_modules(struct dso *self, symbol_filter_t filter, int verbose)
 843 {
 844         struct mod_dso *mods = mod_dso__new_dso("modules");
 845         struct module *pos;
 846         struct rb_node *next;
 847         int err;
 848
 849         err = mod_dso__load_modules(mods);
 850
 851         if (err <= 0)
 852                 return err;
 853
 854         /*
 855          * Iterate over modules, and load active symbols.
 856          */
 857         next = rb_first(&mods->mods);
 858         while (next) {
 859                 pos = rb_entry(next, struct module, rb_node);
 860                 err = dso__load_module(self, mods, pos->name, filter, verbose);
 861
 862                 if (err < 0)
 863                         break;
 864
 865                 next = rb_next(&pos->rb_node);
 866         }
 867
 868         if (err < 0) {
 869                 mod_dso__delete_modules(mods);
 870                 mod_dso__delete_self(mods);
 871         }
 872
 873         return err;
 874 }
 875
 876 static inline void dso__fill_symbol_holes(struct dso *self)
 877 {
 878         struct symbol *prev = NULL;
 879         struct rb_node *nd;
 880
 881         for (nd = rb_last(&self->syms); nd; nd = rb_prev(nd)) {
 882                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 883
 884                 if (prev) {
 885                         u64 hole = 0;
 886                         int alias = pos->start == prev->start;
 887
 888                         if (!alias)
 889                                 hole = prev->start - pos->end - 1;
 890
 891                         if (hole || alias) {
 892                                 if (alias)
 893                                         pos->end = prev->end;
 894                                 else if (hole)
 895                                         pos->end = prev->start - 1;
 896                         }
 897                 }
 898                 prev = pos;
 899         }
 900 }
 901
 902 static int dso__load_vmlinux(struct dso *self, const char *vmlinux,
 903                              symbol_filter_t filter, int verbose)
 904 {
 905         int err, fd = open(vmlinux, O_RDONLY);
 906
 907         if (fd < 0)
 908                 return -1;
 909
 910         err = dso__load_sym(self, fd, vmlinux, filter, verbose, NULL);
 911
 912         if (err > 0)
 913                 dso__fill_symbol_holes(self);
 914
 915         close(fd);
 916
 917         return err;
 918 }
 919
 920 int dso__load_kernel(struct dso *self, const char *vmlinux,
 921                      symbol_filter_t filter, int verbose, int modules)
 922 {
 923         int err = -1;
 924
 925         if (vmlinux) {
 926                 err = dso__load_vmlinux(self, vmlinux, filter, verbose);
 927                 if (err > 0 && modules)
 928                         err = dso__load_modules(self, filter, verbose);
 929         }
 930
 931         if (err <= 0)
 932                 err = dso__load_kallsyms(self, filter, verbose);
 933
 934         if (err > 0)
 935                 self->origin = DSO__ORIG_KERNEL;
 936
 937         return err;
 938 }
 939
 940 void symbol__init(void)
 941 {
 942         elf_version(EV_CURRENT);
 943 }