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 } 388