arch/s390/tools/relocs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #include <stdio.h>
   4 #include <stdarg.h>
   5 #include <stdlib.h>
   6 #include <stdint.h>
   7 #include <inttypes.h>
   8 #include <string.h>
   9 #include <errno.h>
  10 #include <unistd.h>
  11 #include <elf.h>
  12 #include <byteswap.h>
  13 #define USE_BSD
  14 #include <endian.h>
  15
  16 #define ELF_BITS 64
  17
  18 #define ELF_MACHINE             EM_S390
  19 #define ELF_MACHINE_NAME        "IBM S/390"
  20 #define SHT_REL_TYPE            SHT_RELA
  21 #define Elf_Rel                 Elf64_Rela
  22
  23 #define ELF_CLASS               ELFCLASS64
  24 #define ELF_ENDIAN              ELFDATA2MSB
  25 #define ELF_R_SYM(val)          ELF64_R_SYM(val)
  26 #define ELF_R_TYPE(val)         ELF64_R_TYPE(val)
  27 #define ELF_ST_TYPE(o)          ELF64_ST_TYPE(o)
  28 #define ELF_ST_BIND(o)          ELF64_ST_BIND(o)
  29 #define ELF_ST_VISIBILITY(o)    ELF64_ST_VISIBILITY(o)
  30
  31 #define ElfW(type)              _ElfW(ELF_BITS, type)
  32 #define _ElfW(bits, type)       __ElfW(bits, type)
  33 #define __ElfW(bits, type)      Elf##bits##_##type
  34
  35 #define Elf_Addr                ElfW(Addr)
  36 #define Elf_Ehdr                ElfW(Ehdr)
  37 #define Elf_Phdr                ElfW(Phdr)
  38 #define Elf_Shdr                ElfW(Shdr)
  39 #define Elf_Sym                 ElfW(Sym)
  40
  41 static Elf_Ehdr         ehdr;
  42 static unsigned long    shnum;
  43 static unsigned int     shstrndx;
  44
  45 struct relocs {
  46         uint32_t        *offset;
  47         unsigned long   count;
  48         unsigned long   size;
  49 };
  50
  51 static struct relocs relocs64;
  52 #define FMT PRIu64
  53
  54 struct section {
  55         Elf_Shdr        shdr;
  56         struct section  *link;
  57         Elf_Rel         *reltab;
  58 };
  59
  60 static struct section *secs;
  61
  62 #if BYTE_ORDER == LITTLE_ENDIAN
  63 #define le16_to_cpu(val)        (val)
  64 #define le32_to_cpu(val)        (val)
  65 #define le64_to_cpu(val)        (val)
  66 #define be16_to_cpu(val)        bswap_16(val)
  67 #define be32_to_cpu(val)        bswap_32(val)
  68 #define be64_to_cpu(val)        bswap_64(val)
  69 #endif
  70
  71 #if BYTE_ORDER == BIG_ENDIAN
  72 #define le16_to_cpu(val)        bswap_16(val)
  73 #define le32_to_cpu(val)        bswap_32(val)
  74 #define le64_to_cpu(val)        bswap_64(val)
  75 #define be16_to_cpu(val)        (val)
  76 #define be32_to_cpu(val)        (val)
  77 #define be64_to_cpu(val)        (val)
  78 #endif
  79
  80 static uint16_t elf16_to_cpu(uint16_t val)
  81 {
  82         if (ehdr.e_ident[EI_DATA] == ELFDATA2LSB)
  83                 return le16_to_cpu(val);
  84         else
  85                 return be16_to_cpu(val);
  86 }
  87
  88 static uint32_t elf32_to_cpu(uint32_t val)
  89 {
  90         if (ehdr.e_ident[EI_DATA] == ELFDATA2LSB)
  91                 return le32_to_cpu(val);
  92         else
  93                 return be32_to_cpu(val);
  94 }
  95
  96 #define elf_half_to_cpu(x)      elf16_to_cpu(x)
  97 #define elf_word_to_cpu(x)      elf32_to_cpu(x)
  98
  99 static uint64_t elf64_to_cpu(uint64_t val)
 100 {
 101         return be64_to_cpu(val);
 102 }
 103
 104 #define elf_addr_to_cpu(x)      elf64_to_cpu(x)
 105 #define elf_off_to_cpu(x)       elf64_to_cpu(x)
 106 #define elf_xword_to_cpu(x)     elf64_to_cpu(x)
 107
 108 static void die(char *fmt, ...)
 109 {
 110         va_list ap;
 111
 112         va_start(ap, fmt);
 113         vfprintf(stderr, fmt, ap);
 114         va_end(ap);
 115         exit(1);
 116 }
 117
 118 static void read_ehdr(FILE *fp)
 119 {
 120         if (fread(&ehdr, sizeof(ehdr), 1, fp) != 1)
 121                 die("Cannot read ELF header: %s\n", strerror(errno));
 122         if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0)
 123                 die("No ELF magic\n");
 124         if (ehdr.e_ident[EI_CLASS] != ELF_CLASS)
 125                 die("Not a %d bit executable\n", ELF_BITS);
 126         if (ehdr.e_ident[EI_DATA] != ELF_ENDIAN)
 127                 die("ELF endian mismatch\n");
 128         if (ehdr.e_ident[EI_VERSION] != EV_CURRENT)
 129                 die("Unknown ELF version\n");
 130
 131         /* Convert the fields to native endian */
 132         ehdr.e_type      = elf_half_to_cpu(ehdr.e_type);
 133         ehdr.e_machine   = elf_half_to_cpu(ehdr.e_machine);
 134         ehdr.e_version   = elf_word_to_cpu(ehdr.e_version);
 135         ehdr.e_entry     = elf_addr_to_cpu(ehdr.e_entry);
 136         ehdr.e_phoff     = elf_off_to_cpu(ehdr.e_phoff);
 137         ehdr.e_shoff     = elf_off_to_cpu(ehdr.e_shoff);
 138         ehdr.e_flags     = elf_word_to_cpu(ehdr.e_flags);
 139         ehdr.e_ehsize    = elf_half_to_cpu(ehdr.e_ehsize);
 140         ehdr.e_phentsize = elf_half_to_cpu(ehdr.e_phentsize);
 141         ehdr.e_phnum     = elf_half_to_cpu(ehdr.e_phnum);
 142         ehdr.e_shentsize = elf_half_to_cpu(ehdr.e_shentsize);
 143         ehdr.e_shnum     = elf_half_to_cpu(ehdr.e_shnum);
 144         ehdr.e_shstrndx  = elf_half_to_cpu(ehdr.e_shstrndx);
 145
 146         shnum = ehdr.e_shnum;
 147         shstrndx = ehdr.e_shstrndx;
 148
 149         if ((ehdr.e_type != ET_EXEC) && (ehdr.e_type != ET_DYN))
 150                 die("Unsupported ELF header type\n");
 151         if (ehdr.e_machine != ELF_MACHINE)
 152                 die("Not for %s\n", ELF_MACHINE_NAME);
 153         if (ehdr.e_version != EV_CURRENT)
 154                 die("Unknown ELF version\n");
 155         if (ehdr.e_ehsize != sizeof(Elf_Ehdr))
 156                 die("Bad Elf header size\n");
 157         if (ehdr.e_phentsize != sizeof(Elf_Phdr))
 158                 die("Bad program header entry\n");
 159         if (ehdr.e_shentsize != sizeof(Elf_Shdr))
 160                 die("Bad section header entry\n");
 161
 162         if (shnum == SHN_UNDEF || shstrndx == SHN_XINDEX) {
 163                 Elf_Shdr shdr;
 164
 165                 if (fseek(fp, ehdr.e_shoff, SEEK_SET) < 0)
 166                         die("Seek to %" FMT " failed: %s\n", ehdr.e_shoff, strerror(errno));
 167
 168                 if (fread(&shdr, sizeof(shdr), 1, fp) != 1)
 169                         die("Cannot read initial ELF section header: %s\n", strerror(errno));
 170
 171                 if (shnum == SHN_UNDEF)
 172                         shnum = elf_xword_to_cpu(shdr.sh_size);
 173
 174                 if (shstrndx == SHN_XINDEX)
 175                         shstrndx = elf_word_to_cpu(shdr.sh_link);
 176         }
 177
 178         if (shstrndx >= shnum)
 179                 die("String table index out of bounds\n");
 180 }
 181
 182 static void read_shdrs(FILE *fp)
 183 {
 184         Elf_Shdr shdr;
 185         int i;
 186
 187         secs = calloc(shnum, sizeof(struct section));
 188         if (!secs)
 189                 die("Unable to allocate %ld section headers\n", shnum);
 190
 191         if (fseek(fp, ehdr.e_shoff, SEEK_SET) < 0)
 192                 die("Seek to %" FMT " failed: %s\n", ehdr.e_shoff, strerror(errno));
 193
 194         for (i = 0; i < shnum; i++) {
 195                 struct section *sec = &secs[i];
 196
 197                 if (fread(&shdr, sizeof(shdr), 1, fp) != 1) {
 198                         die("Cannot read ELF section headers %d/%ld: %s\n",
 199                             i, shnum, strerror(errno));
 200                 }
 201
 202                 sec->shdr.sh_name      = elf_word_to_cpu(shdr.sh_name);
 203                 sec->shdr.sh_type      = elf_word_to_cpu(shdr.sh_type);
 204                 sec->shdr.sh_flags     = elf_xword_to_cpu(shdr.sh_flags);
 205                 sec->shdr.sh_addr      = elf_addr_to_cpu(shdr.sh_addr);
 206                 sec->shdr.sh_offset    = elf_off_to_cpu(shdr.sh_offset);
 207                 sec->shdr.sh_size      = elf_xword_to_cpu(shdr.sh_size);
 208                 sec->shdr.sh_link      = elf_word_to_cpu(shdr.sh_link);
 209                 sec->shdr.sh_info      = elf_word_to_cpu(shdr.sh_info);
 210                 sec->shdr.sh_addralign = elf_xword_to_cpu(shdr.sh_addralign);
 211                 sec->shdr.sh_entsize   = elf_xword_to_cpu(shdr.sh_entsize);
 212
 213                 if (sec->shdr.sh_link < shnum)
 214                         sec->link = &secs[sec->shdr.sh_link];
 215         }
 216
 217 }
 218
 219 static void read_relocs(FILE *fp)
 220 {
 221         int i, j;
 222
 223         for (i = 0; i < shnum; i++) {
 224                 struct section *sec = &secs[i];
 225
 226                 if (sec->shdr.sh_type != SHT_REL_TYPE)
 227                         continue;
 228
 229                 sec->reltab = malloc(sec->shdr.sh_size);
 230                 if (!sec->reltab)
 231                         die("malloc of %" FMT " bytes for relocs failed\n", sec->shdr.sh_size);
 232
 233                 if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0)
 234                         die("Seek to %" FMT " failed: %s\n", sec->shdr.sh_offset, strerror(errno));
 235
 236                 if (fread(sec->reltab, 1, sec->shdr.sh_size, fp) != sec->shdr.sh_size)
 237                         die("Cannot read symbol table: %s\n", strerror(errno));
 238
 239                 for (j = 0; j < sec->shdr.sh_size / sizeof(Elf_Rel); j++) {
 240                         Elf_Rel *rel = &sec->reltab[j];
 241
 242                         rel->r_offset = elf_addr_to_cpu(rel->r_offset);
 243                         rel->r_info   = elf_xword_to_cpu(rel->r_info);
 244 #if (SHT_REL_TYPE == SHT_RELA)
 245                         rel->r_addend = elf_xword_to_cpu(rel->r_addend);
 246 #endif
 247                 }
 248         }
 249 }
 250
 251 static void add_reloc(struct relocs *r, uint32_t offset)
 252 {
 253         if (r->count == r->size) {
 254                 unsigned long newsize = r->size + 50000;
 255                 void *mem = realloc(r->offset, newsize * sizeof(r->offset[0]));
 256
 257                 if (!mem)
 258                         die("realloc of %ld entries for relocs failed\n", newsize);
 259
 260                 r->offset = mem;
 261                 r->size = newsize;
 262         }
 263         r->offset[r->count++] = offset;
 264 }
 265
 266 static int do_reloc(struct section *sec, Elf_Rel *rel)
 267 {
 268         unsigned int r_type = ELF64_R_TYPE(rel->r_info);
 269         ElfW(Addr) offset = rel->r_offset;
 270
 271         switch (r_type) {
 272         case R_390_NONE:
 273         case R_390_PC32:
 274         case R_390_PC64:
 275         case R_390_PC16DBL:
 276         case R_390_PC32DBL:
 277         case R_390_PLT32DBL:
 278         case R_390_GOTENT:
 279         case R_390_GOTPCDBL:
 280         case R_390_GOTOFF64:
 281                 break;
 282         case R_390_64:
 283                 add_reloc(&relocs64, offset);
 284                 break;
 285         default:
 286                 die("Unsupported relocation type: %d\n", r_type);
 287                 break;
 288         }
 289
 290         return 0;
 291 }
 292
 293 static void walk_relocs(void)
 294 {
 295         int i;
 296
 297         /* Walk through the relocations */
 298         for (i = 0; i < shnum; i++) {
 299                 struct section *sec_applies;
 300                 int j;
 301                 struct section *sec = &secs[i];
 302
 303                 if (sec->shdr.sh_type != SHT_REL_TYPE)
 304                         continue;
 305
 306                 sec_applies = &secs[sec->shdr.sh_info];
 307                 if (!(sec_applies->shdr.sh_flags & SHF_ALLOC))
 308                         continue;
 309
 310                 for (j = 0; j < sec->shdr.sh_size / sizeof(Elf_Rel); j++) {
 311                         Elf_Rel *rel = &sec->reltab[j];
 312
 313                         do_reloc(sec, rel);
 314                 }
 315         }
 316 }
 317
 318 static int cmp_relocs(const void *va, const void *vb)
 319 {
 320         const uint32_t *a, *b;
 321
 322         a = va; b = vb;
 323         return (*a == *b) ? 0 : (*a > *b) ? 1 : -1;
 324 }
 325
 326 static void sort_relocs(struct relocs *r)
 327 {
 328         qsort(r->offset, r->count, sizeof(r->offset[0]), cmp_relocs);
 329 }
 330
 331 static int print_reloc(uint32_t v)
 332 {
 333         return fprintf(stdout, "\t.long 0x%08"PRIx32"\n", v) > 0 ? 0 : -1;
 334 }
 335
 336 static void emit_relocs(void)
 337 {
 338         int i;
 339
 340         walk_relocs();
 341         sort_relocs(&relocs64);
 342
 343         printf(".section \".vmlinux.relocs_64\",\"a\"\n");
 344         for (i = 0; i < relocs64.count; i++)
 345                 print_reloc(relocs64.offset[i]);
 346 }
 347
 348 static void process(FILE *fp)
 349 {
 350         read_ehdr(fp);
 351         read_shdrs(fp);
 352         read_relocs(fp);
 353         emit_relocs();
 354 }
 355
 356 static void usage(void)
 357 {
 358         die("relocs vmlinux\n");
 359 }
 360
 361 int main(int argc, char **argv)
 362 {
 363         unsigned char e_ident[EI_NIDENT];
 364         const char *fname;
 365         FILE *fp;
 366
 367         fname = NULL;
 368
 369         if (argc != 2)
 370                 usage();
 371
 372         fname = argv[1];
 373
 374         fp = fopen(fname, "r");
 375         if (!fp)
 376                 die("Cannot open %s: %s\n", fname, strerror(errno));
 377
 378         if (fread(&e_ident, 1, EI_NIDENT, fp) != EI_NIDENT)
 379                 die("Cannot read %s: %s", fname, strerror(errno));
 380
 381         rewind(fp);
 382
 383         process(fp);
 384
 385         fclose(fp);
 386         return 0;
 387 }