ObjectFileELF.h revision 269024 
1//===-- ObjectFileELF.h --------------------------------------- -*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef liblldb_ObjectFileELF_h_
11#define liblldb_ObjectFileELF_h_
12
13#include <stdint.h>
14#include <vector>
15
16#include "lldb/lldb-private.h"
17#include "lldb/Host/FileSpec.h"
18#include "lldb/Symbol/ObjectFile.h"
19#include "lldb/Core/UUID.h"
20
21#include "ELFHeader.h"
22
23struct ELFNote
24{
25    elf::elf_word n_namesz;
26    elf::elf_word n_descsz;
27    elf::elf_word n_type;
28
29    std::string n_name;
30
31    ELFNote() : n_namesz(0), n_descsz(0), n_type(0)
32    {
33    }
34
35    /// Parse an ELFNote entry from the given DataExtractor starting at position
36    /// \p offset.
37    ///
38    /// @param[in] data
39    ///    The DataExtractor to read from.
40    ///
41    /// @param[in,out] offset
42    ///    Pointer to an offset in the data.  On return the offset will be
43    ///    advanced by the number of bytes read.
44    ///
45    /// @return
46    ///    True if the ELFRel entry was successfully read and false otherwise.
47    bool
48    Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
49};
50
51//------------------------------------------------------------------------------
52/// @class ObjectFileELF
53/// @brief Generic ELF object file reader.
54///
55/// This class provides a generic ELF (32/64 bit) reader plugin implementing the
56/// ObjectFile protocol.
57class ObjectFileELF :
58    public lldb_private::ObjectFile
59{
60public:
61    //------------------------------------------------------------------
62    // Static Functions
63    //------------------------------------------------------------------
64    static void
65    Initialize();
66
67    static void
68    Terminate();
69
70    static lldb_private::ConstString
71    GetPluginNameStatic();
72
73    static const char *
74    GetPluginDescriptionStatic();
75
76    static lldb_private::ObjectFile *
77    CreateInstance(const lldb::ModuleSP &module_sp,
78                   lldb::DataBufferSP& data_sp,
79                   lldb::offset_t data_offset,
80                   const lldb_private::FileSpec* file,
81                   lldb::offset_t file_offset,
82                   lldb::offset_t length);
83
84    static lldb_private::ObjectFile *
85    CreateMemoryInstance (const lldb::ModuleSP &module_sp,
86                          lldb::DataBufferSP& data_sp,
87                          const lldb::ProcessSP &process_sp,
88                          lldb::addr_t header_addr);
89
90    static size_t
91    GetModuleSpecifications (const lldb_private::FileSpec& file,
92                             lldb::DataBufferSP& data_sp,
93                             lldb::offset_t data_offset,
94                             lldb::offset_t file_offset,
95                             lldb::offset_t length,
96                             lldb_private::ModuleSpecList &specs);
97
98    static bool
99    MagicBytesMatch (lldb::DataBufferSP& data_sp,
100                     lldb::addr_t offset,
101                     lldb::addr_t length);
102
103    //------------------------------------------------------------------
104    // PluginInterface protocol
105    //------------------------------------------------------------------
106    virtual lldb_private::ConstString
107    GetPluginName();
108
109    virtual uint32_t
110    GetPluginVersion();
111
112    //------------------------------------------------------------------
113    // ObjectFile Protocol.
114    //------------------------------------------------------------------
115    virtual
116    ~ObjectFileELF();
117
118    virtual bool
119    ParseHeader();
120
121    virtual bool
122    SetLoadAddress (lldb_private::Target &target,
123                    lldb::addr_t value,
124                    bool value_is_offset);
125
126    virtual lldb::ByteOrder
127    GetByteOrder() const;
128
129    virtual bool
130    IsExecutable () const;
131
132    virtual uint32_t
133    GetAddressByteSize() const;
134
135    virtual lldb_private::Symtab *
136    GetSymtab();
137
138    virtual lldb_private::Symbol *
139    ResolveSymbolForAddress(const lldb_private::Address& so_addr, bool verify_unique);
140
141    virtual bool
142    IsStripped ();
143
144    virtual void
145    CreateSections (lldb_private::SectionList &unified_section_list);
146
147    virtual void
148    Dump(lldb_private::Stream *s);
149
150    virtual bool
151    GetArchitecture (lldb_private::ArchSpec &arch);
152
153    virtual bool
154    GetUUID(lldb_private::UUID* uuid);
155
156    virtual lldb_private::FileSpecList
157    GetDebugSymbolFilePaths();
158
159    virtual uint32_t
160    GetDependentModules(lldb_private::FileSpecList& files);
161
162    virtual lldb_private::Address
163    GetImageInfoAddress(lldb_private::Target *target);
164
165    virtual lldb_private::Address
166    GetEntryPointAddress ();
167
168    virtual ObjectFile::Type
169    CalculateType();
170
171    virtual ObjectFile::Strata
172    CalculateStrata();
173
174    // Returns number of program headers found in the ELF file.
175    size_t
176    GetProgramHeaderCount();
177
178    // Returns the program header with the given index.
179    const elf::ELFProgramHeader *
180    GetProgramHeaderByIndex(lldb::user_id_t id);
181
182    // Returns segment data for the given index.
183    lldb_private::DataExtractor
184    GetSegmentDataByIndex(lldb::user_id_t id);
185
186private:
187    ObjectFileELF(const lldb::ModuleSP &module_sp,
188                  lldb::DataBufferSP& data_sp,
189                  lldb::offset_t data_offset,
190                  const lldb_private::FileSpec* file,
191                  lldb::offset_t offset,
192                  lldb::offset_t length);
193
194    typedef std::vector<elf::ELFProgramHeader>  ProgramHeaderColl;
195    typedef ProgramHeaderColl::iterator         ProgramHeaderCollIter;
196    typedef ProgramHeaderColl::const_iterator   ProgramHeaderCollConstIter;
197
198    struct ELFSectionHeaderInfo : public elf::ELFSectionHeader
199    {
200        lldb_private::ConstString section_name;
201    };
202    typedef std::vector<ELFSectionHeaderInfo>   SectionHeaderColl;
203    typedef SectionHeaderColl::iterator         SectionHeaderCollIter;
204    typedef SectionHeaderColl::const_iterator   SectionHeaderCollConstIter;
205
206    typedef std::vector<elf::ELFDynamic>        DynamicSymbolColl;
207    typedef DynamicSymbolColl::iterator         DynamicSymbolCollIter;
208    typedef DynamicSymbolColl::const_iterator   DynamicSymbolCollConstIter;
209
210    /// Version of this reader common to all plugins based on this class.
211    static const uint32_t m_plugin_version = 1;
212
213    /// ELF file header.
214    elf::ELFHeader m_header;
215
216    /// ELF build ID.
217    lldb_private::UUID m_uuid;
218
219    /// ELF .gnu_debuglink file and crc data if available.
220    std::string m_gnu_debuglink_file;
221    uint32_t m_gnu_debuglink_crc;
222
223    /// Collection of program headers.
224    ProgramHeaderColl m_program_headers;
225
226    /// Collection of section headers.
227    SectionHeaderColl m_section_headers;
228
229    /// Collection of symbols from the dynamic table.
230    DynamicSymbolColl m_dynamic_symbols;
231
232    /// List of file specifications corresponding to the modules (shared
233    /// libraries) on which this object file depends.
234    mutable std::unique_ptr<lldb_private::FileSpecList> m_filespec_ap;
235
236    /// Cached value of the entry point for this module.
237    lldb_private::Address  m_entry_point_address;
238
239    /// Returns a 1 based index of the given section header.
240    size_t
241    SectionIndex(const SectionHeaderCollIter &I);
242
243    /// Returns a 1 based index of the given section header.
244    size_t
245    SectionIndex(const SectionHeaderCollConstIter &I) const;
246
247    /// Parses all section headers present in this object file and populates
248    /// m_program_headers.  This method will compute the header list only once.
249    /// Returns the number of headers parsed.
250    size_t
251    ParseProgramHeaders();
252
253    /// Parses all section headers present in this object file and populates
254    /// m_section_headers.  This method will compute the header list only once.
255    /// Returns the number of headers parsed.
256    size_t
257    ParseSectionHeaders();
258
259    /// Parses the elf section headers and returns the uuid, debug link name, crc.
260    static size_t
261    GetSectionHeaderInfo(SectionHeaderColl &section_headers,
262                         lldb_private::DataExtractor &data,
263                         const elf::ELFHeader &header,
264                         lldb_private::UUID &uuid,
265                         std::string &gnu_debuglink_file,
266                         uint32_t &gnu_debuglink_crc);
267
268    /// Scans the dynamic section and locates all dependent modules (shared
269    /// libraries) populating m_filespec_ap.  This method will compute the
270    /// dependent module list only once.  Returns the number of dependent
271    /// modules parsed.
272    size_t
273    ParseDependentModules();
274
275    /// Parses the dynamic symbol table and populates m_dynamic_symbols.  The
276    /// vector retains the order as found in the object file.  Returns the
277    /// number of dynamic symbols parsed.
278    size_t
279    ParseDynamicSymbols();
280
281    /// Populates m_symtab_ap will all non-dynamic linker symbols.  This method
282    /// will parse the symbols only once.  Returns the number of symbols parsed.
283    unsigned
284    ParseSymbolTable(lldb_private::Symtab *symbol_table,
285                     lldb::user_id_t start_id,
286                     lldb_private::Section *symtab);
287
288    /// Helper routine for ParseSymbolTable().
289    unsigned
290    ParseSymbols(lldb_private::Symtab *symbol_table,
291                 lldb::user_id_t start_id,
292                 lldb_private::SectionList *section_list,
293                 const size_t num_symbols,
294                 const lldb_private::DataExtractor &symtab_data,
295                 const lldb_private::DataExtractor &strtab_data);
296
297    /// Scans the relocation entries and adds a set of artificial symbols to the
298    /// given symbol table for each PLT slot.  Returns the number of symbols
299    /// added.
300    unsigned
301    ParseTrampolineSymbols(lldb_private::Symtab *symbol_table,
302                           lldb::user_id_t start_id,
303                           const ELFSectionHeaderInfo *rela_hdr,
304                           lldb::user_id_t section_id);
305
306    /// Returns the section header with the given id or NULL.
307    const ELFSectionHeaderInfo *
308    GetSectionHeaderByIndex(lldb::user_id_t id);
309
310    /// @name  ELF header dump routines
311    //@{
312    static void
313    DumpELFHeader(lldb_private::Stream *s, const elf::ELFHeader& header);
314
315    static void
316    DumpELFHeader_e_ident_EI_DATA(lldb_private::Stream *s,
317                                  unsigned char ei_data);
318
319    static void
320    DumpELFHeader_e_type(lldb_private::Stream *s, elf::elf_half e_type);
321    //@}
322
323    /// @name ELF program header dump routines
324    //@{
325    void
326    DumpELFProgramHeaders(lldb_private::Stream *s);
327
328    static void
329    DumpELFProgramHeader(lldb_private::Stream *s,
330                         const elf::ELFProgramHeader &ph);
331
332    static void
333    DumpELFProgramHeader_p_type(lldb_private::Stream *s, elf::elf_word p_type);
334
335    static void
336    DumpELFProgramHeader_p_flags(lldb_private::Stream *s,
337                                 elf::elf_word p_flags);
338    //@}
339
340    /// @name ELF section header dump routines
341    //@{
342    void
343    DumpELFSectionHeaders(lldb_private::Stream *s);
344
345    static void
346    DumpELFSectionHeader(lldb_private::Stream *s,
347                         const ELFSectionHeaderInfo& sh);
348
349    static void
350    DumpELFSectionHeader_sh_type(lldb_private::Stream *s,
351                                 elf::elf_word sh_type);
352
353    static void
354    DumpELFSectionHeader_sh_flags(lldb_private::Stream *s,
355                                  elf::elf_xword sh_flags);
356    //@}
357
358    /// ELF dependent module dump routine.
359    void
360    DumpDependentModules(lldb_private::Stream *s);
361
362    const elf::ELFDynamic *
363    FindDynamicSymbol(unsigned tag);
364
365    unsigned
366    PLTRelocationType();
367};
368
369#endif // #ifndef liblldb_ObjectFileELF_h_
370