1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef COURGETTE_DISASSEMBLER_ELF_32_H_
6#define COURGETTE_DISASSEMBLER_ELF_32_H_
7
8#include "base/basictypes.h"
9#include "base/memory/scoped_vector.h"
10#include "courgette/assembly_program.h"
11#include "courgette/disassembler.h"
12#include "courgette/memory_allocator.h"
13#include "courgette/types_elf.h"
14
15namespace courgette {
16
17class AssemblyProgram;
18
19// A courgette disassembler for 32-bit ELF files.  This class is only a
20// partial implementation.  Subclasses implement the
21// architecture-specific parts of processing 32-bit ELF files.  Specifically,
22// RelToRVA processes entries in ELF relocation table,
23// ParseRelocationSection verifies the organization of the ELF
24// relocation table, and ParseRel32RelocsFromSection finds branch
25// targets by looking for relative jump/call opcodes in the particular
26// architecture's machine code.
27class DisassemblerElf32 : public Disassembler {
28 public:
29  // Different instructions encode the target rva differently.  This
30  // class encapsulates this behavior.  public for use in unit tests.
31  class TypedRVA {
32   public:
33    explicit TypedRVA(RVA rva) : rva_(rva), offset_(static_cast<size_t>(-1)) {
34    }
35
36    virtual ~TypedRVA() { };
37
38    RVA rva() {
39      return rva_;
40    }
41
42    RVA relative_target() {
43      return relative_target_;
44    }
45
46    void set_relative_target(RVA relative_target) {
47      relative_target_ = relative_target;
48    }
49
50    size_t get_offset() {
51      return offset_;
52    }
53
54    void set_offset(size_t offset) {
55      offset_ = offset;
56    }
57
58    // Computes the relative jump's offset from the op in p.
59    virtual CheckBool ComputeRelativeTarget(const uint8* op_pointer) = 0;
60
61    // Emits the courgette instruction corresponding to the RVA type.
62    virtual CheckBool EmitInstruction(AssemblyProgram* program,
63                                      RVA target_rva) = 0;
64
65    virtual uint16 op_size() const = 0;
66
67    static bool IsLessThan(TypedRVA *a, TypedRVA *b) {
68      return a->rva() < b->rva();
69    }
70
71  private:
72    const RVA rva_;
73    RVA relative_target_;
74    size_t offset_;
75  };
76
77 public:
78  explicit DisassemblerElf32(const void* start, size_t length);
79
80  virtual ~DisassemblerElf32() { };
81
82  virtual ExecutableType kind() = 0;
83
84  virtual e_machine_values ElfEM() = 0;
85
86  // Returns 'true' if the buffer appears to point to a valid ELF executable
87  // for 32 bit. If ParseHeader() succeeds, other member
88  // functions may be called.
89  virtual bool ParseHeader();
90
91  virtual bool Disassemble(AssemblyProgram* target);
92
93  // Public for unittests only
94  std::vector<RVA> &Abs32Locations() { return abs32_locations_; }
95  ScopedVector<TypedRVA> &Rel32Locations() { return rel32_locations_; }
96
97 protected:
98
99  uint32 DiscoverLength();
100
101  // Misc Section Helpers
102
103  Elf32_Half SectionHeaderCount() const {
104    return section_header_table_size_;
105  }
106
107  const Elf32_Shdr *SectionHeader(int id) const {
108    assert(id >= 0 && id < SectionHeaderCount());
109    return section_header_table_ + id;
110  }
111
112  const uint8 *SectionBody(int id) const {
113    return OffsetToPointer(SectionHeader(id)->sh_offset);
114  }
115
116  Elf32_Word SectionBodySize(int id) const {
117    return SectionHeader(id)->sh_size;
118  }
119
120  // Misc Segment Helpers
121
122  Elf32_Half ProgramSegmentHeaderCount() const {
123    return program_header_table_size_;
124  }
125
126  const Elf32_Phdr *ProgramSegmentHeader(int id) const {
127    assert(id >= 0 && id < ProgramSegmentHeaderCount());
128    return program_header_table_ + id;
129  }
130
131  // The virtual memory address at which this program segment will be loaded
132  Elf32_Addr ProgramSegmentMemoryBegin(int id) const {
133    return ProgramSegmentHeader(id)->p_vaddr;
134  }
135
136  // The number of virtual memory bytes for this program segment
137  Elf32_Word ProgramSegmentMemorySize(int id) const {
138    return ProgramSegmentHeader(id)->p_memsz;
139  }
140
141  // Pointer into the source file for this program segment
142  Elf32_Addr ProgramSegmentFileOffset(int id) const {
143    return ProgramSegmentHeader(id)->p_offset;
144  }
145
146  // Number of file bytes for this program segment. Is <= ProgramMemorySize.
147  Elf32_Word ProgramSegmentFileSize(int id) const {
148    return ProgramSegmentHeader(id)->p_filesz;
149  }
150
151  // Misc address space helpers
152
153  CheckBool IsValidRVA(RVA rva) const WARN_UNUSED_RESULT;
154
155  // Convert an ELF relocation struction into an RVA
156  virtual CheckBool RelToRVA(Elf32_Rel rel, RVA* result)
157    const WARN_UNUSED_RESULT = 0;
158
159  // Returns kNoOffset if there is no file offset corresponding to 'rva'.
160  CheckBool RVAToFileOffset(RVA rva, size_t* result) const WARN_UNUSED_RESULT;
161
162  RVA FileOffsetToRVA(size_t offset) const WARN_UNUSED_RESULT;
163
164  CheckBool RVAsToOffsets(std::vector<RVA>* rvas /*in*/,
165                          std::vector<size_t>* offsets /*out*/);
166
167  CheckBool RVAsToOffsets(ScopedVector<TypedRVA>* rvas /*in and out*/);
168
169  // Parsing Code used to really implement Disassemble
170
171  CheckBool ParseFile(AssemblyProgram* target) WARN_UNUSED_RESULT;
172  virtual CheckBool ParseRelocationSection(
173      const Elf32_Shdr *section_header,
174        AssemblyProgram* program) WARN_UNUSED_RESULT = 0;
175  CheckBool ParseProgbitsSection(
176      const Elf32_Shdr *section_header,
177      std::vector<size_t>::iterator* current_abs_offset,
178      std::vector<size_t>::iterator end_abs_offset,
179      ScopedVector<TypedRVA>::iterator* current_rel,
180      ScopedVector<TypedRVA>::iterator end_rel,
181      AssemblyProgram* program) WARN_UNUSED_RESULT;
182  CheckBool ParseSimpleRegion(size_t start_file_offset,
183                              size_t end_file_offset,
184                              AssemblyProgram* program) WARN_UNUSED_RESULT;
185
186  CheckBool ParseAbs32Relocs() WARN_UNUSED_RESULT;
187  CheckBool CheckSection(RVA rva) WARN_UNUSED_RESULT;
188  CheckBool ParseRel32RelocsFromSections() WARN_UNUSED_RESULT;
189  virtual CheckBool ParseRel32RelocsFromSection(
190      const Elf32_Shdr* section) WARN_UNUSED_RESULT = 0;
191
192  Elf32_Ehdr *header_;
193  Elf32_Shdr *section_header_table_;
194  Elf32_Half section_header_table_size_;
195
196  Elf32_Phdr *program_header_table_;
197  Elf32_Half program_header_table_size_;
198
199  // Section header for default
200  const char *default_string_section_;
201
202  std::vector<RVA> abs32_locations_;
203  ScopedVector<TypedRVA> rel32_locations_;
204
205  DISALLOW_COPY_AND_ASSIGN(DisassemblerElf32);
206};
207
208}  // namespace courgette
209
210#endif  // COURGETTE_DISASSEMBLER_ELF_32_H_
211