relocs.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044
  1. /* This is included from relocs_32/64.c */
  2. #define ElfW(type) _ElfW(ELF_BITS, type)
  3. #define _ElfW(bits, type) __ElfW(bits, type)
  4. #define __ElfW(bits, type) Elf##bits##_##type
  5. #define Elf_Addr ElfW(Addr)
  6. #define Elf_Ehdr ElfW(Ehdr)
  7. #define Elf_Phdr ElfW(Phdr)
  8. #define Elf_Shdr ElfW(Shdr)
  9. #define Elf_Sym ElfW(Sym)
  10. static Elf_Ehdr ehdr;
  11. struct relocs {
  12. uint32_t *offset;
  13. unsigned long count;
  14. unsigned long size;
  15. };
  16. static struct relocs relocs16;
  17. static struct relocs relocs32;
  18. static struct relocs relocs64;
  19. struct section {
  20. Elf_Shdr shdr;
  21. struct section *link;
  22. Elf_Sym *symtab;
  23. Elf_Rel *reltab;
  24. char *strtab;
  25. };
  26. static struct section *secs;
  27. static const char * const sym_regex_kernel[S_NSYMTYPES] = {
  28. /*
  29. * Following symbols have been audited. There values are constant and do
  30. * not change if bzImage is loaded at a different physical address than
  31. * the address for which it has been compiled. Don't warn user about
  32. * absolute relocations present w.r.t these symbols.
  33. */
  34. [S_ABS] =
  35. "^(xen_irq_disable_direct_reloc$|"
  36. "xen_save_fl_direct_reloc$|"
  37. "VDSO|"
  38. "__crc_)",
  39. /*
  40. * These symbols are known to be relative, even if the linker marks them
  41. * as absolute (typically defined outside any section in the linker script.)
  42. */
  43. [S_REL] =
  44. "^(__init_(begin|end)|"
  45. "__x86_cpu_dev_(start|end)|"
  46. "(__parainstructions|__alt_instructions)(|_end)|"
  47. "(__iommu_table|__apicdrivers|__smp_locks)(|_end)|"
  48. "__(start|end)_pci_.*|"
  49. "__(start|end)_builtin_fw|"
  50. "__(start|stop)___ksymtab(|_gpl|_unused|_unused_gpl|_gpl_future)|"
  51. "__(start|stop)___kcrctab(|_gpl|_unused|_unused_gpl|_gpl_future)|"
  52. "__(start|stop)___param|"
  53. "__(start|stop)___modver|"
  54. "__(start|stop)___bug_table|"
  55. "__tracedata_(start|end)|"
  56. "__(start|stop)_notes|"
  57. "__end_rodata|"
  58. "__initramfs_start|"
  59. "(jiffies|jiffies_64)|"
  60. #if ELF_BITS == 64
  61. "__per_cpu_load|"
  62. "init_per_cpu__.*|"
  63. "__end_rodata_hpage_align|"
  64. "__vvar_page|"
  65. #endif
  66. "_end)$"
  67. };
  68. static const char * const sym_regex_realmode[S_NSYMTYPES] = {
  69. /*
  70. * These symbols are known to be relative, even if the linker marks them
  71. * as absolute (typically defined outside any section in the linker script.)
  72. */
  73. [S_REL] =
  74. "^pa_",
  75. /*
  76. * These are 16-bit segment symbols when compiling 16-bit code.
  77. */
  78. [S_SEG] =
  79. "^real_mode_seg$",
  80. /*
  81. * These are offsets belonging to segments, as opposed to linear addresses,
  82. * when compiling 16-bit code.
  83. */
  84. [S_LIN] =
  85. "^pa_",
  86. };
  87. static const char * const *sym_regex;
  88. static regex_t sym_regex_c[S_NSYMTYPES];
  89. static int is_reloc(enum symtype type, const char *sym_name)
  90. {
  91. return sym_regex[type] &&
  92. !regexec(&sym_regex_c[type], sym_name, 0, NULL, 0);
  93. }
  94. static void regex_init(int use_real_mode)
  95. {
  96. char errbuf[128];
  97. int err;
  98. int i;
  99. if (use_real_mode)
  100. sym_regex = sym_regex_realmode;
  101. else
  102. sym_regex = sym_regex_kernel;
  103. for (i = 0; i < S_NSYMTYPES; i++) {
  104. if (!sym_regex[i])
  105. continue;
  106. err = regcomp(&sym_regex_c[i], sym_regex[i],
  107. REG_EXTENDED|REG_NOSUB);
  108. if (err) {
  109. regerror(err, &sym_regex_c[i], errbuf, sizeof errbuf);
  110. die("%s", errbuf);
  111. }
  112. }
  113. }
  114. static const char *sym_type(unsigned type)
  115. {
  116. static const char *type_name[] = {
  117. #define SYM_TYPE(X) [X] = #X
  118. SYM_TYPE(STT_NOTYPE),
  119. SYM_TYPE(STT_OBJECT),
  120. SYM_TYPE(STT_FUNC),
  121. SYM_TYPE(STT_SECTION),
  122. SYM_TYPE(STT_FILE),
  123. SYM_TYPE(STT_COMMON),
  124. SYM_TYPE(STT_TLS),
  125. #undef SYM_TYPE
  126. };
  127. const char *name = "unknown sym type name";
  128. if (type < ARRAY_SIZE(type_name)) {
  129. name = type_name[type];
  130. }
  131. return name;
  132. }
  133. static const char *sym_bind(unsigned bind)
  134. {
  135. static const char *bind_name[] = {
  136. #define SYM_BIND(X) [X] = #X
  137. SYM_BIND(STB_LOCAL),
  138. SYM_BIND(STB_GLOBAL),
  139. SYM_BIND(STB_WEAK),
  140. #undef SYM_BIND
  141. };
  142. const char *name = "unknown sym bind name";
  143. if (bind < ARRAY_SIZE(bind_name)) {
  144. name = bind_name[bind];
  145. }
  146. return name;
  147. }
  148. static const char *sym_visibility(unsigned visibility)
  149. {
  150. static const char *visibility_name[] = {
  151. #define SYM_VISIBILITY(X) [X] = #X
  152. SYM_VISIBILITY(STV_DEFAULT),
  153. SYM_VISIBILITY(STV_INTERNAL),
  154. SYM_VISIBILITY(STV_HIDDEN),
  155. SYM_VISIBILITY(STV_PROTECTED),
  156. #undef SYM_VISIBILITY
  157. };
  158. const char *name = "unknown sym visibility name";
  159. if (visibility < ARRAY_SIZE(visibility_name)) {
  160. name = visibility_name[visibility];
  161. }
  162. return name;
  163. }
  164. static const char *rel_type(unsigned type)
  165. {
  166. static const char *type_name[] = {
  167. #define REL_TYPE(X) [X] = #X
  168. #if ELF_BITS == 64
  169. REL_TYPE(R_X86_64_NONE),
  170. REL_TYPE(R_X86_64_64),
  171. REL_TYPE(R_X86_64_PC32),
  172. REL_TYPE(R_X86_64_GOT32),
  173. REL_TYPE(R_X86_64_PLT32),
  174. REL_TYPE(R_X86_64_COPY),
  175. REL_TYPE(R_X86_64_GLOB_DAT),
  176. REL_TYPE(R_X86_64_JUMP_SLOT),
  177. REL_TYPE(R_X86_64_RELATIVE),
  178. REL_TYPE(R_X86_64_GOTPCREL),
  179. REL_TYPE(R_X86_64_32),
  180. REL_TYPE(R_X86_64_32S),
  181. REL_TYPE(R_X86_64_16),
  182. REL_TYPE(R_X86_64_PC16),
  183. REL_TYPE(R_X86_64_8),
  184. REL_TYPE(R_X86_64_PC8),
  185. #else
  186. REL_TYPE(R_386_NONE),
  187. REL_TYPE(R_386_32),
  188. REL_TYPE(R_386_PC32),
  189. REL_TYPE(R_386_GOT32),
  190. REL_TYPE(R_386_PLT32),
  191. REL_TYPE(R_386_COPY),
  192. REL_TYPE(R_386_GLOB_DAT),
  193. REL_TYPE(R_386_JMP_SLOT),
  194. REL_TYPE(R_386_RELATIVE),
  195. REL_TYPE(R_386_GOTOFF),
  196. REL_TYPE(R_386_GOTPC),
  197. REL_TYPE(R_386_8),
  198. REL_TYPE(R_386_PC8),
  199. REL_TYPE(R_386_16),
  200. REL_TYPE(R_386_PC16),
  201. #endif
  202. #undef REL_TYPE
  203. };
  204. const char *name = "unknown type rel type name";
  205. if (type < ARRAY_SIZE(type_name) && type_name[type]) {
  206. name = type_name[type];
  207. }
  208. return name;
  209. }
  210. static const char *sec_name(unsigned shndx)
  211. {
  212. const char *sec_strtab;
  213. const char *name;
  214. sec_strtab = secs[ehdr.e_shstrndx].strtab;
  215. name = "<noname>";
  216. if (shndx < ehdr.e_shnum) {
  217. name = sec_strtab + secs[shndx].shdr.sh_name;
  218. }
  219. else if (shndx == SHN_ABS) {
  220. name = "ABSOLUTE";
  221. }
  222. else if (shndx == SHN_COMMON) {
  223. name = "COMMON";
  224. }
  225. return name;
  226. }
  227. static const char *sym_name(const char *sym_strtab, Elf_Sym *sym)
  228. {
  229. const char *name;
  230. name = "<noname>";
  231. if (sym->st_name) {
  232. name = sym_strtab + sym->st_name;
  233. }
  234. else {
  235. name = sec_name(sym->st_shndx);
  236. }
  237. return name;
  238. }
  239. static Elf_Sym *sym_lookup(const char *symname)
  240. {
  241. int i;
  242. for (i = 0; i < ehdr.e_shnum; i++) {
  243. struct section *sec = &secs[i];
  244. long nsyms;
  245. char *strtab;
  246. Elf_Sym *symtab;
  247. Elf_Sym *sym;
  248. if (sec->shdr.sh_type != SHT_SYMTAB)
  249. continue;
  250. nsyms = sec->shdr.sh_size/sizeof(Elf_Sym);
  251. symtab = sec->symtab;
  252. strtab = sec->link->strtab;
  253. for (sym = symtab; --nsyms >= 0; sym++) {
  254. if (!sym->st_name)
  255. continue;
  256. if (strcmp(symname, strtab + sym->st_name) == 0)
  257. return sym;
  258. }
  259. }
  260. return 0;
  261. }
  262. #if BYTE_ORDER == LITTLE_ENDIAN
  263. #define le16_to_cpu(val) (val)
  264. #define le32_to_cpu(val) (val)
  265. #define le64_to_cpu(val) (val)
  266. #endif
  267. #if BYTE_ORDER == BIG_ENDIAN
  268. #define le16_to_cpu(val) bswap_16(val)
  269. #define le32_to_cpu(val) bswap_32(val)
  270. #define le64_to_cpu(val) bswap_64(val)
  271. #endif
  272. static uint16_t elf16_to_cpu(uint16_t val)
  273. {
  274. return le16_to_cpu(val);
  275. }
  276. static uint32_t elf32_to_cpu(uint32_t val)
  277. {
  278. return le32_to_cpu(val);
  279. }
  280. #define elf_half_to_cpu(x) elf16_to_cpu(x)
  281. #define elf_word_to_cpu(x) elf32_to_cpu(x)
  282. #if ELF_BITS == 64
  283. static uint64_t elf64_to_cpu(uint64_t val)
  284. {
  285. return le64_to_cpu(val);
  286. }
  287. #define elf_addr_to_cpu(x) elf64_to_cpu(x)
  288. #define elf_off_to_cpu(x) elf64_to_cpu(x)
  289. #define elf_xword_to_cpu(x) elf64_to_cpu(x)
  290. #else
  291. #define elf_addr_to_cpu(x) elf32_to_cpu(x)
  292. #define elf_off_to_cpu(x) elf32_to_cpu(x)
  293. #define elf_xword_to_cpu(x) elf32_to_cpu(x)
  294. #endif
  295. static void read_ehdr(FILE *fp)
  296. {
  297. if (fread(&ehdr, sizeof(ehdr), 1, fp) != 1) {
  298. die("Cannot read ELF header: %s\n",
  299. strerror(errno));
  300. }
  301. if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0) {
  302. die("No ELF magic\n");
  303. }
  304. if (ehdr.e_ident[EI_CLASS] != ELF_CLASS) {
  305. die("Not a %d bit executable\n", ELF_BITS);
  306. }
  307. if (ehdr.e_ident[EI_DATA] != ELFDATA2LSB) {
  308. die("Not a LSB ELF executable\n");
  309. }
  310. if (ehdr.e_ident[EI_VERSION] != EV_CURRENT) {
  311. die("Unknown ELF version\n");
  312. }
  313. /* Convert the fields to native endian */
  314. ehdr.e_type = elf_half_to_cpu(ehdr.e_type);
  315. ehdr.e_machine = elf_half_to_cpu(ehdr.e_machine);
  316. ehdr.e_version = elf_word_to_cpu(ehdr.e_version);
  317. ehdr.e_entry = elf_addr_to_cpu(ehdr.e_entry);
  318. ehdr.e_phoff = elf_off_to_cpu(ehdr.e_phoff);
  319. ehdr.e_shoff = elf_off_to_cpu(ehdr.e_shoff);
  320. ehdr.e_flags = elf_word_to_cpu(ehdr.e_flags);
  321. ehdr.e_ehsize = elf_half_to_cpu(ehdr.e_ehsize);
  322. ehdr.e_phentsize = elf_half_to_cpu(ehdr.e_phentsize);
  323. ehdr.e_phnum = elf_half_to_cpu(ehdr.e_phnum);
  324. ehdr.e_shentsize = elf_half_to_cpu(ehdr.e_shentsize);
  325. ehdr.e_shnum = elf_half_to_cpu(ehdr.e_shnum);
  326. ehdr.e_shstrndx = elf_half_to_cpu(ehdr.e_shstrndx);
  327. if ((ehdr.e_type != ET_EXEC) && (ehdr.e_type != ET_DYN)) {
  328. die("Unsupported ELF header type\n");
  329. }
  330. if (ehdr.e_machine != ELF_MACHINE) {
  331. die("Not for %s\n", ELF_MACHINE_NAME);
  332. }
  333. if (ehdr.e_version != EV_CURRENT) {
  334. die("Unknown ELF version\n");
  335. }
  336. if (ehdr.e_ehsize != sizeof(Elf_Ehdr)) {
  337. die("Bad Elf header size\n");
  338. }
  339. if (ehdr.e_phentsize != sizeof(Elf_Phdr)) {
  340. die("Bad program header entry\n");
  341. }
  342. if (ehdr.e_shentsize != sizeof(Elf_Shdr)) {
  343. die("Bad section header entry\n");
  344. }
  345. if (ehdr.e_shstrndx >= ehdr.e_shnum) {
  346. die("String table index out of bounds\n");
  347. }
  348. }
  349. static void read_shdrs(FILE *fp)
  350. {
  351. int i;
  352. Elf_Shdr shdr;
  353. secs = calloc(ehdr.e_shnum, sizeof(struct section));
  354. if (!secs) {
  355. die("Unable to allocate %d section headers\n",
  356. ehdr.e_shnum);
  357. }
  358. if (fseek(fp, ehdr.e_shoff, SEEK_SET) < 0) {
  359. die("Seek to %d failed: %s\n",
  360. ehdr.e_shoff, strerror(errno));
  361. }
  362. for (i = 0; i < ehdr.e_shnum; i++) {
  363. struct section *sec = &secs[i];
  364. if (fread(&shdr, sizeof shdr, 1, fp) != 1)
  365. die("Cannot read ELF section headers %d/%d: %s\n",
  366. i, ehdr.e_shnum, strerror(errno));
  367. sec->shdr.sh_name = elf_word_to_cpu(shdr.sh_name);
  368. sec->shdr.sh_type = elf_word_to_cpu(shdr.sh_type);
  369. sec->shdr.sh_flags = elf_xword_to_cpu(shdr.sh_flags);
  370. sec->shdr.sh_addr = elf_addr_to_cpu(shdr.sh_addr);
  371. sec->shdr.sh_offset = elf_off_to_cpu(shdr.sh_offset);
  372. sec->shdr.sh_size = elf_xword_to_cpu(shdr.sh_size);
  373. sec->shdr.sh_link = elf_word_to_cpu(shdr.sh_link);
  374. sec->shdr.sh_info = elf_word_to_cpu(shdr.sh_info);
  375. sec->shdr.sh_addralign = elf_xword_to_cpu(shdr.sh_addralign);
  376. sec->shdr.sh_entsize = elf_xword_to_cpu(shdr.sh_entsize);
  377. if (sec->shdr.sh_link < ehdr.e_shnum)
  378. sec->link = &secs[sec->shdr.sh_link];
  379. }
  380. }
  381. static void read_strtabs(FILE *fp)
  382. {
  383. int i;
  384. for (i = 0; i < ehdr.e_shnum; i++) {
  385. struct section *sec = &secs[i];
  386. if (sec->shdr.sh_type != SHT_STRTAB) {
  387. continue;
  388. }
  389. sec->strtab = malloc(sec->shdr.sh_size);
  390. if (!sec->strtab) {
  391. die("malloc of %d bytes for strtab failed\n",
  392. sec->shdr.sh_size);
  393. }
  394. if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0) {
  395. die("Seek to %d failed: %s\n",
  396. sec->shdr.sh_offset, strerror(errno));
  397. }
  398. if (fread(sec->strtab, 1, sec->shdr.sh_size, fp)
  399. != sec->shdr.sh_size) {
  400. die("Cannot read symbol table: %s\n",
  401. strerror(errno));
  402. }
  403. }
  404. }
  405. static void read_symtabs(FILE *fp)
  406. {
  407. int i,j;
  408. for (i = 0; i < ehdr.e_shnum; i++) {
  409. struct section *sec = &secs[i];
  410. if (sec->shdr.sh_type != SHT_SYMTAB) {
  411. continue;
  412. }
  413. sec->symtab = malloc(sec->shdr.sh_size);
  414. if (!sec->symtab) {
  415. die("malloc of %d bytes for symtab failed\n",
  416. sec->shdr.sh_size);
  417. }
  418. if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0) {
  419. die("Seek to %d failed: %s\n",
  420. sec->shdr.sh_offset, strerror(errno));
  421. }
  422. if (fread(sec->symtab, 1, sec->shdr.sh_size, fp)
  423. != sec->shdr.sh_size) {
  424. die("Cannot read symbol table: %s\n",
  425. strerror(errno));
  426. }
  427. for (j = 0; j < sec->shdr.sh_size/sizeof(Elf_Sym); j++) {
  428. Elf_Sym *sym = &sec->symtab[j];
  429. sym->st_name = elf_word_to_cpu(sym->st_name);
  430. sym->st_value = elf_addr_to_cpu(sym->st_value);
  431. sym->st_size = elf_xword_to_cpu(sym->st_size);
  432. sym->st_shndx = elf_half_to_cpu(sym->st_shndx);
  433. }
  434. }
  435. }
  436. static void read_relocs(FILE *fp)
  437. {
  438. int i,j;
  439. for (i = 0; i < ehdr.e_shnum; i++) {
  440. struct section *sec = &secs[i];
  441. if (sec->shdr.sh_type != SHT_REL_TYPE) {
  442. continue;
  443. }
  444. sec->reltab = malloc(sec->shdr.sh_size);
  445. if (!sec->reltab) {
  446. die("malloc of %d bytes for relocs failed\n",
  447. sec->shdr.sh_size);
  448. }
  449. if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0) {
  450. die("Seek to %d failed: %s\n",
  451. sec->shdr.sh_offset, strerror(errno));
  452. }
  453. if (fread(sec->reltab, 1, sec->shdr.sh_size, fp)
  454. != sec->shdr.sh_size) {
  455. die("Cannot read symbol table: %s\n",
  456. strerror(errno));
  457. }
  458. for (j = 0; j < sec->shdr.sh_size/sizeof(Elf_Rel); j++) {
  459. Elf_Rel *rel = &sec->reltab[j];
  460. rel->r_offset = elf_addr_to_cpu(rel->r_offset);
  461. rel->r_info = elf_xword_to_cpu(rel->r_info);
  462. #if (SHT_REL_TYPE == SHT_RELA)
  463. rel->r_addend = elf_xword_to_cpu(rel->r_addend);
  464. #endif
  465. }
  466. }
  467. }
  468. static void print_absolute_symbols(void)
  469. {
  470. int i;
  471. const char *format;
  472. if (ELF_BITS == 64)
  473. format = "%5d %016"PRIx64" %5"PRId64" %10s %10s %12s %s\n";
  474. else
  475. format = "%5d %08"PRIx32" %5"PRId32" %10s %10s %12s %s\n";
  476. printf("Absolute symbols\n");
  477. printf(" Num: Value Size Type Bind Visibility Name\n");
  478. for (i = 0; i < ehdr.e_shnum; i++) {
  479. struct section *sec = &secs[i];
  480. char *sym_strtab;
  481. int j;
  482. if (sec->shdr.sh_type != SHT_SYMTAB) {
  483. continue;
  484. }
  485. sym_strtab = sec->link->strtab;
  486. for (j = 0; j < sec->shdr.sh_size/sizeof(Elf_Sym); j++) {
  487. Elf_Sym *sym;
  488. const char *name;
  489. sym = &sec->symtab[j];
  490. name = sym_name(sym_strtab, sym);
  491. if (sym->st_shndx != SHN_ABS) {
  492. continue;
  493. }
  494. printf(format,
  495. j, sym->st_value, sym->st_size,
  496. sym_type(ELF_ST_TYPE(sym->st_info)),
  497. sym_bind(ELF_ST_BIND(sym->st_info)),
  498. sym_visibility(ELF_ST_VISIBILITY(sym->st_other)),
  499. name);
  500. }
  501. }
  502. printf("\n");
  503. }
  504. static void print_absolute_relocs(void)
  505. {
  506. int i, printed = 0;
  507. const char *format;
  508. if (ELF_BITS == 64)
  509. format = "%016"PRIx64" %016"PRIx64" %10s %016"PRIx64" %s\n";
  510. else
  511. format = "%08"PRIx32" %08"PRIx32" %10s %08"PRIx32" %s\n";
  512. for (i = 0; i < ehdr.e_shnum; i++) {
  513. struct section *sec = &secs[i];
  514. struct section *sec_applies, *sec_symtab;
  515. char *sym_strtab;
  516. Elf_Sym *sh_symtab;
  517. int j;
  518. if (sec->shdr.sh_type != SHT_REL_TYPE) {
  519. continue;
  520. }
  521. sec_symtab = sec->link;
  522. sec_applies = &secs[sec->shdr.sh_info];
  523. if (!(sec_applies->shdr.sh_flags & SHF_ALLOC)) {
  524. continue;
  525. }
  526. sh_symtab = sec_symtab->symtab;
  527. sym_strtab = sec_symtab->link->strtab;
  528. for (j = 0; j < sec->shdr.sh_size/sizeof(Elf_Rel); j++) {
  529. Elf_Rel *rel;
  530. Elf_Sym *sym;
  531. const char *name;
  532. rel = &sec->reltab[j];
  533. sym = &sh_symtab[ELF_R_SYM(rel->r_info)];
  534. name = sym_name(sym_strtab, sym);
  535. if (sym->st_shndx != SHN_ABS) {
  536. continue;
  537. }
  538. /* Absolute symbols are not relocated if bzImage is
  539. * loaded at a non-compiled address. Display a warning
  540. * to user at compile time about the absolute
  541. * relocations present.
  542. *
  543. * User need to audit the code to make sure
  544. * some symbols which should have been section
  545. * relative have not become absolute because of some
  546. * linker optimization or wrong programming usage.
  547. *
  548. * Before warning check if this absolute symbol
  549. * relocation is harmless.
  550. */
  551. if (is_reloc(S_ABS, name) || is_reloc(S_REL, name))
  552. continue;
  553. if (!printed) {
  554. printf("WARNING: Absolute relocations"
  555. " present\n");
  556. printf("Offset Info Type Sym.Value "
  557. "Sym.Name\n");
  558. printed = 1;
  559. }
  560. printf(format,
  561. rel->r_offset,
  562. rel->r_info,
  563. rel_type(ELF_R_TYPE(rel->r_info)),
  564. sym->st_value,
  565. name);
  566. }
  567. }
  568. if (printed)
  569. printf("\n");
  570. }
  571. static void add_reloc(struct relocs *r, uint32_t offset)
  572. {
  573. if (r->count == r->size) {
  574. unsigned long newsize = r->size + 50000;
  575. void *mem = realloc(r->offset, newsize * sizeof(r->offset[0]));
  576. if (!mem)
  577. die("realloc of %ld entries for relocs failed\n",
  578. newsize);
  579. r->offset = mem;
  580. r->size = newsize;
  581. }
  582. r->offset[r->count++] = offset;
  583. }
  584. static void walk_relocs(int (*process)(struct section *sec, Elf_Rel *rel,
  585. Elf_Sym *sym, const char *symname))
  586. {
  587. int i;
  588. /* Walk through the relocations */
  589. for (i = 0; i < ehdr.e_shnum; i++) {
  590. char *sym_strtab;
  591. Elf_Sym *sh_symtab;
  592. struct section *sec_applies, *sec_symtab;
  593. int j;
  594. struct section *sec = &secs[i];
  595. if (sec->shdr.sh_type != SHT_REL_TYPE) {
  596. continue;
  597. }
  598. sec_symtab = sec->link;
  599. sec_applies = &secs[sec->shdr.sh_info];
  600. if (!(sec_applies->shdr.sh_flags & SHF_ALLOC)) {
  601. continue;
  602. }
  603. sh_symtab = sec_symtab->symtab;
  604. sym_strtab = sec_symtab->link->strtab;
  605. for (j = 0; j < sec->shdr.sh_size/sizeof(Elf_Rel); j++) {
  606. Elf_Rel *rel = &sec->reltab[j];
  607. Elf_Sym *sym = &sh_symtab[ELF_R_SYM(rel->r_info)];
  608. const char *symname = sym_name(sym_strtab, sym);
  609. process(sec, rel, sym, symname);
  610. }
  611. }
  612. }
  613. /*
  614. * The .data..percpu section is a special case for x86_64 SMP kernels.
  615. * It is used to initialize the actual per_cpu areas and to provide
  616. * definitions for the per_cpu variables that correspond to their offsets
  617. * within the percpu area. Since the values of all of the symbols need
  618. * to be offsets from the start of the per_cpu area the virtual address
  619. * (sh_addr) of .data..percpu is 0 in SMP kernels.
  620. *
  621. * This means that:
  622. *
  623. * Relocations that reference symbols in the per_cpu area do not
  624. * need further relocation (since the value is an offset relative
  625. * to the start of the per_cpu area that does not change).
  626. *
  627. * Relocations that apply to the per_cpu area need to have their
  628. * offset adjusted by by the value of __per_cpu_load to make them
  629. * point to the correct place in the loaded image (because the
  630. * virtual address of .data..percpu is 0).
  631. *
  632. * For non SMP kernels .data..percpu is linked as part of the normal
  633. * kernel data and does not require special treatment.
  634. *
  635. */
  636. static int per_cpu_shndx = -1;
  637. Elf_Addr per_cpu_load_addr;
  638. static void percpu_init(void)
  639. {
  640. int i;
  641. for (i = 0; i < ehdr.e_shnum; i++) {
  642. ElfW(Sym) *sym;
  643. if (strcmp(sec_name(i), ".data..percpu"))
  644. continue;
  645. if (secs[i].shdr.sh_addr != 0) /* non SMP kernel */
  646. return;
  647. sym = sym_lookup("__per_cpu_load");
  648. if (!sym)
  649. die("can't find __per_cpu_load\n");
  650. per_cpu_shndx = i;
  651. per_cpu_load_addr = sym->st_value;
  652. return;
  653. }
  654. }
  655. #if ELF_BITS == 64
  656. /*
  657. * Check to see if a symbol lies in the .data..percpu section.
  658. * For some as yet not understood reason the "__init_begin"
  659. * symbol which immediately preceeds the .data..percpu section
  660. * also shows up as it it were part of it so we do an explict
  661. * check for that symbol name and ignore it.
  662. */
  663. static int is_percpu_sym(ElfW(Sym) *sym, const char *symname)
  664. {
  665. return (sym->st_shndx == per_cpu_shndx) &&
  666. strcmp(symname, "__init_begin");
  667. }
  668. static int do_reloc64(struct section *sec, Elf_Rel *rel, ElfW(Sym) *sym,
  669. const char *symname)
  670. {
  671. unsigned r_type = ELF64_R_TYPE(rel->r_info);
  672. ElfW(Addr) offset = rel->r_offset;
  673. int shn_abs = (sym->st_shndx == SHN_ABS) && !is_reloc(S_REL, symname);
  674. if (sym->st_shndx == SHN_UNDEF)
  675. return 0;
  676. /*
  677. * Adjust the offset if this reloc applies to the percpu section.
  678. */
  679. if (sec->shdr.sh_info == per_cpu_shndx)
  680. offset += per_cpu_load_addr;
  681. switch (r_type) {
  682. case R_X86_64_NONE:
  683. case R_X86_64_PC32:
  684. /*
  685. * NONE can be ignored and PC relative relocations don't
  686. * need to be adjusted.
  687. */
  688. break;
  689. case R_X86_64_32:
  690. case R_X86_64_32S:
  691. case R_X86_64_64:
  692. /*
  693. * References to the percpu area don't need to be adjusted.
  694. */
  695. if (is_percpu_sym(sym, symname))
  696. break;
  697. if (shn_abs) {
  698. /*
  699. * Whitelisted absolute symbols do not require
  700. * relocation.
  701. */
  702. if (is_reloc(S_ABS, symname))
  703. break;
  704. die("Invalid absolute %s relocation: %s\n",
  705. rel_type(r_type), symname);
  706. break;
  707. }
  708. /*
  709. * Relocation offsets for 64 bit kernels are output
  710. * as 32 bits and sign extended back to 64 bits when
  711. * the relocations are processed.
  712. * Make sure that the offset will fit.
  713. */
  714. if ((int32_t)offset != (int64_t)offset)
  715. die("Relocation offset doesn't fit in 32 bits\n");
  716. if (r_type == R_X86_64_64)
  717. add_reloc(&relocs64, offset);
  718. else
  719. add_reloc(&relocs32, offset);
  720. break;
  721. default:
  722. die("Unsupported relocation type: %s (%d)\n",
  723. rel_type(r_type), r_type);
  724. break;
  725. }
  726. return 0;
  727. }
  728. #else
  729. static int do_reloc32(struct section *sec, Elf_Rel *rel, Elf_Sym *sym,
  730. const char *symname)
  731. {
  732. unsigned r_type = ELF32_R_TYPE(rel->r_info);
  733. int shn_abs = (sym->st_shndx == SHN_ABS) && !is_reloc(S_REL, symname);
  734. switch (r_type) {
  735. case R_386_NONE:
  736. case R_386_PC32:
  737. case R_386_PC16:
  738. case R_386_PC8:
  739. /*
  740. * NONE can be ignored and PC relative relocations don't
  741. * need to be adjusted.
  742. */
  743. break;
  744. case R_386_32:
  745. if (shn_abs) {
  746. /*
  747. * Whitelisted absolute symbols do not require
  748. * relocation.
  749. */
  750. if (is_reloc(S_ABS, symname))
  751. break;
  752. die("Invalid absolute %s relocation: %s\n",
  753. rel_type(r_type), symname);
  754. break;
  755. }
  756. add_reloc(&relocs32, rel->r_offset);
  757. break;
  758. default:
  759. die("Unsupported relocation type: %s (%d)\n",
  760. rel_type(r_type), r_type);
  761. break;
  762. }
  763. return 0;
  764. }
  765. static int do_reloc_real(struct section *sec, Elf_Rel *rel, Elf_Sym *sym,
  766. const char *symname)
  767. {
  768. unsigned r_type = ELF32_R_TYPE(rel->r_info);
  769. int shn_abs = (sym->st_shndx == SHN_ABS) && !is_reloc(S_REL, symname);
  770. switch (r_type) {
  771. case R_386_NONE:
  772. case R_386_PC32:
  773. case R_386_PC16:
  774. case R_386_PC8:
  775. /*
  776. * NONE can be ignored and PC relative relocations don't
  777. * need to be adjusted.
  778. */
  779. break;
  780. case R_386_16:
  781. if (shn_abs) {
  782. /*
  783. * Whitelisted absolute symbols do not require
  784. * relocation.
  785. */
  786. if (is_reloc(S_ABS, symname))
  787. break;
  788. if (is_reloc(S_SEG, symname)) {
  789. add_reloc(&relocs16, rel->r_offset);
  790. break;
  791. }
  792. } else {
  793. if (!is_reloc(S_LIN, symname))
  794. break;
  795. }
  796. die("Invalid %s %s relocation: %s\n",
  797. shn_abs ? "absolute" : "relative",
  798. rel_type(r_type), symname);
  799. break;
  800. case R_386_32:
  801. if (shn_abs) {
  802. /*
  803. * Whitelisted absolute symbols do not require
  804. * relocation.
  805. */
  806. if (is_reloc(S_ABS, symname))
  807. break;
  808. if (is_reloc(S_REL, symname)) {
  809. add_reloc(&relocs32, rel->r_offset);
  810. break;
  811. }
  812. } else {
  813. if (is_reloc(S_LIN, symname))
  814. add_reloc(&relocs32, rel->r_offset);
  815. break;
  816. }
  817. die("Invalid %s %s relocation: %s\n",
  818. shn_abs ? "absolute" : "relative",
  819. rel_type(r_type), symname);
  820. break;
  821. default:
  822. die("Unsupported relocation type: %s (%d)\n",
  823. rel_type(r_type), r_type);
  824. break;
  825. }
  826. return 0;
  827. }
  828. #endif
  829. static int cmp_relocs(const void *va, const void *vb)
  830. {
  831. const uint32_t *a, *b;
  832. a = va; b = vb;
  833. return (*a == *b)? 0 : (*a > *b)? 1 : -1;
  834. }
  835. static void sort_relocs(struct relocs *r)
  836. {
  837. qsort(r->offset, r->count, sizeof(r->offset[0]), cmp_relocs);
  838. }
  839. static int write32(uint32_t v, FILE *f)
  840. {
  841. unsigned char buf[4];
  842. put_unaligned_le32(v, buf);
  843. return fwrite(buf, 1, 4, f) == 4 ? 0 : -1;
  844. }
  845. static int write32_as_text(uint32_t v, FILE *f)
  846. {
  847. return fprintf(f, "\t.long 0x%08"PRIx32"\n", v) > 0 ? 0 : -1;
  848. }
  849. static void emit_relocs(int as_text, int use_real_mode)
  850. {
  851. int i;
  852. int (*write_reloc)(uint32_t, FILE *) = write32;
  853. int (*do_reloc)(struct section *sec, Elf_Rel *rel, Elf_Sym *sym,
  854. const char *symname);
  855. #if ELF_BITS == 64
  856. if (!use_real_mode)
  857. do_reloc = do_reloc64;
  858. else
  859. die("--realmode not valid for a 64-bit ELF file");
  860. #else
  861. if (!use_real_mode)
  862. do_reloc = do_reloc32;
  863. else
  864. do_reloc = do_reloc_real;
  865. #endif
  866. /* Collect up the relocations */
  867. walk_relocs(do_reloc);
  868. if (relocs16.count && !use_real_mode)
  869. die("Segment relocations found but --realmode not specified\n");
  870. /* Order the relocations for more efficient processing */
  871. sort_relocs(&relocs16);
  872. sort_relocs(&relocs32);
  873. sort_relocs(&relocs64);
  874. /* Print the relocations */
  875. if (as_text) {
  876. /* Print the relocations in a form suitable that
  877. * gas will like.
  878. */
  879. printf(".section \".data.reloc\",\"a\"\n");
  880. printf(".balign 4\n");
  881. write_reloc = write32_as_text;
  882. }
  883. if (use_real_mode) {
  884. write_reloc(relocs16.count, stdout);
  885. for (i = 0; i < relocs16.count; i++)
  886. write_reloc(relocs16.offset[i], stdout);
  887. write_reloc(relocs32.count, stdout);
  888. for (i = 0; i < relocs32.count; i++)
  889. write_reloc(relocs32.offset[i], stdout);
  890. } else {
  891. if (ELF_BITS == 64) {
  892. /* Print a stop */
  893. write_reloc(0, stdout);
  894. /* Now print each relocation */
  895. for (i = 0; i < relocs64.count; i++)
  896. write_reloc(relocs64.offset[i], stdout);
  897. }
  898. /* Print a stop */
  899. write_reloc(0, stdout);
  900. /* Now print each relocation */
  901. for (i = 0; i < relocs32.count; i++)
  902. write_reloc(relocs32.offset[i], stdout);
  903. }
  904. }
  905. #if ELF_BITS == 64
  906. # define process process_64
  907. #else
  908. # define process process_32
  909. #endif
  910. void process(FILE *fp, int use_real_mode, int as_text,
  911. int show_absolute_syms, int show_absolute_relocs)
  912. {
  913. regex_init(use_real_mode);
  914. read_ehdr(fp);
  915. read_shdrs(fp);
  916. read_strtabs(fp);
  917. read_symtabs(fp);
  918. read_relocs(fp);
  919. if (ELF_BITS == 64)
  920. percpu_init();
  921. if (show_absolute_syms) {
  922. print_absolute_symbols();
  923. return;
  924. }
  925. if (show_absolute_relocs) {
  926. print_absolute_relocs();
  927. return;
  928. }
  929. emit_relocs(as_text, use_real_mode);
  930. }