Image.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460
  1. /*
  2. * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/BinarySearch.h>
  7. #include <AK/Debug.h>
  8. #include <AK/Demangle.h>
  9. #include <AK/Memory.h>
  10. #include <AK/QuickSort.h>
  11. #include <AK/StringBuilder.h>
  12. #include <AK/StringView.h>
  13. #include <LibELF/Image.h>
  14. #include <LibELF/Validation.h>
  15. #include <limits.h>
  16. namespace ELF {
  17. Image::Image(ReadonlyBytes bytes, bool verbose_logging)
  18. : m_buffer(bytes.data())
  19. , m_size(bytes.size())
  20. , m_verbose_logging(verbose_logging)
  21. {
  22. parse();
  23. }
  24. Image::Image(const u8* buffer, size_t size, bool verbose_logging)
  25. : Image(ReadonlyBytes { buffer, size }, verbose_logging)
  26. {
  27. }
  28. Image::~Image()
  29. {
  30. }
  31. StringView Image::section_index_to_string(unsigned index) const
  32. {
  33. VERIFY(m_valid);
  34. if (index == SHN_UNDEF)
  35. return "Undefined"sv;
  36. if (index >= SHN_LORESERVE)
  37. return "Reserved"sv;
  38. return section(index).name();
  39. }
  40. unsigned Image::symbol_count() const
  41. {
  42. VERIFY(m_valid);
  43. if (!section_count())
  44. return 0;
  45. return section(m_symbol_table_section_index).entry_count();
  46. }
  47. void Image::dump() const
  48. {
  49. #if ELF_IMAGE_DEBUG
  50. dbgln("ELF::Image({:p}) {{", this);
  51. dbgln(" is_valid: {}", is_valid());
  52. if (!is_valid()) {
  53. dbgln("}}");
  54. return;
  55. }
  56. dbgln(" type: {}", ELF::Image::object_file_type_to_string(header().e_type).value_or("(?)"));
  57. dbgln(" machine: {}", header().e_machine);
  58. dbgln(" entry: {:x}", header().e_entry);
  59. dbgln(" shoff: {}", header().e_shoff);
  60. dbgln(" shnum: {}", header().e_shnum);
  61. dbgln(" phoff: {}", header().e_phoff);
  62. dbgln(" phnum: {}", header().e_phnum);
  63. dbgln(" shstrndx: {}", header().e_shstrndx);
  64. for_each_program_header([&](const ProgramHeader& program_header) {
  65. dbgln(" Program Header {}: {{", program_header.index());
  66. dbgln(" type: {:x}", program_header.type());
  67. dbgln(" offset: {:x}", program_header.offset());
  68. dbgln(" flags: {:x}", program_header.flags());
  69. dbgln(" }}");
  70. });
  71. for (unsigned i = 0; i < header().e_shnum; ++i) {
  72. const auto& section = this->section(i);
  73. dbgln(" Section {}: {{", i);
  74. dbgln(" name: {}", section.name());
  75. dbgln(" type: {:x}", section.type());
  76. dbgln(" offset: {:x}", section.offset());
  77. dbgln(" size: {}", section.size());
  78. dbgln(" ");
  79. dbgln(" }}");
  80. }
  81. dbgln("Symbol count: {} (table is {})", symbol_count(), m_symbol_table_section_index);
  82. for (unsigned i = 1; i < symbol_count(); ++i) {
  83. const auto& sym = symbol(i);
  84. dbgln("Symbol @{}:", i);
  85. dbgln(" Name: {}", sym.name());
  86. dbgln(" In section: {}", section_index_to_string(sym.section_index()));
  87. dbgln(" Value: {}", sym.value());
  88. dbgln(" Size: {}", sym.size());
  89. }
  90. dbgln("}}");
  91. #endif
  92. }
  93. unsigned Image::section_count() const
  94. {
  95. VERIFY(m_valid);
  96. return header().e_shnum;
  97. }
  98. unsigned Image::program_header_count() const
  99. {
  100. VERIFY(m_valid);
  101. return header().e_phnum;
  102. }
  103. bool Image::parse()
  104. {
  105. if (m_size < sizeof(ElfW(Ehdr)) || !validate_elf_header(header(), m_size, m_verbose_logging)) {
  106. if (m_verbose_logging)
  107. dbgln("ELF::Image::parse(): ELF Header not valid");
  108. m_valid = false;
  109. return false;
  110. }
  111. auto result_or_error = validate_program_headers(header(), m_size, { m_buffer, m_size }, nullptr, m_verbose_logging);
  112. if (result_or_error.is_error()) {
  113. if (m_verbose_logging)
  114. dbgln("ELF::Image::parse(): Failed validating ELF Program Headers");
  115. m_valid = false;
  116. return false;
  117. }
  118. if (!result_or_error.value()) {
  119. if (m_verbose_logging)
  120. dbgln("ELF::Image::parse(): ELF Program Headers not valid");
  121. m_valid = false;
  122. return false;
  123. }
  124. m_valid = true;
  125. // First locate the string tables.
  126. for (unsigned i = 0; i < section_count(); ++i) {
  127. auto& sh = section_header(i);
  128. if (sh.sh_type == SHT_SYMTAB) {
  129. if (m_symbol_table_section_index && m_symbol_table_section_index != i) {
  130. m_valid = false;
  131. return false;
  132. }
  133. m_symbol_table_section_index = i;
  134. }
  135. if (sh.sh_type == SHT_STRTAB && i != header().e_shstrndx) {
  136. if (section_header_table_string(sh.sh_name) == ELF_STRTAB)
  137. m_string_table_section_index = i;
  138. }
  139. }
  140. return m_valid;
  141. }
  142. StringView Image::table_string(unsigned table_index, unsigned offset) const
  143. {
  144. VERIFY(m_valid);
  145. auto& sh = section_header(table_index);
  146. if (sh.sh_type != SHT_STRTAB)
  147. return nullptr;
  148. size_t computed_offset = sh.sh_offset + offset;
  149. if (computed_offset >= m_size) {
  150. if (m_verbose_logging)
  151. dbgln("SHENANIGANS! Image::table_string() computed offset outside image.");
  152. return {};
  153. }
  154. size_t max_length = min(m_size - computed_offset, (size_t)PAGE_SIZE);
  155. size_t length = strnlen(raw_data(sh.sh_offset + offset), max_length);
  156. return { raw_data(sh.sh_offset + offset), length };
  157. }
  158. StringView Image::section_header_table_string(unsigned offset) const
  159. {
  160. VERIFY(m_valid);
  161. return table_string(header().e_shstrndx, offset);
  162. }
  163. StringView Image::table_string(unsigned offset) const
  164. {
  165. VERIFY(m_valid);
  166. return table_string(m_string_table_section_index, offset);
  167. }
  168. const char* Image::raw_data(unsigned offset) const
  169. {
  170. VERIFY(offset < m_size); // Callers must check indices into raw_data()'s result are also in bounds.
  171. return reinterpret_cast<const char*>(m_buffer) + offset;
  172. }
  173. const ElfW(Ehdr) & Image::header() const
  174. {
  175. VERIFY(m_size >= sizeof(ElfW(Ehdr)));
  176. return *reinterpret_cast<const ElfW(Ehdr)*>(raw_data(0));
  177. }
  178. const ElfW(Phdr) & Image::program_header_internal(unsigned index) const
  179. {
  180. VERIFY(m_valid);
  181. VERIFY(index < header().e_phnum);
  182. return *reinterpret_cast<const ElfW(Phdr)*>(raw_data(header().e_phoff + (index * sizeof(ElfW(Phdr)))));
  183. }
  184. const ElfW(Shdr) & Image::section_header(unsigned index) const
  185. {
  186. VERIFY(m_valid);
  187. VERIFY(index < header().e_shnum);
  188. return *reinterpret_cast<const ElfW(Shdr)*>(raw_data(header().e_shoff + (index * header().e_shentsize)));
  189. }
  190. Image::Symbol Image::symbol(unsigned index) const
  191. {
  192. VERIFY(m_valid);
  193. VERIFY(index < symbol_count());
  194. auto* raw_syms = reinterpret_cast<const ElfW(Sym)*>(raw_data(section(m_symbol_table_section_index).offset()));
  195. return Symbol(*this, index, raw_syms[index]);
  196. }
  197. Image::Section Image::section(unsigned index) const
  198. {
  199. VERIFY(m_valid);
  200. VERIFY(index < section_count());
  201. return Section(*this, index);
  202. }
  203. Image::ProgramHeader Image::program_header(unsigned index) const
  204. {
  205. VERIFY(m_valid);
  206. VERIFY(index < program_header_count());
  207. return ProgramHeader(*this, index);
  208. }
  209. Image::Relocation Image::RelocationSection::relocation(unsigned index) const
  210. {
  211. VERIFY(index < relocation_count());
  212. auto* rels = reinterpret_cast<const ElfW(Rel)*>(m_image.raw_data(offset()));
  213. return Relocation(m_image, rels[index]);
  214. }
  215. Optional<Image::RelocationSection> Image::Section::relocations() const
  216. {
  217. StringBuilder builder;
  218. builder.append(".rel"sv);
  219. builder.append(name());
  220. auto relocation_section = m_image.lookup_section(builder.string_view());
  221. if (!relocation_section.has_value())
  222. return {};
  223. dbgln_if(ELF_IMAGE_DEBUG, "Found relocations for {} in {}", name(), relocation_section.value().name());
  224. return static_cast<RelocationSection>(relocation_section.value());
  225. }
  226. Optional<Image::Section> Image::lookup_section(StringView name) const
  227. {
  228. VERIFY(m_valid);
  229. for (unsigned i = 0; i < section_count(); ++i) {
  230. auto section = this->section(i);
  231. if (section.name() == name)
  232. return section;
  233. }
  234. return {};
  235. }
  236. Optional<StringView> Image::object_file_type_to_string(ElfW(Half) type)
  237. {
  238. switch (type) {
  239. case ET_NONE:
  240. return "None"sv;
  241. case ET_REL:
  242. return "Relocatable"sv;
  243. case ET_EXEC:
  244. return "Executable"sv;
  245. case ET_DYN:
  246. return "Shared object"sv;
  247. case ET_CORE:
  248. return "Core"sv;
  249. default:
  250. return {};
  251. }
  252. }
  253. Optional<StringView> Image::object_machine_type_to_string(ElfW(Half) type)
  254. {
  255. switch (type) {
  256. case ET_NONE:
  257. return "None"sv;
  258. case EM_M32:
  259. return "AT&T WE 32100"sv;
  260. case EM_SPARC:
  261. return "SPARC"sv;
  262. case EM_386:
  263. return "Intel 80386"sv;
  264. case EM_68K:
  265. return "Motorola 68000"sv;
  266. case EM_88K:
  267. return "Motorola 88000"sv;
  268. case EM_486:
  269. return "Intel 80486"sv;
  270. case EM_860:
  271. return "Intel 80860"sv;
  272. case EM_MIPS:
  273. return "MIPS R3000 Big-Endian only"sv;
  274. case EM_X86_64:
  275. return "x86_64"sv;
  276. default:
  277. return {};
  278. }
  279. }
  280. Optional<StringView> Image::object_abi_type_to_string(Elf_Byte type)
  281. {
  282. switch (type) {
  283. case ELFOSABI_SYSV:
  284. return "SYSV"sv;
  285. case ELFOSABI_HPUX:
  286. return "HP-UX"sv;
  287. case ELFOSABI_NETBSD:
  288. return "NetBSD"sv;
  289. case ELFOSABI_LINUX:
  290. return "Linux"sv;
  291. case ELFOSABI_HURD:
  292. return "GNU Hurd"sv;
  293. case ELFOSABI_86OPEN:
  294. return "86Open"sv;
  295. case ELFOSABI_SOLARIS:
  296. return "Solaris"sv;
  297. case ELFOSABI_MONTEREY:
  298. return "AIX"sv;
  299. case ELFOSABI_IRIX:
  300. return "IRIX"sv;
  301. case ELFOSABI_FREEBSD:
  302. return "FreeBSD"sv;
  303. case ELFOSABI_TRU64:
  304. return "Tru64"sv;
  305. case ELFOSABI_MODESTO:
  306. return "Novell Modesto"sv;
  307. case ELFOSABI_OPENBSD:
  308. return "OpenBSD"sv;
  309. case ELFOSABI_ARM:
  310. return "ARM"sv;
  311. case ELFOSABI_STANDALONE:
  312. return "Standalone"sv;
  313. default:
  314. return {};
  315. }
  316. }
  317. StringView Image::Symbol::raw_data() const
  318. {
  319. auto section = this->section();
  320. return { section.raw_data() + (value() - section.address()), size() };
  321. }
  322. #ifndef KERNEL
  323. Optional<Image::Symbol> Image::find_demangled_function(StringView name) const
  324. {
  325. Optional<Image::Symbol> found;
  326. for_each_symbol([&](const Image::Symbol& symbol) {
  327. if (symbol.type() != STT_FUNC)
  328. return IterationDecision::Continue;
  329. if (symbol.is_undefined())
  330. return IterationDecision::Continue;
  331. auto demangled = demangle(symbol.name());
  332. auto index_of_paren = demangled.find('(');
  333. if (index_of_paren.has_value()) {
  334. demangled = demangled.substring(0, index_of_paren.value());
  335. }
  336. if (demangled != name)
  337. return IterationDecision::Continue;
  338. found = symbol;
  339. return IterationDecision::Break;
  340. });
  341. return found;
  342. }
  343. #endif
  344. Image::SortedSymbol* Image::find_sorted_symbol(FlatPtr address) const
  345. {
  346. if (m_sorted_symbols.is_empty())
  347. sort_symbols();
  348. size_t index = 0;
  349. binary_search(m_sorted_symbols, nullptr, &index, [&address](auto, auto& candidate) {
  350. if (address < candidate.address)
  351. return -1;
  352. else if (address > candidate.address)
  353. return 1;
  354. else
  355. return 0;
  356. });
  357. // FIXME: The error path here feels strange, index == 0 means error but what about symbol #0?
  358. if (index == 0)
  359. return nullptr;
  360. return &m_sorted_symbols[index];
  361. }
  362. Optional<Image::Symbol> Image::find_symbol(FlatPtr address, u32* out_offset) const
  363. {
  364. auto symbol_count = this->symbol_count();
  365. if (!symbol_count)
  366. return {};
  367. auto* symbol = find_sorted_symbol(address);
  368. if (!symbol)
  369. return {};
  370. if (out_offset)
  371. *out_offset = address - symbol->address;
  372. return symbol->symbol;
  373. }
  374. NEVER_INLINE void Image::sort_symbols() const
  375. {
  376. m_sorted_symbols.ensure_capacity(symbol_count());
  377. for_each_symbol([this](const auto& symbol) {
  378. m_sorted_symbols.append({ symbol.value(), symbol.name(), {}, symbol });
  379. });
  380. quick_sort(m_sorted_symbols, [](auto& a, auto& b) {
  381. return a.address < b.address;
  382. });
  383. }
  384. #ifndef KERNEL
  385. String Image::symbolicate(FlatPtr address, u32* out_offset) const
  386. {
  387. auto symbol_count = this->symbol_count();
  388. if (!symbol_count) {
  389. if (out_offset)
  390. *out_offset = 0;
  391. return "??";
  392. }
  393. auto* symbol = find_sorted_symbol(address);
  394. if (!symbol) {
  395. if (out_offset)
  396. *out_offset = 0;
  397. return "??";
  398. }
  399. auto& demangled_name = symbol->demangled_name;
  400. if (demangled_name.is_null())
  401. demangled_name = demangle(symbol->name);
  402. if (out_offset) {
  403. *out_offset = address - symbol->address;
  404. return demangled_name;
  405. }
  406. return String::formatted("{} +{:#x}", demangled_name, address - symbol->address);
  407. }
  408. #endif
  409. } // end namespace ELF