objcommon.c

   1 /*  Copyright (C) 2007-2009  Ksplice, Inc.
   2  *  Authors: Jeff Arnold, Anders Kaseorg, Tim Abbott
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License, version 2.
   6  *
   7  *  This program is distributed in the hope that it will be useful,
   8  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *  GNU General Public License for more details.
  11  *
  12  *  You should have received a copy of the GNU General Public License
  13  *  along with this program; if not, write to the Free Software
  14  *  Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  15  *  02110-1301, USA.
  16  */
  17
  18 #define _GNU_SOURCE
  19 #include "objcommon.h"
  20 #include <stdio.h>
  21
  22 #define arelentp_init(x) *(x) = NULL
  23 IMPLEMENT_HASH_TYPE(arelent *, arelentp_hash, arelentp_hash_init,
  24                     arelentp_hash_free, arelentp_hash_lookup, arelentp_init);
  25
  26 #define label_mapp_init(map) *(map) = NULL
  27 IMPLEMENT_HASH_TYPE(struct label_map *, label_mapp_hash, label_mapp_hash_init,
  28                     label_mapp_hash_free, label_mapp_hash_lookup,
  29                     label_mapp_init);
  30
  31 #define asymbolpp_init(symp) *(symp) = NULL
  32 IMPLEMENT_HASH_TYPE(asymbol **, asymbolpp_hash, asymbolpp_hash_init,
  33                     asymbolpp_hash_free, asymbolpp_hash_lookup, asymbolpp_init);
  34
  35 #define string_init(str) *(str) = NULL
  36 IMPLEMENT_HASH_TYPE(const char *, string_hash, string_hash_init,
  37                     string_hash_free, string_hash_lookup, string_init);
  38
  39 void vec_do_reserve(void **data, size_t *mem_size, size_t new_size)
  40 {
  41         if (new_size > *mem_size || new_size * 2 < *mem_size) {
  42                 if (new_size < *mem_size * 2)
  43                         new_size = *mem_size * 2;
  44                 *data = realloc(*data, new_size);
  45                 assert(new_size == 0 || *data != NULL);
  46                 *mem_size = new_size;
  47         }
  48 }
  49
  50 void get_syms(bfd *abfd, struct asymbolp_vec *syms)
  51 {
  52         long storage_needed = bfd_get_symtab_upper_bound(abfd);
  53         if (storage_needed == 0)
  54                 return;
  55         assert(storage_needed >= 0);
  56
  57         vec_init(syms);
  58         vec_reserve(syms, storage_needed);
  59         vec_resize(syms, bfd_canonicalize_symtab(abfd, syms->data));
  60         assert(syms->size >= 0);
  61 }
  62
  63 struct superbfd *fetch_superbfd(bfd *abfd)
  64 {
  65         assert(abfd != NULL);
  66         if (abfd->usrdata != NULL)
  67                 return abfd->usrdata;
  68
  69         struct superbfd *sbfd = malloc(sizeof(*sbfd));
  70         assert(sbfd != NULL);
  71
  72         abfd->usrdata = sbfd;
  73         sbfd->abfd = abfd;
  74         get_syms(abfd, &sbfd->syms);
  75         vec_init(&sbfd->new_syms);
  76         sbfd->new_supersects = NULL;
  77         return sbfd;
  78 }
  79
  80 struct supersect *fetch_supersect(struct superbfd *sbfd, asection *sect)
  81 {
  82         assert(sect != NULL);
  83         assert(!bfd_is_const_section(sect));
  84         if (sect->userdata != NULL)
  85                 return sect->userdata;
  86
  87         struct supersect *new = malloc(sizeof(*new));
  88         assert(new != NULL);
  89
  90         sect->userdata = new;
  91         new->parent = sbfd;
  92         new->name = sect->name;
  93         new->flags = bfd_get_section_flags(sbfd->abfd, sect);
  94         new->keep = true;
  95         new->symbol = sect->symbol;
  96
  97         vec_init(&new->contents);
  98         vec_resize(&new->contents, bfd_get_section_size(sect));
  99         assert(bfd_get_section_contents
 100                (sbfd->abfd, sect, new->contents.data, 0, new->contents.size));
 101         new->alignment = bfd_get_section_alignment(sbfd->abfd, sect);
 102         new->entsize = sect->entsize;
 103
 104         vec_init(&new->relocs);
 105         vec_reserve(&new->relocs, bfd_get_reloc_upper_bound(sbfd->abfd, sect));
 106         vec_resize(&new->relocs,
 107                    bfd_canonicalize_reloc(sbfd->abfd, sect, new->relocs.data,
 108                                           sbfd->syms.data));
 109         assert(new->relocs.size >= 0);
 110         vec_init(&new->new_relocs);
 111
 112         vec_init(&new->syms);
 113         asymbol **symp;
 114         for (symp = sbfd->syms.data; symp < sbfd->syms.data + sbfd->syms.size;
 115              symp++) {
 116                 asymbol *sym = *symp;
 117                 if (sym->section == sect && (sym->flags & BSF_SECTION_SYM) == 0)
 118                         *vec_grow(&new->syms, 1) = sym;
 119         }
 120
 121         vec_init(&new->spans);
 122
 123         arelentp_hash_init(&new->reloc_hash);
 124         arelent **relocp;
 125         for (relocp = new->relocs.data;
 126              relocp < new->relocs.data + new->relocs.size; relocp++) {
 127                 arelent *reloc = *relocp;
 128                 char *key = strprintf("%lx", (unsigned long)reloc->address);
 129                 arelent **hash_relocp = arelentp_hash_lookup(&new->reloc_hash,
 130                                                              key, TRUE);
 131                 free(key);
 132                 *hash_relocp = reloc;
 133         }
 134
 135         return new;
 136 }
 137
 138 struct supersect *new_supersect(struct superbfd *sbfd, const char *name)
 139 {
 140         struct supersect *ss;
 141         for (ss = sbfd->new_supersects; ss != NULL; ss = ss->next) {
 142                 if (strcmp(name, ss->name) == 0)
 143                         return ss;
 144         }
 145
 146         struct supersect *new = malloc(sizeof(*new));
 147         new->parent = sbfd;
 148         new->name = name;
 149         new->next = sbfd->new_supersects;
 150         sbfd->new_supersects = new;
 151         new->flags = SEC_ALLOC | SEC_HAS_CONTENTS | SEC_RELOC;
 152         new->keep = true;
 153
 154         vec_init(&new->contents);
 155         new->alignment = 0;
 156         new->entsize = 0;
 157         vec_init(&new->relocs);
 158         vec_init(&new->new_relocs);
 159
 160         new->type = SS_TYPE_KSPLICE;
 161         return new;
 162 }
 163
 164 void supersect_move(struct supersect *dest_ss, struct supersect *src_ss)
 165 {
 166         *dest_ss = *src_ss;
 167         vec_init(&src_ss->contents);
 168         vec_init(&src_ss->relocs);
 169         vec_init(&src_ss->new_relocs);
 170         vec_init(&src_ss->syms);
 171 }
 172
 173 void *sect_do_grow(struct supersect *ss, size_t n, size_t size, int alignment)
 174 {
 175         if (ss->alignment < ffs(alignment) - 1)
 176                 ss->alignment = ffs(alignment) - 1;
 177         int pad = align(ss->contents.size, alignment) - ss->contents.size;
 178         void *out = vec_grow(&ss->contents, pad + n * size);
 179         memset(out, 0, pad + n * size);
 180         return out + pad;
 181 }
 182
 183 static void mod_relocs(struct arelentp_vec *dest_relocs,
 184                        struct arelentp_vec *src_relocs,
 185                        bfd_size_type start, bfd_size_type end,
 186                        bfd_size_type mod)
 187 {
 188         arelent **relocp;
 189         for (relocp = src_relocs->data;
 190              relocp < src_relocs->data + src_relocs->size; relocp++) {
 191                 if ((*relocp)->address >= start && (*relocp)->address < end) {
 192                         arelent *reloc = malloc(sizeof(*reloc));
 193                         assert(reloc != NULL);
 194                         *reloc = **relocp;
 195                         reloc->address += mod;
 196                         *vec_grow(dest_relocs, 1) = reloc;
 197                 }
 198         }
 199 }
 200
 201 static void mod_symbols(struct asymbolp_vec *dest_syms,
 202                         struct asymbolp_vec *src_syms,
 203                         bfd_size_type start, bfd_size_type end,
 204                         bfd_size_type mod)
 205 {
 206         asymbol **symp;
 207         for (symp = src_syms->data;
 208              symp < src_syms->data + src_syms->size; symp++) {
 209                 /* must mutate symbols in-place since there are pointers
 210                    to them in relocations elsewhere */
 211                 asymbol *sym = *symp;
 212                 if (sym->value >= start && sym->value < end) {
 213                         sym->value += mod;
 214                         *vec_grow(dest_syms, 1) = sym;
 215                 }
 216         }
 217 }
 218
 219 void sect_do_copy(struct supersect *dest_ss, void *dest,
 220                   struct supersect *src_ss, const void *src, size_t n)
 221 {
 222         memcpy(dest, src, n);
 223         bfd_size_type start = addr_offset(src_ss, src);
 224         bfd_size_type end = start + n;
 225         bfd_size_type mod = addr_offset(dest_ss, dest) - start;
 226         mod_relocs(&dest_ss->relocs, &src_ss->relocs, start, end, mod);
 227         mod_relocs(&dest_ss->new_relocs, &src_ss->new_relocs, start, end, mod);
 228         mod_symbols(&dest_ss->syms, &src_ss->syms, start, end, mod);
 229 }
 230
 231 bfd_vma addr_offset(struct supersect *ss, const void *addr)
 232 {
 233         return (void *)addr - ss->contents.data;
 234 }
 235
 236 bfd_vma reloc_offset(struct supersect *ss, arelent *reloc)
 237 {
 238         int size = bfd_get_reloc_size(reloc->howto);
 239
 240         bfd_vma x = bfd_get(size * 8, ss->parent->abfd,
 241                             ss->contents.data + reloc->address);
 242         x &= reloc->howto->src_mask;
 243         x >>= reloc->howto->bitpos;
 244         bfd_vma signbit = reloc->howto->dst_mask >> reloc->howto->bitpos;
 245         signbit &= ~(signbit >> 1);
 246         switch (reloc->howto->complain_on_overflow) {
 247         case complain_overflow_signed:
 248         case complain_overflow_bitfield:
 249                 x |= -(x & signbit);
 250                 break;
 251         case complain_overflow_unsigned:
 252                 break;
 253         default:
 254                 DIE;
 255         }
 256         x <<= reloc->howto->rightshift;
 257
 258         bfd_vma add = reloc->addend;
 259         if (reloc->howto->pc_relative) {
 260                 if (!reloc->howto->pcrel_offset)
 261                         add += reloc->address;
 262         }
 263         return x + add;
 264 }
 265
 266 arelent *find_reloc(struct supersect *ss, const void *addr)
 267 {
 268         bfd_vma address = addr_offset(ss, addr);
 269         char *key = strprintf("%lx", (unsigned long)address);
 270         arelent **relocp = arelentp_hash_lookup(&ss->reloc_hash, key, FALSE);
 271         free(key);
 272         return relocp != NULL ? *relocp : NULL;
 273 }
 274
 275 bfd_vma read_reloc(struct supersect *ss, const void *addr, size_t size,
 276                    asymbol **symp)
 277 {
 278         bfd_vma val = bfd_get(size * 8, ss->parent->abfd, addr);
 279         arelent *reloc = find_reloc(ss, addr);
 280         if (reloc == NULL) {
 281                 if (symp != NULL)
 282                         *symp = *bfd_abs_section_ptr->symbol_ptr_ptr;
 283                 return val;
 284         }
 285
 286         if (symp != NULL)
 287                 *symp = *reloc->sym_ptr_ptr;
 288         else if (*reloc->sym_ptr_ptr != bfd_abs_section_ptr->symbol)
 289                 fprintf(stderr, "warning: unexpected "
 290                         "non-absolute relocation at %s+%lx\n",
 291                         ss->name, (unsigned long)addr_offset(ss, addr));
 292         return reloc_offset(ss, reloc);
 293 }
 294
 295 const void *read_pointer(struct supersect *ss, void *const *addr,
 296                          struct supersect **data_ssp)
 297 {
 298         asymbol *sym;
 299         bfd_vma offset = read_reloc(ss, addr, sizeof(*addr), &sym);
 300         if (bfd_is_abs_section(sym->section) && sym->value + offset == 0)
 301                 return NULL;
 302         if (bfd_is_const_section(sym->section)) {
 303                 fprintf(stderr, "warning: unexpected relocation to const "
 304                         "section at %s+%lx\n", ss->name,
 305                         (unsigned long)addr_offset(ss, addr));
 306                 return NULL;
 307         }
 308         struct supersect *data_ss = fetch_supersect(ss->parent, sym->section);
 309         if (data_ssp != NULL)
 310                 *data_ssp = data_ss;
 311         return data_ss->contents.data + sym->value + offset;
 312 }
 313
 314 const char *read_string(struct supersect *ss, const char *const *addr)
 315 {
 316         return read_pointer(ss, (void *const *)addr, NULL);
 317 }