• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // -*- mode: c++ -*-
2 
3 // Copyright (c) 2011 Google Inc. All Rights Reserved.
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 //     * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 //     * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 //     * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 
31 // Original author: Ted Mielczarek <ted.mielczarek@gmail.com>
32 
33 #include "common/linux/elf_symbols_to_module.h"
34 
35 #include <cxxabi.h>
36 #include <elf.h>
37 #include <string.h>
38 
39 #include "common/byte_cursor.h"
40 #include "common/module.h"
41 
42 namespace google_breakpad {
43 
44 class ELFSymbolIterator {
45 public:
46   // The contents of an ELF symbol, adjusted for the host's endianness,
47   // word size, and so on. Corresponds to the data in Elf32_Sym / Elf64_Sym.
48   struct Symbol {
49     // True if this iterator has reached the end of the symbol array. When
50     // this is set, the other members of this structure are not valid.
51     bool at_end;
52 
53     // The number of this symbol within the list.
54     size_t index;
55 
56     // The current symbol's name offset. This is the offset within the
57     // string table.
58     size_t name_offset;
59 
60     // The current symbol's value, size, info and shndx fields.
61     uint64_t value;
62     uint64_t size;
63     unsigned char info;
64     uint16_t shndx;
65   };
66 
67   // Create an ELFSymbolIterator walking the symbols in BUFFER. Treat the
68   // symbols as big-endian if BIG_ENDIAN is true, as little-endian
69   // otherwise. Assume each symbol has a 'value' field whose size is
70   // VALUE_SIZE.
71   //
ELFSymbolIterator(const ByteBuffer * buffer,bool big_endian,size_t value_size)72   ELFSymbolIterator(const ByteBuffer *buffer, bool big_endian,
73                     size_t value_size)
74     : value_size_(value_size), cursor_(buffer, big_endian) {
75     // Actually, weird sizes could be handled just fine, but they're
76     // probably mistakes --- expressed in bits, say.
77     assert(value_size == 4 || value_size == 8);
78     symbol_.index = 0;
79     Fetch();
80   }
81 
82   // Move to the next symbol. This function's behavior is undefined if
83   // at_end() is true when it is called.
operator ++()84   ELFSymbolIterator &operator++() { Fetch(); symbol_.index++; return *this; }
85 
86   // Dereferencing this iterator produces a reference to an Symbol structure
87   // that holds the current symbol's values. The symbol is owned by this
88   // SymbolIterator, and will be invalidated at the next call to operator++.
operator *() const89   const Symbol &operator*() const { return symbol_; }
operator ->() const90   const Symbol *operator->() const { return &symbol_; }
91 
92 private:
93   // Read the symbol at cursor_, and set symbol_ appropriately.
Fetch()94   void Fetch() {
95     // Elf32_Sym and Elf64_Sym have different layouts.
96     unsigned char other;
97     if (value_size_ == 4) {
98       // Elf32_Sym
99       cursor_
100         .Read(4, false, &symbol_.name_offset)
101         .Read(4, false, &symbol_.value)
102         .Read(4, false, &symbol_.size)
103         .Read(1, false, &symbol_.info)
104         .Read(1, false, &other)
105         .Read(2, false, &symbol_.shndx);
106     } else {
107       // Elf64_Sym
108       cursor_
109         .Read(4, false, &symbol_.name_offset)
110         .Read(1, false, &symbol_.info)
111         .Read(1, false, &other)
112         .Read(2, false, &symbol_.shndx)
113         .Read(8, false, &symbol_.value)
114         .Read(8, false, &symbol_.size);
115     }
116     symbol_.at_end = !cursor_;
117   }
118 
119   // The size of symbols' value field, in bytes.
120   size_t value_size_;
121 
122   // A byte cursor traversing buffer_.
123   ByteCursor cursor_;
124 
125   // Values for the symbol this iterator refers to.
126   Symbol symbol_;
127 };
128 
SymbolString(ptrdiff_t offset,ByteBuffer & strings)129 const char *SymbolString(ptrdiff_t offset, ByteBuffer& strings) {
130   if (offset < 0 || (size_t) offset >= strings.Size()) {
131     // Return the null string.
132     offset = 0;
133   }
134   return reinterpret_cast<const char *>(strings.start + offset);
135 }
136 
ELFSymbolsToModule(const uint8_t * symtab_section,size_t symtab_size,const uint8_t * string_section,size_t string_size,const bool big_endian,size_t value_size,Module * module)137 bool ELFSymbolsToModule(const uint8_t *symtab_section,
138                         size_t symtab_size,
139                         const uint8_t *string_section,
140                         size_t string_size,
141                         const bool big_endian,
142                         size_t value_size,
143                         Module *module) {
144   ByteBuffer symbols(symtab_section, symtab_size);
145   // Ensure that the string section is null-terminated.
146   if (string_section[string_size - 1] != '\0') {
147     const void* null_terminator = memrchr(string_section, '\0', string_size);
148     string_size = reinterpret_cast<const uint8_t*>(null_terminator)
149       - string_section;
150   }
151   ByteBuffer strings(string_section, string_size);
152 
153   // The iterator walking the symbol table.
154   ELFSymbolIterator iterator(&symbols, big_endian, value_size);
155 
156   while(!iterator->at_end) {
157     if (ELF32_ST_TYPE(iterator->info) == STT_FUNC &&
158         iterator->shndx != SHN_UNDEF) {
159       Module::Extern *ext = new Module::Extern(iterator->value);
160       ext->name = SymbolString(iterator->name_offset, strings);
161 #if !defined(__ANDROID__)  // Android NDK doesn't provide abi::__cxa_demangle.
162       int status = 0;
163       char* demangled =
164           abi::__cxa_demangle(ext->name.c_str(), NULL, NULL, &status);
165       if (demangled) {
166         if (status == 0)
167           ext->name = demangled;
168         free(demangled);
169       }
170 #endif
171       module->AddExtern(ext);
172     }
173     ++iterator;
174   }
175   return true;
176 }
177 
178 }  // namespace google_breakpad
179