The Tor Browser / file comparison

comparison: tools/profiler/LulElf.cpp

tools/profiler/LulElf.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:1d974f89afaf
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3
4 // Copyright (c) 2006, 2011, 2012 Google Inc.
5 // All rights reserved.
6 //
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions are
9 // met:
10 //
11 // * Redistributions of source code must retain the above copyright
12 // notice, this list of conditions and the following disclaimer.
13 // * Redistributions in binary form must reproduce the above
14 // copyright notice, this list of conditions and the following disclaimer
15 // in the documentation and/or other materials provided with the
16 // distribution.
17 // * Neither the name of Google Inc. nor the names of its
18 // contributors may be used to endorse or promote products derived from
19 // this software without specific prior written permission.
20 //
21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32
33 // Restructured in 2009 by: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
34
35 // (derived from)
36 // dump_symbols.cc: implement google_breakpad::WriteSymbolFile:
37 // Find all the debugging info in a file and dump it as a Breakpad symbol file.
38 //
39 // dump_symbols.h: Read debugging information from an ELF file, and write
40 // it out as a Breakpad symbol file.
41
42 // This file is derived from the following files in
43 // toolkit/crashreporter/google-breakpad:
44 // src/common/linux/dump_symbols.cc
45 // src/common/linux/elfutils.cc
46 // src/common/linux/file_id.cc
47
48 #include <errno.h>
49 #include <fcntl.h>
50 #include <stdio.h>
51 #include <string.h>
52 #include <sys/mman.h>
53 #include <sys/stat.h>
54 #include <unistd.h>
55 #include <arpa/inet.h>
56
57 #include <set>
58 #include <string>
59 #include <vector>
60
61 #include "mozilla/Assertions.h"
62
63 #include "LulPlatformMacros.h"
64 #include "LulCommonExt.h"
65 #include "LulDwarfExt.h"
66 #if defined(LUL_PLAT_arm_android)
67 # include "LulExidxExt.h"
68 #endif
69 #include "LulElfInt.h"
70 #include "LulMainInt.h"
71
72
73 #if defined(LUL_PLAT_arm_android) && !defined(SHT_ARM_EXIDX)
74 // bionic and older glibsc don't define it
75 # define SHT_ARM_EXIDX (SHT_LOPROC + 1)
76 #endif
77
78
79 // This namespace contains helper functions.
80 namespace {
81
82 using lul::DwarfCFIToModule;
83 using lul::FindElfSectionByName;
84 using lul::GetOffset;
85 using lul::IsValidElf;
86 using lul::Module;
87 using lul::UniqueString;
88 using lul::scoped_ptr;
89 using lul::Summariser;
90 using std::string;
91 using std::vector;
92 using std::set;
93
94 //
95 // FDWrapper
96 //
97 // Wrapper class to make sure opened file is closed.
98 //
99 class FDWrapper {
100 public:
101 explicit FDWrapper(int fd) :
102 fd_(fd) {}
103 ~FDWrapper() {
104 if (fd_ != -1)
105 close(fd_);
106 }
107 int get() {
108 return fd_;
109 }
110 int release() {
111 int fd = fd_;
112 fd_ = -1;
113 return fd;
114 }
115 private:
116 int fd_;
117 };
118
119 //
120 // MmapWrapper
121 //
122 // Wrapper class to make sure mapped regions are unmapped.
123 //
124 class MmapWrapper {
125 public:
126 MmapWrapper() : is_set_(false) {}
127 ~MmapWrapper() {
128 if (is_set_ && base_ != NULL) {
129 MOZ_ASSERT(size_ > 0);
130 munmap(base_, size_);
131 }
132 }
133 void set(void *mapped_address, size_t mapped_size) {
134 is_set_ = true;
135 base_ = mapped_address;
136 size_ = mapped_size;
137 }
138 void release() {
139 MOZ_ASSERT(is_set_);
140 is_set_ = false;
141 base_ = NULL;
142 size_ = 0;
143 }
144
145 private:
146 bool is_set_;
147 void *base_;
148 size_t size_;
149 };
150
151
152 // Set NUM_DW_REGNAMES to be the number of Dwarf register names
153 // appropriate to the machine architecture given in HEADER. Return
154 // true on success, or false if HEADER's machine architecture is not
155 // supported.
156 template<typename ElfClass>
157 bool DwarfCFIRegisterNames(const typename ElfClass::Ehdr* elf_header,
158 unsigned int* num_dw_regnames) {
159 switch (elf_header->e_machine) {
160 case EM_386:
161 *num_dw_regnames = DwarfCFIToModule::RegisterNames::I386();
162 return true;
163 case EM_ARM:
164 *num_dw_regnames = DwarfCFIToModule::RegisterNames::ARM();
165 return true;
166 case EM_X86_64:
167 *num_dw_regnames = DwarfCFIToModule::RegisterNames::X86_64();
168 return true;
169 default:
170 MOZ_ASSERT(0);
171 return false;
172 }
173 }
174
175 template<typename ElfClass>
176 bool LoadDwarfCFI(const string& dwarf_filename,
177 const typename ElfClass::Ehdr* elf_header,
178 const char* section_name,
179 const typename ElfClass::Shdr* section,
180 const bool eh_frame,
181 const typename ElfClass::Shdr* got_section,
182 const typename ElfClass::Shdr* text_section,
183 const bool big_endian,
184 SecMap* smap,
185 uintptr_t text_bias,
186 void (*log)(const char*)) {
187 // Find the appropriate set of register names for this file's
188 // architecture.
189 unsigned int num_dw_regs = 0;
190 if (!DwarfCFIRegisterNames<ElfClass>(elf_header, &num_dw_regs)) {
191 fprintf(stderr, "%s: unrecognized ELF machine architecture '%d';"
192 " cannot convert DWARF call frame information\n",
193 dwarf_filename.c_str(), elf_header->e_machine);
194 return false;
195 }
196
197 const lul::Endianness endianness
198 = big_endian ? lul::ENDIANNESS_BIG : lul::ENDIANNESS_LITTLE;
199
200 // Find the call frame information and its size.
201 const char* cfi =
202 GetOffset<ElfClass, char>(elf_header, section->sh_offset);
203 size_t cfi_size = section->sh_size;
204
205 // Plug together the parser, handler, and their entourages.
206
207 // Here's a summariser, which will receive the output of the
208 // parser, create summaries, and add them to |smap|.
209 Summariser* summ = new Summariser(smap, text_bias, log);
210
211 DwarfCFIToModule::Reporter module_reporter(log, dwarf_filename, section_name);
212 DwarfCFIToModule handler(num_dw_regs, &module_reporter, summ);
213 lul::ByteReader byte_reader(endianness);
214
215 byte_reader.SetAddressSize(ElfClass::kAddrSize);
216
217 // Provide the base addresses for .eh_frame encoded pointers, if
218 // possible.
219 byte_reader.SetCFIDataBase(section->sh_addr, cfi);
220 if (got_section)
221 byte_reader.SetDataBase(got_section->sh_addr);
222 if (text_section)
223 byte_reader.SetTextBase(text_section->sh_addr);
224
225 lul::CallFrameInfo::Reporter dwarf_reporter(log, dwarf_filename,
226 section_name);
227 lul::CallFrameInfo parser(cfi, cfi_size,
228 &byte_reader, &handler, &dwarf_reporter,
229 eh_frame);
230 parser.Start();
231
232 delete summ;
233 return true;
234 }
235
236 #if defined(LUL_PLAT_arm_android)
237 template<typename ElfClass>
238 bool LoadARMexidx(const typename ElfClass::Ehdr* elf_header,
239 const typename ElfClass::Shdr* exidx_section,
240 const typename ElfClass::Shdr* extab_section,
241 uint32_t loading_addr,
242 uintptr_t text_bias,
243 SecMap* smap,
244 void (*log)(const char*)) {
245 // To do this properly we need to know:
246 // * the bounds of the .ARM.exidx section in the mapped image
247 // * the bounds of the .ARM.extab section in the mapped image
248 // * the vma of the last byte in the text section associated with the .exidx
249 // The first two are easy. The third is a bit tricky. If we can't
250 // figure out what it is, just pass in zero.
251 // Note that we are reading EXIDX directly out of the mapped in
252 // executable image. Unlike with the CFI reader, there is no
253 // auxiliary, temporary mapping used to read the unwind data.
254 //
255 // An .exidx section is always required, but the .extab section
256 // can be optionally omitted, provided that .exidx does not refer
257 // to it. If the .exidx is erroneous and does refer to .extab even
258 // though .extab is missing, the range checks done by GET_EX_U32 in
259 // ExceptionTableInfo::ExtabEntryExtract should prevent any invalid
260 // memory accesses, and cause the .extab to be rejected as invalid.
261 const char *exidx_img
262 = GetOffset<ElfClass, char>(elf_header, exidx_section->sh_offset);
263 size_t exidx_size = exidx_section->sh_size;
264 const char *extab_img
265 = extab_section
266 ? GetOffset<ElfClass, char>(elf_header, extab_section->sh_offset)
267 : nullptr;
268 size_t extab_size = extab_section ? extab_section->sh_size : 0;
269
270 // The sh_link field of the exidx section gives the section number
271 // for the associated text section.
272 uint32_t exidx_text_last_svma = 0;
273 int exidx_text_sno = exidx_section->sh_link;
274 typedef typename ElfClass::Shdr Shdr;
275 // |sections| points to the section header table
276 const Shdr* sections
277 = GetOffset<ElfClass, Shdr>(elf_header, elf_header->e_shoff);
278 const int num_sections = elf_header->e_shnum;
279 if (exidx_text_sno >= 0 && exidx_text_sno < num_sections) {
280 const Shdr* exidx_text_shdr = &sections[exidx_text_sno];
281 if (exidx_text_shdr->sh_size > 0) {
282 exidx_text_last_svma
283 = exidx_text_shdr->sh_addr + exidx_text_shdr->sh_size - 1;
284 }
285 }
286
287 lul::ARMExToModule handler(smap, log);
288 lul::ExceptionTableInfo
289 parser(exidx_img, exidx_size, extab_img, extab_size, exidx_text_last_svma,
290 &handler,
291 reinterpret_cast<const char*>(elf_header),
292 loading_addr, text_bias, log);
293 parser.Start();
294 return true;
295 }
296 #endif /* defined(LUL_PLAT_arm_android) */
297
298 bool LoadELF(const string& obj_file, MmapWrapper* map_wrapper,
299 void** elf_header) {
300 int obj_fd = open(obj_file.c_str(), O_RDONLY);
301 if (obj_fd < 0) {
302 fprintf(stderr, "Failed to open ELF file '%s': %s\n",
303 obj_file.c_str(), strerror(errno));
304 return false;
305 }
306 FDWrapper obj_fd_wrapper(obj_fd);
307 struct stat st;
308 if (fstat(obj_fd, &st) != 0 && st.st_size <= 0) {
309 fprintf(stderr, "Unable to fstat ELF file '%s': %s\n",
310 obj_file.c_str(), strerror(errno));
311 return false;
312 }
313 // Mapping it read-only is good enough. In any case, mapping it
314 // read-write confuses Valgrind's debuginfo acquire/discard
315 // heuristics, making it hard to profile the profiler.
316 void *obj_base = mmap(nullptr, st.st_size,
317 PROT_READ, MAP_PRIVATE, obj_fd, 0);
318 if (obj_base == MAP_FAILED) {
319 fprintf(stderr, "Failed to mmap ELF file '%s': %s\n",
320 obj_file.c_str(), strerror(errno));
321 return false;
322 }
323 map_wrapper->set(obj_base, st.st_size);
324 *elf_header = obj_base;
325 if (!IsValidElf(*elf_header)) {
326 fprintf(stderr, "Not a valid ELF file: %s\n", obj_file.c_str());
327 return false;
328 }
329 return true;
330 }
331
332 // Get the endianness of ELF_HEADER. If it's invalid, return false.
333 template<typename ElfClass>
334 bool ElfEndianness(const typename ElfClass::Ehdr* elf_header,
335 bool* big_endian) {
336 if (elf_header->e_ident[EI_DATA] == ELFDATA2LSB) {
337 *big_endian = false;
338 return true;
339 }
340 if (elf_header->e_ident[EI_DATA] == ELFDATA2MSB) {
341 *big_endian = true;
342 return true;
343 }
344
345 fprintf(stderr, "bad data encoding in ELF header: %d\n",
346 elf_header->e_ident[EI_DATA]);
347 return false;
348 }
349
350 //
351 // LoadSymbolsInfo
352 //
353 // Holds the state between the two calls to LoadSymbols() in case it's necessary
354 // to follow the .gnu_debuglink section and load debug information from a
355 // different file.
356 //
357 template<typename ElfClass>
358 class LoadSymbolsInfo {
359 public:
360 typedef typename ElfClass::Addr Addr;
361
362 explicit LoadSymbolsInfo(const vector<string>& dbg_dirs) :
363 debug_dirs_(dbg_dirs),
364 has_loading_addr_(false) {}
365
366 // Keeps track of which sections have been loaded so sections don't
367 // accidentally get loaded twice from two different files.
368 void LoadedSection(const string &section) {
369 if (loaded_sections_.count(section) == 0) {
370 loaded_sections_.insert(section);
371 } else {
372 fprintf(stderr, "Section %s has already been loaded.\n",
373 section.c_str());
374 }
375 }
376
377 string debuglink_file() const {
378 return debuglink_file_;
379 }
380
381 private:
382 const vector<string>& debug_dirs_; // Directories in which to
383 // search for the debug ELF file.
384
385 string debuglink_file_; // Full path to the debug ELF file.
386
387 bool has_loading_addr_; // Indicate if LOADING_ADDR_ is valid.
388
389 set<string> loaded_sections_; // Tracks the Loaded ELF sections
390 // between calls to LoadSymbols().
391 };
392
393 // Find the preferred loading address of the binary.
394 template<typename ElfClass>
395 typename ElfClass::Addr GetLoadingAddress(
396 const typename ElfClass::Phdr* program_headers,
397 int nheader) {
398 typedef typename ElfClass::Phdr Phdr;
399
400 // For non-PIC executables (e_type == ET_EXEC), the load address is
401 // the start address of the first PT_LOAD segment. (ELF requires
402 // the segments to be sorted by load address.) For PIC executables
403 // and dynamic libraries (e_type == ET_DYN), this address will
404 // normally be zero.
405 for (int i = 0; i < nheader; ++i) {
406 const Phdr& header = program_headers[i];
407 if (header.p_type == PT_LOAD)
408 return header.p_vaddr;
409 }
410 return 0;
411 }
412
413 template<typename ElfClass>
414 bool LoadSymbols(const string& obj_file,
415 const bool big_endian,
416 const typename ElfClass::Ehdr* elf_header,
417 const bool read_gnu_debug_link,
418 LoadSymbolsInfo<ElfClass>* info,
419 SecMap* smap,
420 void* rx_avma,
421 void (*log)(const char*)) {
422 typedef typename ElfClass::Phdr Phdr;
423 typedef typename ElfClass::Shdr Shdr;
424
425 char buf[500];
426 snprintf(buf, sizeof(buf), "LoadSymbols: BEGIN %s\n", obj_file.c_str());
427 buf[sizeof(buf)-1] = 0;
428 log(buf);
429
430 // This is how the text bias is calculated.
431 // BEGIN CALCULATE BIAS
432 uintptr_t loading_addr = GetLoadingAddress<ElfClass>(
433 GetOffset<ElfClass, Phdr>(elf_header, elf_header->e_phoff),
434 elf_header->e_phnum);
435 uintptr_t text_bias = ((uintptr_t)rx_avma) - loading_addr;
436 snprintf(buf, sizeof(buf),
437 "LoadSymbols: rx_avma=%llx, text_bias=%llx",
438 (unsigned long long int)(uintptr_t)rx_avma,
439 (unsigned long long int)text_bias);
440 buf[sizeof(buf)-1] = 0;
441 log(buf);
442 // END CALCULATE BIAS
443
444 const Shdr* sections =
445 GetOffset<ElfClass, Shdr>(elf_header, elf_header->e_shoff);
446 const Shdr* section_names = sections + elf_header->e_shstrndx;
447 const char* names =
448 GetOffset<ElfClass, char>(elf_header, section_names->sh_offset);
449 const char *names_end = names + section_names->sh_size;
450 bool found_usable_info = false;
451
452 // Dwarf Call Frame Information (CFI) is actually independent from
453 // the other DWARF debugging information, and can be used alone.
454 const Shdr* dwarf_cfi_section =
455 FindElfSectionByName<ElfClass>(".debug_frame", SHT_PROGBITS,
456 sections, names, names_end,
457 elf_header->e_shnum);
458 if (dwarf_cfi_section) {
459 // Ignore the return value of this function; even without call frame
460 // information, the other debugging information could be perfectly
461 // useful.
462 info->LoadedSection(".debug_frame");
463 bool result =
464 LoadDwarfCFI<ElfClass>(obj_file, elf_header, ".debug_frame",
465 dwarf_cfi_section, false, 0, 0, big_endian,
466 smap, text_bias, log);
467 found_usable_info = found_usable_info || result;
468 if (result)
469 log("LoadSymbols: read CFI from .debug_frame");
470 }
471
472 // Linux C++ exception handling information can also provide
473 // unwinding data.
474 const Shdr* eh_frame_section =
475 FindElfSectionByName<ElfClass>(".eh_frame", SHT_PROGBITS,
476 sections, names, names_end,
477 elf_header->e_shnum);
478 if (eh_frame_section) {
479 // Pointers in .eh_frame data may be relative to the base addresses of
480 // certain sections. Provide those sections if present.
481 const Shdr* got_section =
482 FindElfSectionByName<ElfClass>(".got", SHT_PROGBITS,
483 sections, names, names_end,
484 elf_header->e_shnum);
485 const Shdr* text_section =
486 FindElfSectionByName<ElfClass>(".text", SHT_PROGBITS,
487 sections, names, names_end,
488 elf_header->e_shnum);
489 info->LoadedSection(".eh_frame");
490 // As above, ignore the return value of this function.
491 bool result =
492 LoadDwarfCFI<ElfClass>(obj_file, elf_header, ".eh_frame",
493 eh_frame_section, true,
494 got_section, text_section, big_endian,
495 smap, text_bias, log);
496 found_usable_info = found_usable_info || result;
497 if (result)
498 log("LoadSymbols: read CFI from .eh_frame");
499 }
500
501 # if defined(LUL_PLAT_arm_android)
502 // ARM has special unwind tables that can be used. .exidx is
503 // always required, and .extab is normally required, but may
504 // be omitted if it is empty. See comments on LoadARMexidx()
505 // for more details.
506 const Shdr* arm_exidx_section =
507 FindElfSectionByName<ElfClass>(".ARM.exidx", SHT_ARM_EXIDX,
508 sections, names, names_end,
509 elf_header->e_shnum);
510 const Shdr* arm_extab_section =
511 FindElfSectionByName<ElfClass>(".ARM.extab", SHT_PROGBITS,
512 sections, names, names_end,
513 elf_header->e_shnum);
514 const Shdr* debug_info_section =
515 FindElfSectionByName<ElfClass>(".debug_info", SHT_PROGBITS,
516 sections, names, names_end,
517 elf_header->e_shnum);
518 // Only load information from this section if there isn't a .debug_info
519 // section.
520 if (!debug_info_section && arm_exidx_section) {
521 info->LoadedSection(".ARM.exidx");
522 if (arm_extab_section)
523 info->LoadedSection(".ARM.extab");
524 bool result = LoadARMexidx<ElfClass>(elf_header,
525 arm_exidx_section, arm_extab_section,
526 loading_addr, text_bias, smap, log);
527 found_usable_info = found_usable_info || result;
528 if (result)
529 log("LoadSymbols: read EXIDX from .ARM.{exidx,extab}");
530 }
531 # endif /* defined(LUL_PLAT_arm_android) */
532
533 snprintf(buf, sizeof(buf), "LoadSymbols: END %s\n", obj_file.c_str());
534 buf[sizeof(buf)-1] = 0;
535 log(buf);
536
537 return found_usable_info;
538 }
539
540 // Return the breakpad symbol file identifier for the architecture of
541 // ELF_HEADER.
542 template<typename ElfClass>
543 const char* ElfArchitecture(const typename ElfClass::Ehdr* elf_header) {
544 typedef typename ElfClass::Half Half;
545 Half arch = elf_header->e_machine;
546 switch (arch) {
547 case EM_386: return "x86";
548 case EM_ARM: return "arm";
549 case EM_MIPS: return "mips";
550 case EM_PPC64: return "ppc64";
551 case EM_PPC: return "ppc";
552 case EM_S390: return "s390";
553 case EM_SPARC: return "sparc";
554 case EM_SPARCV9: return "sparcv9";
555 case EM_X86_64: return "x86_64";
556 default: return NULL;
557 }
558 }
559
560 // Format the Elf file identifier in IDENTIFIER as a UUID with the
561 // dashes removed.
562 string FormatIdentifier(unsigned char identifier[16]) {
563 char identifier_str[40];
564 lul::FileID::ConvertIdentifierToString(
565 identifier,
566 identifier_str,
567 sizeof(identifier_str));
568 string id_no_dash;
569 for (int i = 0; identifier_str[i] != '\0'; ++i)
570 if (identifier_str[i] != '-')
571 id_no_dash += identifier_str[i];
572 // Add an extra "0" by the end. PDB files on Windows have an 'age'
573 // number appended to the end of the file identifier; this isn't
574 // really used or necessary on other platforms, but be consistent.
575 id_no_dash += '0';
576 return id_no_dash;
577 }
578
579 // Return the non-directory portion of FILENAME: the portion after the
580 // last slash, or the whole filename if there are no slashes.
581 string BaseFileName(const string &filename) {
582 // Lots of copies! basename's behavior is less than ideal.
583 char *c_filename = strdup(filename.c_str());
584 string base = basename(c_filename);
585 free(c_filename);
586 return base;
587 }
588
589 template<typename ElfClass>
590 bool ReadSymbolDataElfClass(const typename ElfClass::Ehdr* elf_header,
591 const string& obj_filename,
592 const vector<string>& debug_dirs,
593 SecMap* smap, void* rx_avma,
594 void (*log)(const char*)) {
595 typedef typename ElfClass::Ehdr Ehdr;
596
597 unsigned char identifier[16];
598 if (!lul
599 ::FileID::ElfFileIdentifierFromMappedFile(elf_header, identifier)) {
600 fprintf(stderr, "%s: unable to generate file identifier\n",
601 obj_filename.c_str());
602 return false;
603 }
604
605 const char *architecture = ElfArchitecture<ElfClass>(elf_header);
606 if (!architecture) {
607 fprintf(stderr, "%s: unrecognized ELF machine architecture: %d\n",
608 obj_filename.c_str(), elf_header->e_machine);
609 return false;
610 }
611
612 // Figure out what endianness this file is.
613 bool big_endian;
614 if (!ElfEndianness<ElfClass>(elf_header, &big_endian))
615 return false;
616
617 string name = BaseFileName(obj_filename);
618 string os = "Linux";
619 string id = FormatIdentifier(identifier);
620
621 LoadSymbolsInfo<ElfClass> info(debug_dirs);
622 if (!LoadSymbols<ElfClass>(obj_filename, big_endian, elf_header,
623 !debug_dirs.empty(), &info,
624 smap, rx_avma, log)) {
625 const string debuglink_file = info.debuglink_file();
626 if (debuglink_file.empty())
627 return false;
628
629 // Load debuglink ELF file.
630 fprintf(stderr, "Found debugging info in %s\n", debuglink_file.c_str());
631 MmapWrapper debug_map_wrapper;
632 Ehdr* debug_elf_header = NULL;
633 if (!LoadELF(debuglink_file, &debug_map_wrapper,
634 reinterpret_cast<void**>(&debug_elf_header)))
635 return false;
636 // Sanity checks to make sure everything matches up.
637 const char *debug_architecture =
638 ElfArchitecture<ElfClass>(debug_elf_header);
639 if (!debug_architecture) {
640 fprintf(stderr, "%s: unrecognized ELF machine architecture: %d\n",
641 debuglink_file.c_str(), debug_elf_header->e_machine);
642 return false;
643 }
644 if (strcmp(architecture, debug_architecture)) {
645 fprintf(stderr, "%s with ELF machine architecture %s does not match "
646 "%s with ELF architecture %s\n",
647 debuglink_file.c_str(), debug_architecture,
648 obj_filename.c_str(), architecture);
649 return false;
650 }
651
652 bool debug_big_endian;
653 if (!ElfEndianness<ElfClass>(debug_elf_header, &debug_big_endian))
654 return false;
655 if (debug_big_endian != big_endian) {
656 fprintf(stderr, "%s and %s does not match in endianness\n",
657 obj_filename.c_str(), debuglink_file.c_str());
658 return false;
659 }
660
661 if (!LoadSymbols<ElfClass>(debuglink_file, debug_big_endian,
662 debug_elf_header, false, &info,
663 smap, rx_avma, log)) {
664 return false;
665 }
666 }
667
668 return true;
669 }
670
671 } // namespace (anon)
672
673
674 namespace lul {
675
676 bool ReadSymbolDataInternal(const uint8_t* obj_file,
677 const string& obj_filename,
678 const vector<string>& debug_dirs,
679 SecMap* smap, void* rx_avma,
680 void (*log)(const char*)) {
681
682 if (!IsValidElf(obj_file)) {
683 fprintf(stderr, "Not a valid ELF file: %s\n", obj_filename.c_str());
684 return false;
685 }
686
687 int elfclass = ElfClass(obj_file);
688 if (elfclass == ELFCLASS32) {
689 return ReadSymbolDataElfClass<ElfClass32>(
690 reinterpret_cast<const Elf32_Ehdr*>(obj_file),
691 obj_filename, debug_dirs, smap, rx_avma, log);
692 }
693 if (elfclass == ELFCLASS64) {
694 return ReadSymbolDataElfClass<ElfClass64>(
695 reinterpret_cast<const Elf64_Ehdr*>(obj_file),
696 obj_filename, debug_dirs, smap, rx_avma, log);
697 }
698
699 return false;
700 }
701
702 bool ReadSymbolData(const string& obj_file,
703 const vector<string>& debug_dirs,
704 SecMap* smap, void* rx_avma,
705 void (*log)(const char*)) {
706 MmapWrapper map_wrapper;
707 void* elf_header = NULL;
708 if (!LoadELF(obj_file, &map_wrapper, &elf_header))
709 return false;
710
711 return ReadSymbolDataInternal(reinterpret_cast<uint8_t*>(elf_header),
712 obj_file, debug_dirs, smap, rx_avma, log);
713 }
714
715
716 namespace {
717
718 template<typename ElfClass>
719 void FindElfClassSection(const char *elf_base,
720 const char *section_name,
721 typename ElfClass::Word section_type,
722 const void **section_start,
723 int *section_size) {
724 typedef typename ElfClass::Ehdr Ehdr;
725 typedef typename ElfClass::Shdr Shdr;
726
727 MOZ_ASSERT(elf_base);
728 MOZ_ASSERT(section_start);
729 MOZ_ASSERT(section_size);
730
731 MOZ_ASSERT(strncmp(elf_base, ELFMAG, SELFMAG) == 0);
732
733 const Ehdr* elf_header = reinterpret_cast<const Ehdr*>(elf_base);
734 MOZ_ASSERT(elf_header->e_ident[EI_CLASS] == ElfClass::kClass);
735
736 const Shdr* sections =
737 GetOffset<ElfClass,Shdr>(elf_header, elf_header->e_shoff);
738 const Shdr* section_names = sections + elf_header->e_shstrndx;
739 const char* names =
740 GetOffset<ElfClass,char>(elf_header, section_names->sh_offset);
741 const char *names_end = names + section_names->sh_size;
742
743 const Shdr* section =
744 FindElfSectionByName<ElfClass>(section_name, section_type,
745 sections, names, names_end,
746 elf_header->e_shnum);
747
748 if (section != NULL && section->sh_size > 0) {
749 *section_start = elf_base + section->sh_offset;
750 *section_size = section->sh_size;
751 }
752 }
753
754 template<typename ElfClass>
755 void FindElfClassSegment(const char *elf_base,
756 typename ElfClass::Word segment_type,
757 const void **segment_start,
758 int *segment_size) {
759 typedef typename ElfClass::Ehdr Ehdr;
760 typedef typename ElfClass::Phdr Phdr;
761
762 MOZ_ASSERT(elf_base);
763 MOZ_ASSERT(segment_start);
764 MOZ_ASSERT(segment_size);
765
766 MOZ_ASSERT(strncmp(elf_base, ELFMAG, SELFMAG) == 0);
767
768 const Ehdr* elf_header = reinterpret_cast<const Ehdr*>(elf_base);
769 MOZ_ASSERT(elf_header->e_ident[EI_CLASS] == ElfClass::kClass);
770
771 const Phdr* phdrs =
772 GetOffset<ElfClass,Phdr>(elf_header, elf_header->e_phoff);
773
774 for (int i = 0; i < elf_header->e_phnum; ++i) {
775 if (phdrs[i].p_type == segment_type) {
776 *segment_start = elf_base + phdrs[i].p_offset;
777 *segment_size = phdrs[i].p_filesz;
778 return;
779 }
780 }
781 }
782
783 } // namespace (anon)
784
785 bool IsValidElf(const void* elf_base) {
786 return strncmp(reinterpret_cast<const char*>(elf_base),
787 ELFMAG, SELFMAG) == 0;
788 }
789
790 int ElfClass(const void* elf_base) {
791 const ElfW(Ehdr)* elf_header =
792 reinterpret_cast<const ElfW(Ehdr)*>(elf_base);
793
794 return elf_header->e_ident[EI_CLASS];
795 }
796
797 bool FindElfSection(const void *elf_mapped_base,
798 const char *section_name,
799 uint32_t section_type,
800 const void **section_start,
801 int *section_size,
802 int *elfclass) {
803 MOZ_ASSERT(elf_mapped_base);
804 MOZ_ASSERT(section_start);
805 MOZ_ASSERT(section_size);
806
807 *section_start = NULL;
808 *section_size = 0;
809
810 if (!IsValidElf(elf_mapped_base))
811 return false;
812
813 int cls = ElfClass(elf_mapped_base);
814 if (elfclass) {
815 *elfclass = cls;
816 }
817
818 const char* elf_base =
819 static_cast<const char*>(elf_mapped_base);
820
821 if (cls == ELFCLASS32) {
822 FindElfClassSection<ElfClass32>(elf_base, section_name, section_type,
823 section_start, section_size);
824 return *section_start != NULL;
825 } else if (cls == ELFCLASS64) {
826 FindElfClassSection<ElfClass64>(elf_base, section_name, section_type,
827 section_start, section_size);
828 return *section_start != NULL;
829 }
830
831 return false;
832 }
833
834 bool FindElfSegment(const void *elf_mapped_base,
835 uint32_t segment_type,
836 const void **segment_start,
837 int *segment_size,
838 int *elfclass) {
839 MOZ_ASSERT(elf_mapped_base);
840 MOZ_ASSERT(segment_start);
841 MOZ_ASSERT(segment_size);
842
843 *segment_start = NULL;
844 *segment_size = 0;
845
846 if (!IsValidElf(elf_mapped_base))
847 return false;
848
849 int cls = ElfClass(elf_mapped_base);
850 if (elfclass) {
851 *elfclass = cls;
852 }
853
854 const char* elf_base =
855 static_cast<const char*>(elf_mapped_base);
856
857 if (cls == ELFCLASS32) {
858 FindElfClassSegment<ElfClass32>(elf_base, segment_type,
859 segment_start, segment_size);
860 return *segment_start != NULL;
861 } else if (cls == ELFCLASS64) {
862 FindElfClassSegment<ElfClass64>(elf_base, segment_type,
863 segment_start, segment_size);
864 return *segment_start != NULL;
865 }
866
867 return false;
868 }
869
870
871 // (derived from)
872 // file_id.cc: Return a unique identifier for a file
873 //
874 // See file_id.h for documentation
875 //
876
877 // ELF note name and desc are 32-bits word padded.
878 #define NOTE_PADDING(a) ((a + 3) & ~3)
879
880 // These functions are also used inside the crashed process, so be safe
881 // and use the syscall/libc wrappers instead of direct syscalls or libc.
882
883 template<typename ElfClass>
884 static bool ElfClassBuildIDNoteIdentifier(const void *section, int length,
885 uint8_t identifier[kMDGUIDSize]) {
886 typedef typename ElfClass::Nhdr Nhdr;
887
888 const void* section_end = reinterpret_cast<const char*>(section) + length;
889 const Nhdr* note_header = reinterpret_cast<const Nhdr*>(section);
890 while (reinterpret_cast<const void *>(note_header) < section_end) {
891 if (note_header->n_type == NT_GNU_BUILD_ID)
892 break;
893 note_header = reinterpret_cast<const Nhdr*>(
894 reinterpret_cast<const char*>(note_header) + sizeof(Nhdr) +
895 NOTE_PADDING(note_header->n_namesz) +
896 NOTE_PADDING(note_header->n_descsz));
897 }
898 if (reinterpret_cast<const void *>(note_header) >= section_end ||
899 note_header->n_descsz == 0) {
900 return false;
901 }
902
903 const char* build_id = reinterpret_cast<const char*>(note_header) +
904 sizeof(Nhdr) + NOTE_PADDING(note_header->n_namesz);
905 // Copy as many bits of the build ID as will fit
906 // into the GUID space.
907 memset(identifier, 0, kMDGUIDSize);
908 memcpy(identifier, build_id,
909 std::min(kMDGUIDSize, (size_t)note_header->n_descsz));
910
911 return true;
912 }
913
914 // Attempt to locate a .note.gnu.build-id section in an ELF binary
915 // and copy as many bytes of it as will fit into |identifier|.
916 static bool FindElfBuildIDNote(const void *elf_mapped_base,
917 uint8_t identifier[kMDGUIDSize]) {
918 void* note_section;
919 int note_size, elfclass;
920 if ((!FindElfSegment(elf_mapped_base, PT_NOTE,
921 (const void**)&note_section, &note_size, &elfclass) ||
922 note_size == 0) &&
923 (!FindElfSection(elf_mapped_base, ".note.gnu.build-id", SHT_NOTE,
924 (const void**)&note_section, &note_size, &elfclass) ||
925 note_size == 0)) {
926 return false;
927 }
928
929 if (elfclass == ELFCLASS32) {
930 return ElfClassBuildIDNoteIdentifier<ElfClass32>(note_section, note_size,
931 identifier);
932 } else if (elfclass == ELFCLASS64) {
933 return ElfClassBuildIDNoteIdentifier<ElfClass64>(note_section, note_size,
934 identifier);
935 }
936
937 return false;
938 }
939
940 // Attempt to locate the .text section of an ELF binary and generate
941 // a simple hash by XORing the first page worth of bytes into |identifier|.
942 static bool HashElfTextSection(const void *elf_mapped_base,
943 uint8_t identifier[kMDGUIDSize]) {
944 void* text_section;
945 int text_size;
946 if (!FindElfSection(elf_mapped_base, ".text", SHT_PROGBITS,
947 (const void**)&text_section, &text_size, NULL) ||
948 text_size == 0) {
949 return false;
950 }
951
952 memset(identifier, 0, kMDGUIDSize);
953 const uint8_t* ptr = reinterpret_cast<const uint8_t*>(text_section);
954 const uint8_t* ptr_end = ptr + std::min(text_size, 4096);
955 while (ptr < ptr_end) {
956 for (unsigned i = 0; i < kMDGUIDSize; i++)
957 identifier[i] ^= ptr[i];
958 ptr += kMDGUIDSize;
959 }
960 return true;
961 }
962
963 // static
964 bool FileID::ElfFileIdentifierFromMappedFile(const void* base,
965 uint8_t identifier[kMDGUIDSize]) {
966 // Look for a build id note first.
967 if (FindElfBuildIDNote(base, identifier))
968 return true;
969
970 // Fall back on hashing the first page of the text section.
971 return HashElfTextSection(base, identifier);
972 }
973
974 // static
975 void FileID::ConvertIdentifierToString(const uint8_t identifier[kMDGUIDSize],
976 char* buffer, int buffer_length) {
977 uint8_t identifier_swapped[kMDGUIDSize];
978
979 // Endian-ness swap to match dump processor expectation.
980 memcpy(identifier_swapped, identifier, kMDGUIDSize);
981 uint32_t* data1 = reinterpret_cast<uint32_t*>(identifier_swapped);
982 *data1 = htonl(*data1);
983 uint16_t* data2 = reinterpret_cast<uint16_t*>(identifier_swapped + 4);
984 *data2 = htons(*data2);
985 uint16_t* data3 = reinterpret_cast<uint16_t*>(identifier_swapped + 6);
986 *data3 = htons(*data3);
987
988 int buffer_idx = 0;
989 for (unsigned int idx = 0;
990 (buffer_idx < buffer_length) && (idx < kMDGUIDSize);
991 ++idx) {
992 int hi = (identifier_swapped[idx] >> 4) & 0x0F;
993 int lo = (identifier_swapped[idx]) & 0x0F;
994
995 if (idx == 4 || idx == 6 || idx == 8 || idx == 10)
996 buffer[buffer_idx++] = '-';
997
998 buffer[buffer_idx++] = (hi >= 10) ? 'A' + hi - 10 : '0' + hi;
999 buffer[buffer_idx++] = (lo >= 10) ? 'A' + lo - 10 : '0' + lo;
1000 }
1001
1002 // NULL terminate
1003 buffer[(buffer_idx < buffer_length) ? buffer_idx : buffer_idx - 1] = 0;
1004 }
1005
1006 } // namespace lul

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial