OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef CRAZY_LINKER_ELF_RELOCATIONS_H | 5 #ifndef CRAZY_LINKER_ELF_RELOCATIONS_H |
6 #define CRAZY_LINKER_ELF_RELOCATIONS_H | 6 #define CRAZY_LINKER_ELF_RELOCATIONS_H |
7 | 7 |
8 #include <string.h> | 8 #include <string.h> |
9 #include <unistd.h> | 9 #include <unistd.h> |
10 | 10 |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
57 size_t size); | 57 size_t size); |
58 | 58 |
59 private: | 59 private: |
60 bool ResolveSymbol(unsigned rel_type, | 60 bool ResolveSymbol(unsigned rel_type, |
61 unsigned rel_symbol, | 61 unsigned rel_symbol, |
62 const ElfSymbols* symbols, | 62 const ElfSymbols* symbols, |
63 SymbolResolver* resolver, | 63 SymbolResolver* resolver, |
64 ELF::Addr reloc, | 64 ELF::Addr reloc, |
65 ELF::Addr* sym_addr, | 65 ELF::Addr* sym_addr, |
66 Error* error); | 66 Error* error); |
| 67 bool ApplyResolvedRelaReloc(const ELF::Rela* rela, |
| 68 ELF::Addr sym_addr, |
| 69 bool resolved, |
| 70 Error* error); |
| 71 bool ApplyResolvedRelReloc(const ELF::Rel* rel, |
| 72 ELF::Addr sym_addr, |
| 73 bool resolved, |
| 74 Error* error); |
67 bool ApplyRelaReloc(const ELF::Rela* rela, | 75 bool ApplyRelaReloc(const ELF::Rela* rela, |
68 ELF::Addr sym_addr, | 76 const ElfSymbols* symbols, |
69 bool resolved, | 77 SymbolResolver* resolver, |
70 Error* error); | 78 Error* error); |
71 bool ApplyRelReloc(const ELF::Rel* rel, | 79 bool ApplyRelReloc(const ELF::Rel* rel, |
72 ELF::Addr sym_addr, | 80 const ElfSymbols* symbols, |
73 bool resolved, | 81 SymbolResolver* resolver, |
74 Error* error); | 82 Error* error); |
75 bool ApplyRelaRelocs(const ELF::Rela* relocs, | 83 bool ApplyRelaRelocs(const ELF::Rela* relocs, |
76 size_t relocs_count, | 84 size_t relocs_count, |
77 const ElfSymbols* symbols, | 85 const ElfSymbols* symbols, |
78 SymbolResolver* resolver, | 86 SymbolResolver* resolver, |
79 Error* error); | 87 Error* error); |
80 bool ApplyRelRelocs(const ELF::Rel* relocs, | 88 bool ApplyRelRelocs(const ELF::Rel* relocs, |
81 size_t relocs_count, | 89 size_t relocs_count, |
82 const ElfSymbols* symbols, | 90 const ElfSymbols* symbols, |
83 SymbolResolver* resolver, | 91 SymbolResolver* resolver, |
84 Error* error); | 92 Error* error); |
85 void AdjustRelocation(ELF::Word rel_type, | 93 void AdjustRelocation(ELF::Word rel_type, |
86 ELF::Addr src_reloc, | 94 ELF::Addr src_reloc, |
87 size_t dst_delta, | 95 size_t dst_delta, |
88 size_t map_delta); | 96 size_t map_delta); |
89 template<typename Rel> | 97 template<typename Rel> |
90 void RelocateRelocation(size_t src_addr, | 98 void RelocateRelocations(size_t src_addr, |
91 size_t dst_addr, | 99 size_t dst_addr, |
92 size_t map_addr, | 100 size_t map_addr, |
93 size_t size); | 101 size_t size); |
| 102 void AdjustAndroidRelocation(const ELF::Rela* relocation, |
| 103 size_t src_addr, |
| 104 size_t dst_addr, |
| 105 size_t map_addr, |
| 106 size_t size); |
94 | 107 |
95 #if defined(__arm__) || defined(__aarch64__) | 108 // Android packed relocations unpacker. Calls the given handler for |
96 // Packed relocations unpackers. Call the given handler for each | 109 // each relocation in the unpacking stream. |
97 // relocation in the unpacking stream. There are two versions, one | 110 typedef bool (*RelocationHandler)(ElfRelocations* relocations, |
98 // for REL, the other for RELA. | 111 const ELF::Rela* relocation, |
99 typedef bool (*RelRelocationHandler)(ElfRelocations* relocations, | 112 void* opaque); |
100 const ELF::Rel* relocation, | 113 bool ForEachAndroidRelocation(RelocationHandler handler, |
101 void* opaque); | 114 void* opaque); |
102 bool ForEachPackedRel(const uint8_t* packed_relocations, | |
103 RelRelocationHandler handler, | |
104 void* opaque); | |
105 | 115 |
106 typedef bool (*RelaRelocationHandler)(ElfRelocations* relocations, | 116 // Apply Android packed relocations. |
| 117 // On error, return false and set |error| message. |
| 118 // The static function is the ForEachAndroidRelocation() handler. |
| 119 bool ApplyAndroidRelocations(const ElfSymbols* symbols, |
| 120 SymbolResolver* resolver, |
| 121 Error* error); |
| 122 static bool ApplyAndroidRelocation(ElfRelocations* relocations, |
| 123 const ELF::Rela* relocation, |
| 124 void* opaque); |
| 125 |
| 126 // Relocate Android packed relocations. |
| 127 // The static function is the ForEachAndroidRelocation() handler. |
| 128 void RelocateAndroidRelocations(size_t src_addr, |
| 129 size_t dst_addr, |
| 130 size_t map_addr, |
| 131 size_t size); |
| 132 static bool RelocateAndroidRelocation(ElfRelocations* relocations, |
107 const ELF::Rela* relocation, | 133 const ELF::Rela* relocation, |
108 void* opaque); | 134 void* opaque); |
109 bool ForEachPackedRela(const uint8_t* packed_relocations, | |
110 RelaRelocationHandler handler, | |
111 void* opaque); | |
112 | |
113 // Apply packed REL and RELA relocations. On error, return false. | |
114 bool ApplyPackedRels(const uint8_t* packed_relocations, Error* error); | |
115 static bool ApplyPackedRel(ElfRelocations* relocations, | |
116 const ELF::Rel* relocation, | |
117 void* opaque); | |
118 bool ApplyPackedRelas(const uint8_t* packed_relocations, Error* error); | |
119 static bool ApplyPackedRela(ElfRelocations* relocations, | |
120 const ELF::Rela* relocation, | |
121 void* opaque); | |
122 | |
123 // Apply all packed relocations. | |
124 // On error, return false and set |error| message. No-op if no packed | |
125 // relocations are present. | |
126 bool ApplyPackedRelocations(Error* error); | |
127 | |
128 // Relocate packed REL and RELA relocations. | |
129 template<typename Rel> | |
130 static bool RelocatePackedRelocation(ElfRelocations* relocations, | |
131 const Rel* rel, | |
132 void* opaque); | |
133 | |
134 void RelocatePackedRels(const uint8_t* packed_relocations, | |
135 size_t src_addr, | |
136 size_t dst_addr, | |
137 size_t map_addr, | |
138 size_t size); | |
139 void RelocatePackedRelas(const uint8_t* packed_relocations, | |
140 size_t src_addr, | |
141 size_t dst_addr, | |
142 size_t map_addr, | |
143 size_t size); | |
144 | |
145 // Relocate all packed relocations. No-op if no packed relocations | |
146 // are present. | |
147 void RelocatePackedRelocations(size_t src_addr, | |
148 size_t dst_addr, | |
149 size_t map_addr, | |
150 size_t size); | |
151 #endif | |
152 | 135 |
153 #if defined(__mips__) | 136 #if defined(__mips__) |
154 bool RelocateMipsGot(const ElfSymbols* symbols, | 137 bool RelocateMipsGot(const ElfSymbols* symbols, |
155 SymbolResolver* resolver, | 138 SymbolResolver* resolver, |
156 Error* error); | 139 Error* error); |
157 #endif | 140 #endif |
158 | 141 |
159 const ELF::Phdr* phdr_; | 142 const ELF::Phdr* phdr_; |
160 size_t phdr_count_; | 143 size_t phdr_count_; |
161 size_t load_bias_; | 144 size_t load_bias_; |
162 | 145 |
163 ELF::Addr relocations_type_; | 146 ELF::Addr relocations_type_; |
164 ELF::Addr plt_relocations_; | 147 ELF::Addr plt_relocations_; |
165 size_t plt_relocations_size_; | 148 size_t plt_relocations_size_; |
166 ELF::Addr* plt_got_; | 149 ELF::Addr* plt_got_; |
167 | 150 |
168 ELF::Addr relocations_; | 151 ELF::Addr relocations_; |
169 size_t relocations_size_; | 152 size_t relocations_size_; |
170 | 153 |
171 #if defined(__mips__) | 154 #if defined(__mips__) |
172 // MIPS-specific relocation fields. | 155 // MIPS-specific relocation fields. |
173 ELF::Word mips_symtab_count_; | 156 ELF::Word mips_symtab_count_; |
174 ELF::Word mips_local_got_count_; | 157 ELF::Word mips_local_got_count_; |
175 ELF::Word mips_gotsym_; | 158 ELF::Word mips_gotsym_; |
176 #endif | 159 #endif |
177 | 160 |
178 #if defined(__arm__) || defined(__aarch64__) | 161 uint8_t* android_relocations_; |
179 uint8_t* packed_relocations_; | 162 size_t android_relocations_size_; |
180 #endif | |
181 | 163 |
182 bool has_text_relocations_; | 164 bool has_text_relocations_; |
183 bool has_symbolic_; | 165 bool has_symbolic_; |
184 }; | 166 }; |
185 | 167 |
186 } // namespace crazy | 168 } // namespace crazy |
187 | 169 |
188 #endif // CRAZY_LINKER_ELF_RELOCATIONS_H | 170 #endif // CRAZY_LINKER_ELF_RELOCATIONS_H |
OLD | NEW |