objtool: Fix segfault in .cold detection with -ffunction-sections
[sfrench/cifs-2.6.git] / tools / objtool / elf.c
1 /*
2  * elf.c - ELF access library
3  *
4  * Adapted from kpatch (https://github.com/dynup/kpatch):
5  * Copyright (C) 2013-2015 Josh Poimboeuf <jpoimboe@redhat.com>
6  * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <sys/types.h>
23 #include <sys/stat.h>
24 #include <fcntl.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <errno.h>
30
31 #include "elf.h"
32 #include "warn.h"
33
34 #define MAX_NAME_LEN 128
35
36 struct section *find_section_by_name(struct elf *elf, const char *name)
37 {
38         struct section *sec;
39
40         list_for_each_entry(sec, &elf->sections, list)
41                 if (!strcmp(sec->name, name))
42                         return sec;
43
44         return NULL;
45 }
46
47 static struct section *find_section_by_index(struct elf *elf,
48                                              unsigned int idx)
49 {
50         struct section *sec;
51
52         list_for_each_entry(sec, &elf->sections, list)
53                 if (sec->idx == idx)
54                         return sec;
55
56         return NULL;
57 }
58
59 static struct symbol *find_symbol_by_index(struct elf *elf, unsigned int idx)
60 {
61         struct section *sec;
62         struct symbol *sym;
63
64         list_for_each_entry(sec, &elf->sections, list)
65                 hash_for_each_possible(sec->symbol_hash, sym, hash, idx)
66                         if (sym->idx == idx)
67                                 return sym;
68
69         return NULL;
70 }
71
72 struct symbol *find_symbol_by_offset(struct section *sec, unsigned long offset)
73 {
74         struct symbol *sym;
75
76         list_for_each_entry(sym, &sec->symbol_list, list)
77                 if (sym->type != STT_SECTION &&
78                     sym->offset == offset)
79                         return sym;
80
81         return NULL;
82 }
83
84 struct symbol *find_symbol_by_name(struct elf *elf, const char *name)
85 {
86         struct section *sec;
87         struct symbol *sym;
88
89         list_for_each_entry(sec, &elf->sections, list)
90                 list_for_each_entry(sym, &sec->symbol_list, list)
91                         if (!strcmp(sym->name, name))
92                                 return sym;
93
94         return NULL;
95 }
96
97 struct symbol *find_symbol_containing(struct section *sec, unsigned long offset)
98 {
99         struct symbol *sym;
100
101         list_for_each_entry(sym, &sec->symbol_list, list)
102                 if (sym->type != STT_SECTION &&
103                     offset >= sym->offset && offset < sym->offset + sym->len)
104                         return sym;
105
106         return NULL;
107 }
108
109 struct rela *find_rela_by_dest_range(struct section *sec, unsigned long offset,
110                                      unsigned int len)
111 {
112         struct rela *rela;
113         unsigned long o;
114
115         if (!sec->rela)
116                 return NULL;
117
118         for (o = offset; o < offset + len; o++)
119                 hash_for_each_possible(sec->rela->rela_hash, rela, hash, o)
120                         if (rela->offset == o)
121                                 return rela;
122
123         return NULL;
124 }
125
126 struct rela *find_rela_by_dest(struct section *sec, unsigned long offset)
127 {
128         return find_rela_by_dest_range(sec, offset, 1);
129 }
130
131 struct symbol *find_containing_func(struct section *sec, unsigned long offset)
132 {
133         struct symbol *func;
134
135         list_for_each_entry(func, &sec->symbol_list, list)
136                 if (func->type == STT_FUNC && offset >= func->offset &&
137                     offset < func->offset + func->len)
138                         return func;
139
140         return NULL;
141 }
142
143 static int read_sections(struct elf *elf)
144 {
145         Elf_Scn *s = NULL;
146         struct section *sec;
147         size_t shstrndx, sections_nr;
148         int i;
149
150         if (elf_getshdrnum(elf->elf, &sections_nr)) {
151                 WARN_ELF("elf_getshdrnum");
152                 return -1;
153         }
154
155         if (elf_getshdrstrndx(elf->elf, &shstrndx)) {
156                 WARN_ELF("elf_getshdrstrndx");
157                 return -1;
158         }
159
160         for (i = 0; i < sections_nr; i++) {
161                 sec = malloc(sizeof(*sec));
162                 if (!sec) {
163                         perror("malloc");
164                         return -1;
165                 }
166                 memset(sec, 0, sizeof(*sec));
167
168                 INIT_LIST_HEAD(&sec->symbol_list);
169                 INIT_LIST_HEAD(&sec->rela_list);
170                 hash_init(sec->rela_hash);
171                 hash_init(sec->symbol_hash);
172
173                 list_add_tail(&sec->list, &elf->sections);
174
175                 s = elf_getscn(elf->elf, i);
176                 if (!s) {
177                         WARN_ELF("elf_getscn");
178                         return -1;
179                 }
180
181                 sec->idx = elf_ndxscn(s);
182
183                 if (!gelf_getshdr(s, &sec->sh)) {
184                         WARN_ELF("gelf_getshdr");
185                         return -1;
186                 }
187
188                 sec->name = elf_strptr(elf->elf, shstrndx, sec->sh.sh_name);
189                 if (!sec->name) {
190                         WARN_ELF("elf_strptr");
191                         return -1;
192                 }
193
194                 if (sec->sh.sh_size != 0) {
195                         sec->data = elf_getdata(s, NULL);
196                         if (!sec->data) {
197                                 WARN_ELF("elf_getdata");
198                                 return -1;
199                         }
200                         if (sec->data->d_off != 0 ||
201                             sec->data->d_size != sec->sh.sh_size) {
202                                 WARN("unexpected data attributes for %s",
203                                      sec->name);
204                                 return -1;
205                         }
206                 }
207                 sec->len = sec->sh.sh_size;
208         }
209
210         /* sanity check, one more call to elf_nextscn() should return NULL */
211         if (elf_nextscn(elf->elf, s)) {
212                 WARN("section entry mismatch");
213                 return -1;
214         }
215
216         return 0;
217 }
218
219 static int read_symbols(struct elf *elf)
220 {
221         struct section *symtab, *sec;
222         struct symbol *sym, *pfunc;
223         struct list_head *entry, *tmp;
224         int symbols_nr, i;
225         char *coldstr;
226
227         symtab = find_section_by_name(elf, ".symtab");
228         if (!symtab) {
229                 WARN("missing symbol table");
230                 return -1;
231         }
232
233         symbols_nr = symtab->sh.sh_size / symtab->sh.sh_entsize;
234
235         for (i = 0; i < symbols_nr; i++) {
236                 sym = malloc(sizeof(*sym));
237                 if (!sym) {
238                         perror("malloc");
239                         return -1;
240                 }
241                 memset(sym, 0, sizeof(*sym));
242
243                 sym->idx = i;
244
245                 if (!gelf_getsym(symtab->data, i, &sym->sym)) {
246                         WARN_ELF("gelf_getsym");
247                         goto err;
248                 }
249
250                 sym->name = elf_strptr(elf->elf, symtab->sh.sh_link,
251                                        sym->sym.st_name);
252                 if (!sym->name) {
253                         WARN_ELF("elf_strptr");
254                         goto err;
255                 }
256
257                 sym->type = GELF_ST_TYPE(sym->sym.st_info);
258                 sym->bind = GELF_ST_BIND(sym->sym.st_info);
259
260                 if (sym->sym.st_shndx > SHN_UNDEF &&
261                     sym->sym.st_shndx < SHN_LORESERVE) {
262                         sym->sec = find_section_by_index(elf,
263                                                          sym->sym.st_shndx);
264                         if (!sym->sec) {
265                                 WARN("couldn't find section for symbol %s",
266                                      sym->name);
267                                 goto err;
268                         }
269                         if (sym->type == STT_SECTION) {
270                                 sym->name = sym->sec->name;
271                                 sym->sec->sym = sym;
272                         }
273                 } else
274                         sym->sec = find_section_by_index(elf, 0);
275
276                 sym->offset = sym->sym.st_value;
277                 sym->len = sym->sym.st_size;
278
279                 /* sorted insert into a per-section list */
280                 entry = &sym->sec->symbol_list;
281                 list_for_each_prev(tmp, &sym->sec->symbol_list) {
282                         struct symbol *s;
283
284                         s = list_entry(tmp, struct symbol, list);
285
286                         if (sym->offset > s->offset) {
287                                 entry = tmp;
288                                 break;
289                         }
290
291                         if (sym->offset == s->offset && sym->len >= s->len) {
292                                 entry = tmp;
293                                 break;
294                         }
295                 }
296                 list_add(&sym->list, entry);
297                 hash_add(sym->sec->symbol_hash, &sym->hash, sym->idx);
298         }
299
300         /* Create parent/child links for any cold subfunctions */
301         list_for_each_entry(sec, &elf->sections, list) {
302                 list_for_each_entry(sym, &sec->symbol_list, list) {
303                         char pname[MAX_NAME_LEN + 1];
304                         size_t pnamelen;
305                         if (sym->type != STT_FUNC)
306                                 continue;
307                         sym->pfunc = sym->cfunc = sym;
308                         coldstr = strstr(sym->name, ".cold");
309                         if (!coldstr)
310                                 continue;
311
312                         pnamelen = coldstr - sym->name;
313                         if (pnamelen > MAX_NAME_LEN) {
314                                 WARN("%s(): parent function name exceeds maximum length of %d characters",
315                                      sym->name, MAX_NAME_LEN);
316                                 return -1;
317                         }
318
319                         strncpy(pname, sym->name, pnamelen);
320                         pname[pnamelen] = '\0';
321                         pfunc = find_symbol_by_name(elf, pname);
322
323                         if (!pfunc) {
324                                 WARN("%s(): can't find parent function",
325                                      sym->name);
326                                 return -1;
327                         }
328
329                         sym->pfunc = pfunc;
330                         pfunc->cfunc = sym;
331
332                         /*
333                          * Unfortunately, -fnoreorder-functions puts the child
334                          * inside the parent.  Remove the overlap so we can
335                          * have sane assumptions.
336                          *
337                          * Note that pfunc->len now no longer matches
338                          * pfunc->sym.st_size.
339                          */
340                         if (sym->sec == pfunc->sec &&
341                             sym->offset >= pfunc->offset &&
342                             sym->offset + sym->len == pfunc->offset + pfunc->len) {
343                                 pfunc->len -= sym->len;
344                         }
345                 }
346         }
347
348         return 0;
349
350 err:
351         free(sym);
352         return -1;
353 }
354
355 static int read_relas(struct elf *elf)
356 {
357         struct section *sec;
358         struct rela *rela;
359         int i;
360         unsigned int symndx;
361
362         list_for_each_entry(sec, &elf->sections, list) {
363                 if (sec->sh.sh_type != SHT_RELA)
364                         continue;
365
366                 sec->base = find_section_by_name(elf, sec->name + 5);
367                 if (!sec->base) {
368                         WARN("can't find base section for rela section %s",
369                              sec->name);
370                         return -1;
371                 }
372
373                 sec->base->rela = sec;
374
375                 for (i = 0; i < sec->sh.sh_size / sec->sh.sh_entsize; i++) {
376                         rela = malloc(sizeof(*rela));
377                         if (!rela) {
378                                 perror("malloc");
379                                 return -1;
380                         }
381                         memset(rela, 0, sizeof(*rela));
382
383                         if (!gelf_getrela(sec->data, i, &rela->rela)) {
384                                 WARN_ELF("gelf_getrela");
385                                 return -1;
386                         }
387
388                         rela->type = GELF_R_TYPE(rela->rela.r_info);
389                         rela->addend = rela->rela.r_addend;
390                         rela->offset = rela->rela.r_offset;
391                         symndx = GELF_R_SYM(rela->rela.r_info);
392                         rela->sym = find_symbol_by_index(elf, symndx);
393                         rela->rela_sec = sec;
394                         if (!rela->sym) {
395                                 WARN("can't find rela entry symbol %d for %s",
396                                      symndx, sec->name);
397                                 return -1;
398                         }
399
400                         list_add_tail(&rela->list, &sec->rela_list);
401                         hash_add(sec->rela_hash, &rela->hash, rela->offset);
402
403                 }
404         }
405
406         return 0;
407 }
408
409 struct elf *elf_open(const char *name, int flags)
410 {
411         struct elf *elf;
412         Elf_Cmd cmd;
413
414         elf_version(EV_CURRENT);
415
416         elf = malloc(sizeof(*elf));
417         if (!elf) {
418                 perror("malloc");
419                 return NULL;
420         }
421         memset(elf, 0, sizeof(*elf));
422
423         INIT_LIST_HEAD(&elf->sections);
424
425         elf->fd = open(name, flags);
426         if (elf->fd == -1) {
427                 fprintf(stderr, "objtool: Can't open '%s': %s\n",
428                         name, strerror(errno));
429                 goto err;
430         }
431
432         if ((flags & O_ACCMODE) == O_RDONLY)
433                 cmd = ELF_C_READ_MMAP;
434         else if ((flags & O_ACCMODE) == O_RDWR)
435                 cmd = ELF_C_RDWR;
436         else /* O_WRONLY */
437                 cmd = ELF_C_WRITE;
438
439         elf->elf = elf_begin(elf->fd, cmd, NULL);
440         if (!elf->elf) {
441                 WARN_ELF("elf_begin");
442                 goto err;
443         }
444
445         if (!gelf_getehdr(elf->elf, &elf->ehdr)) {
446                 WARN_ELF("gelf_getehdr");
447                 goto err;
448         }
449
450         if (read_sections(elf))
451                 goto err;
452
453         if (read_symbols(elf))
454                 goto err;
455
456         if (read_relas(elf))
457                 goto err;
458
459         return elf;
460
461 err:
462         elf_close(elf);
463         return NULL;
464 }
465
466 struct section *elf_create_section(struct elf *elf, const char *name,
467                                    size_t entsize, int nr)
468 {
469         struct section *sec, *shstrtab;
470         size_t size = entsize * nr;
471         struct Elf_Scn *s;
472         Elf_Data *data;
473
474         sec = malloc(sizeof(*sec));
475         if (!sec) {
476                 perror("malloc");
477                 return NULL;
478         }
479         memset(sec, 0, sizeof(*sec));
480
481         INIT_LIST_HEAD(&sec->symbol_list);
482         INIT_LIST_HEAD(&sec->rela_list);
483         hash_init(sec->rela_hash);
484         hash_init(sec->symbol_hash);
485
486         list_add_tail(&sec->list, &elf->sections);
487
488         s = elf_newscn(elf->elf);
489         if (!s) {
490                 WARN_ELF("elf_newscn");
491                 return NULL;
492         }
493
494         sec->name = strdup(name);
495         if (!sec->name) {
496                 perror("strdup");
497                 return NULL;
498         }
499
500         sec->idx = elf_ndxscn(s);
501         sec->len = size;
502         sec->changed = true;
503
504         sec->data = elf_newdata(s);
505         if (!sec->data) {
506                 WARN_ELF("elf_newdata");
507                 return NULL;
508         }
509
510         sec->data->d_size = size;
511         sec->data->d_align = 1;
512
513         if (size) {
514                 sec->data->d_buf = malloc(size);
515                 if (!sec->data->d_buf) {
516                         perror("malloc");
517                         return NULL;
518                 }
519                 memset(sec->data->d_buf, 0, size);
520         }
521
522         if (!gelf_getshdr(s, &sec->sh)) {
523                 WARN_ELF("gelf_getshdr");
524                 return NULL;
525         }
526
527         sec->sh.sh_size = size;
528         sec->sh.sh_entsize = entsize;
529         sec->sh.sh_type = SHT_PROGBITS;
530         sec->sh.sh_addralign = 1;
531         sec->sh.sh_flags = SHF_ALLOC;
532
533
534         /* Add section name to .shstrtab (or .strtab for Clang) */
535         shstrtab = find_section_by_name(elf, ".shstrtab");
536         if (!shstrtab)
537                 shstrtab = find_section_by_name(elf, ".strtab");
538         if (!shstrtab) {
539                 WARN("can't find .shstrtab or .strtab section");
540                 return NULL;
541         }
542
543         s = elf_getscn(elf->elf, shstrtab->idx);
544         if (!s) {
545                 WARN_ELF("elf_getscn");
546                 return NULL;
547         }
548
549         data = elf_newdata(s);
550         if (!data) {
551                 WARN_ELF("elf_newdata");
552                 return NULL;
553         }
554
555         data->d_buf = sec->name;
556         data->d_size = strlen(name) + 1;
557         data->d_align = 1;
558
559         sec->sh.sh_name = shstrtab->len;
560
561         shstrtab->len += strlen(name) + 1;
562         shstrtab->changed = true;
563
564         return sec;
565 }
566
567 struct section *elf_create_rela_section(struct elf *elf, struct section *base)
568 {
569         char *relaname;
570         struct section *sec;
571
572         relaname = malloc(strlen(base->name) + strlen(".rela") + 1);
573         if (!relaname) {
574                 perror("malloc");
575                 return NULL;
576         }
577         strcpy(relaname, ".rela");
578         strcat(relaname, base->name);
579
580         sec = elf_create_section(elf, relaname, sizeof(GElf_Rela), 0);
581         free(relaname);
582         if (!sec)
583                 return NULL;
584
585         base->rela = sec;
586         sec->base = base;
587
588         sec->sh.sh_type = SHT_RELA;
589         sec->sh.sh_addralign = 8;
590         sec->sh.sh_link = find_section_by_name(elf, ".symtab")->idx;
591         sec->sh.sh_info = base->idx;
592         sec->sh.sh_flags = SHF_INFO_LINK;
593
594         return sec;
595 }
596
597 int elf_rebuild_rela_section(struct section *sec)
598 {
599         struct rela *rela;
600         int nr, idx = 0, size;
601         GElf_Rela *relas;
602
603         nr = 0;
604         list_for_each_entry(rela, &sec->rela_list, list)
605                 nr++;
606
607         size = nr * sizeof(*relas);
608         relas = malloc(size);
609         if (!relas) {
610                 perror("malloc");
611                 return -1;
612         }
613
614         sec->data->d_buf = relas;
615         sec->data->d_size = size;
616
617         sec->sh.sh_size = size;
618
619         idx = 0;
620         list_for_each_entry(rela, &sec->rela_list, list) {
621                 relas[idx].r_offset = rela->offset;
622                 relas[idx].r_addend = rela->addend;
623                 relas[idx].r_info = GELF_R_INFO(rela->sym->idx, rela->type);
624                 idx++;
625         }
626
627         return 0;
628 }
629
630 int elf_write(struct elf *elf)
631 {
632         struct section *sec;
633         Elf_Scn *s;
634
635         /* Update section headers for changed sections: */
636         list_for_each_entry(sec, &elf->sections, list) {
637                 if (sec->changed) {
638                         s = elf_getscn(elf->elf, sec->idx);
639                         if (!s) {
640                                 WARN_ELF("elf_getscn");
641                                 return -1;
642                         }
643                         if (!gelf_update_shdr(s, &sec->sh)) {
644                                 WARN_ELF("gelf_update_shdr");
645                                 return -1;
646                         }
647                 }
648         }
649
650         /* Make sure the new section header entries get updated properly. */
651         elf_flagelf(elf->elf, ELF_C_SET, ELF_F_DIRTY);
652
653         /* Write all changes to the file. */
654         if (elf_update(elf->elf, ELF_C_WRITE) < 0) {
655                 WARN_ELF("elf_update");
656                 return -1;
657         }
658
659         return 0;
660 }
661
662 void elf_close(struct elf *elf)
663 {
664         struct section *sec, *tmpsec;
665         struct symbol *sym, *tmpsym;
666         struct rela *rela, *tmprela;
667
668         if (elf->elf)
669                 elf_end(elf->elf);
670
671         if (elf->fd > 0)
672                 close(elf->fd);
673
674         list_for_each_entry_safe(sec, tmpsec, &elf->sections, list) {
675                 list_for_each_entry_safe(sym, tmpsym, &sec->symbol_list, list) {
676                         list_del(&sym->list);
677                         hash_del(&sym->hash);
678                         free(sym);
679                 }
680                 list_for_each_entry_safe(rela, tmprela, &sec->rela_list, list) {
681                         list_del(&rela->list);
682                         hash_del(&rela->hash);
683                         free(rela);
684                 }
685                 list_del(&sec->list);
686                 free(sec);
687         }
688
689         free(elf);
690 }