1 /*
2  * Copyright (C) 2012 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "elf_file.h"
18 
19 #include <inttypes.h>
20 #include <sys/mman.h>  // For the PROT_* and MAP_* constants.
21 #include <sys/types.h>
22 #include <unistd.h>
23 
24 #include "android-base/stringprintf.h"
25 #include "android-base/strings.h"
26 
27 #include "arch/instruction_set.h"
28 #include "base/leb128.h"
29 #include "base/stl_util.h"
30 #include "base/unix_file/fd_file.h"
31 #include "base/utils.h"
32 #include "elf/elf_utils.h"
33 #include "elf_file_impl.h"
34 
35 namespace art {
36 
37 using android::base::StringPrintf;
38 
39 template <typename ElfTypes>
ElfFileImpl(File * file,bool writable,bool program_header_only)40 ElfFileImpl<ElfTypes>::ElfFileImpl(File* file, bool writable, bool program_header_only)
41   : writable_(writable),
42     program_header_only_(program_header_only),
43     header_(nullptr),
44     base_address_(nullptr),
45     program_headers_start_(nullptr),
46     section_headers_start_(nullptr),
47     dynamic_program_header_(nullptr),
48     dynamic_section_start_(nullptr),
49     symtab_section_start_(nullptr),
50     dynsym_section_start_(nullptr),
51     strtab_section_start_(nullptr),
52     dynstr_section_start_(nullptr),
53     hash_section_start_(nullptr),
54     symtab_symbol_table_(nullptr),
55     dynsym_symbol_table_(nullptr) {
56   CHECK(file != nullptr);
57 }
58 
59 template <typename ElfTypes>
Open(File * file,bool writable,bool program_header_only,bool low_4gb,std::string * error_msg)60 ElfFileImpl<ElfTypes>* ElfFileImpl<ElfTypes>::Open(File* file,
61                                                    bool writable,
62                                                    bool program_header_only,
63                                                    bool low_4gb,
64                                                    std::string* error_msg) {
65   std::unique_ptr<ElfFileImpl<ElfTypes>> elf_file(
66       new ElfFileImpl<ElfTypes>(file, writable, program_header_only));
67   int prot;
68   int flags;
69   if (writable) {
70     prot = PROT_READ | PROT_WRITE;
71     flags = MAP_SHARED;
72   } else {
73     prot = PROT_READ;
74     flags = MAP_PRIVATE;
75   }
76   if (!elf_file->Setup(file, prot, flags, low_4gb, error_msg)) {
77     return nullptr;
78   }
79   return elf_file.release();
80 }
81 
82 template <typename ElfTypes>
Open(File * file,int prot,int flags,bool low_4gb,std::string * error_msg)83 ElfFileImpl<ElfTypes>* ElfFileImpl<ElfTypes>::Open(File* file,
84                                                    int prot,
85                                                    int flags,
86                                                    bool low_4gb,
87                                                    std::string* error_msg) {
88   std::unique_ptr<ElfFileImpl<ElfTypes>> elf_file(
89       new ElfFileImpl<ElfTypes>(file, (prot & PROT_WRITE) != 0, /* program_header_only= */ false));
90   if (!elf_file->Setup(file, prot, flags, low_4gb, error_msg)) {
91     return nullptr;
92   }
93   return elf_file.release();
94 }
95 
96 template <typename ElfTypes>
Setup(File * file,int prot,int flags,bool low_4gb,std::string * error_msg)97 bool ElfFileImpl<ElfTypes>::Setup(File* file,
98                                   int prot,
99                                   int flags,
100                                   bool low_4gb,
101                                   std::string* error_msg) {
102   int64_t temp_file_length = file->GetLength();
103   if (temp_file_length < 0) {
104     errno = -temp_file_length;
105     *error_msg = StringPrintf("Failed to get length of file: '%s' fd=%d: %s",
106                               file->GetPath().c_str(), file->Fd(), strerror(errno));
107     return false;
108   }
109   size_t file_length = static_cast<size_t>(temp_file_length);
110   if (file_length < sizeof(Elf_Ehdr)) {
111     *error_msg = StringPrintf("File size of %zd bytes not large enough to contain ELF header of "
112                               "%zd bytes: '%s'", file_length, sizeof(Elf_Ehdr),
113                               file->GetPath().c_str());
114     return false;
115   }
116 
117   if (program_header_only_) {
118     // first just map ELF header to get program header size information
119     size_t elf_header_size = sizeof(Elf_Ehdr);
120     if (!SetMap(file,
121                 MemMap::MapFile(elf_header_size,
122                                 prot,
123                                 flags,
124                                 file->Fd(),
125                                 0,
126                                 low_4gb,
127                                 file->GetPath().c_str(),
128                                 error_msg),
129                 error_msg)) {
130       return false;
131     }
132     // then remap to cover program header
133     size_t program_header_size = header_->e_phoff + (header_->e_phentsize * header_->e_phnum);
134     if (file_length < program_header_size) {
135       *error_msg = StringPrintf("File size of %zd bytes not large enough to contain ELF program "
136                                 "header of %zd bytes: '%s'", file_length,
137                                 sizeof(Elf_Ehdr), file->GetPath().c_str());
138       return false;
139     }
140     if (!SetMap(file,
141                 MemMap::MapFile(program_header_size,
142                                 prot,
143                                 flags,
144                                 file->Fd(),
145                                 0,
146                                 low_4gb,
147                                 file->GetPath().c_str(),
148                                 error_msg),
149                 error_msg)) {
150       *error_msg = StringPrintf("Failed to map ELF program headers: %s", error_msg->c_str());
151       return false;
152     }
153   } else {
154     // otherwise map entire file
155     if (!SetMap(file,
156                 MemMap::MapFile(file->GetLength(),
157                                 prot,
158                                 flags,
159                                 file->Fd(),
160                                 0,
161                                 low_4gb,
162                                 file->GetPath().c_str(),
163                                 error_msg),
164                 error_msg)) {
165       *error_msg = StringPrintf("Failed to map ELF file: %s", error_msg->c_str());
166       return false;
167     }
168   }
169 
170   if (program_header_only_) {
171     program_headers_start_ = Begin() + GetHeader().e_phoff;
172   } else {
173     if (!CheckAndSet(GetHeader().e_phoff, "program headers", &program_headers_start_, error_msg)) {
174       return false;
175     }
176 
177     // Setup section headers.
178     if (!CheckAndSet(GetHeader().e_shoff, "section headers", &section_headers_start_, error_msg)) {
179       return false;
180     }
181 
182     // Find shstrtab.
183     Elf_Shdr* shstrtab_section_header = GetSectionNameStringSection();
184     if (shstrtab_section_header == nullptr) {
185       *error_msg = StringPrintf("Failed to find shstrtab section header in ELF file: '%s'",
186                                 file->GetPath().c_str());
187       return false;
188     }
189 
190     // Find .dynamic section info from program header
191     dynamic_program_header_ = FindProgamHeaderByType(PT_DYNAMIC);
192     if (dynamic_program_header_ == nullptr) {
193       *error_msg = StringPrintf("Failed to find PT_DYNAMIC program header in ELF file: '%s'",
194                                 file->GetPath().c_str());
195       return false;
196     }
197 
198     if (!CheckAndSet(GetDynamicProgramHeader().p_offset, "dynamic section",
199                      reinterpret_cast<uint8_t**>(&dynamic_section_start_), error_msg)) {
200       return false;
201     }
202 
203     // Find other sections from section headers
204     for (Elf_Word i = 0; i < GetSectionHeaderNum(); i++) {
205       Elf_Shdr* section_header = GetSectionHeader(i);
206       if (section_header == nullptr) {
207         *error_msg = StringPrintf("Failed to find section header for section %d in ELF file: '%s'",
208                                   i, file->GetPath().c_str());
209         return false;
210       }
211       switch (section_header->sh_type) {
212         case SHT_SYMTAB: {
213           if (!CheckAndSet(section_header->sh_offset, "symtab",
214                            reinterpret_cast<uint8_t**>(&symtab_section_start_), error_msg)) {
215             return false;
216           }
217           break;
218         }
219         case SHT_DYNSYM: {
220           if (!CheckAndSet(section_header->sh_offset, "dynsym",
221                            reinterpret_cast<uint8_t**>(&dynsym_section_start_), error_msg)) {
222             return false;
223           }
224           break;
225         }
226         case SHT_STRTAB: {
227           // TODO: base these off of sh_link from .symtab and .dynsym above
228           if ((section_header->sh_flags & SHF_ALLOC) != 0) {
229             // Check that this is named ".dynstr" and ignore otherwise.
230             const char* header_name = GetString(*shstrtab_section_header, section_header->sh_name);
231             if (strncmp(".dynstr", header_name, 8) == 0) {
232               if (!CheckAndSet(section_header->sh_offset, "dynstr",
233                                reinterpret_cast<uint8_t**>(&dynstr_section_start_), error_msg)) {
234                 return false;
235               }
236             }
237           } else {
238             // Check that this is named ".strtab" and ignore otherwise.
239             const char* header_name = GetString(*shstrtab_section_header, section_header->sh_name);
240             if (strncmp(".strtab", header_name, 8) == 0) {
241               if (!CheckAndSet(section_header->sh_offset, "strtab",
242                                reinterpret_cast<uint8_t**>(&strtab_section_start_), error_msg)) {
243                 return false;
244               }
245             }
246           }
247           break;
248         }
249         case SHT_DYNAMIC: {
250           if (reinterpret_cast<uint8_t*>(dynamic_section_start_) !=
251               Begin() + section_header->sh_offset) {
252             LOG(WARNING) << "Failed to find matching SHT_DYNAMIC for PT_DYNAMIC in "
253                          << file->GetPath() << ": " << std::hex
254                          << reinterpret_cast<void*>(dynamic_section_start_)
255                          << " != " << reinterpret_cast<void*>(Begin() + section_header->sh_offset);
256             return false;
257           }
258           break;
259         }
260         case SHT_HASH: {
261           if (!CheckAndSet(section_header->sh_offset, "hash section",
262                            reinterpret_cast<uint8_t**>(&hash_section_start_), error_msg)) {
263             return false;
264           }
265           break;
266         }
267       }
268     }
269 
270     // Check for the existence of some sections.
271     if (!CheckSectionsExist(file, error_msg)) {
272       return false;
273     }
274   }
275 
276   return true;
277 }
278 
279 template <typename ElfTypes>
~ElfFileImpl()280 ElfFileImpl<ElfTypes>::~ElfFileImpl() {
281   delete symtab_symbol_table_;
282   delete dynsym_symbol_table_;
283 }
284 
285 template <typename ElfTypes>
CheckAndSet(Elf32_Off offset,const char * label,uint8_t ** target,std::string * error_msg)286 bool ElfFileImpl<ElfTypes>::CheckAndSet(Elf32_Off offset, const char* label,
287                                         uint8_t** target, std::string* error_msg) {
288   if (Begin() + offset >= End()) {
289     *error_msg = StringPrintf("Offset %d is out of range for %s in ELF file: '%s'", offset, label,
290                               file_path_.c_str());
291     return false;
292   }
293   *target = Begin() + offset;
294   return true;
295 }
296 
297 template <typename ElfTypes>
CheckSectionsLinked(const uint8_t * source,const uint8_t * target) const298 bool ElfFileImpl<ElfTypes>::CheckSectionsLinked(const uint8_t* source,
299                                                 const uint8_t* target) const {
300   // Only works in whole-program mode, as we need to iterate over the sections.
301   // Note that we normally can't search by type, as duplicates are allowed for most section types.
302   if (program_header_only_) {
303     return true;
304   }
305 
306   Elf_Shdr* source_section = nullptr;
307   Elf_Word target_index = 0;
308   bool target_found = false;
309   for (Elf_Word i = 0; i < GetSectionHeaderNum(); i++) {
310     Elf_Shdr* section_header = GetSectionHeader(i);
311 
312     if (Begin() + section_header->sh_offset == source) {
313       // Found the source.
314       source_section = section_header;
315       if (target_index) {
316         break;
317       }
318     } else if (Begin() + section_header->sh_offset == target) {
319       target_index = i;
320       target_found = true;
321       if (source_section != nullptr) {
322         break;
323       }
324     }
325   }
326 
327   return target_found && source_section != nullptr && source_section->sh_link == target_index;
328 }
329 
330 template <typename ElfTypes>
CheckSectionsExist(File * file,std::string * error_msg) const331   bool ElfFileImpl<ElfTypes>::CheckSectionsExist(File* file, std::string* error_msg) const {
332   if (!program_header_only_) {
333     // If in full mode, need section headers.
334     if (section_headers_start_ == nullptr) {
335       *error_msg = StringPrintf("No section headers in ELF file: '%s'", file->GetPath().c_str());
336       return false;
337     }
338   }
339 
340   // This is redundant, but defensive.
341   if (dynamic_program_header_ == nullptr) {
342     *error_msg = StringPrintf("Failed to find PT_DYNAMIC program header in ELF file: '%s'",
343                               file->GetPath().c_str());
344     return false;
345   }
346 
347   // Need a dynamic section. This is redundant, but defensive.
348   if (dynamic_section_start_ == nullptr) {
349     *error_msg = StringPrintf("Failed to find dynamic section in ELF file: '%s'",
350                               file->GetPath().c_str());
351     return false;
352   }
353 
354   // Symtab validation. These is not really a hard failure, as we are currently not using the
355   // symtab internally, but it's nice to be defensive.
356   if (symtab_section_start_ != nullptr) {
357     // When there's a symtab, there should be a strtab.
358     if (strtab_section_start_ == nullptr) {
359       *error_msg = StringPrintf("No strtab for symtab in ELF file: '%s'", file->GetPath().c_str());
360       return false;
361     }
362 
363     // The symtab should link to the strtab.
364     if (!CheckSectionsLinked(reinterpret_cast<const uint8_t*>(symtab_section_start_),
365                              reinterpret_cast<const uint8_t*>(strtab_section_start_))) {
366       *error_msg = StringPrintf("Symtab is not linked to the strtab in ELF file: '%s'",
367                                 file->GetPath().c_str());
368       return false;
369     }
370   }
371 
372   // We always need a dynstr & dynsym.
373   if (dynstr_section_start_ == nullptr) {
374     *error_msg = StringPrintf("No dynstr in ELF file: '%s'", file->GetPath().c_str());
375     return false;
376   }
377   if (dynsym_section_start_ == nullptr) {
378     *error_msg = StringPrintf("No dynsym in ELF file: '%s'", file->GetPath().c_str());
379     return false;
380   }
381 
382   // Need a hash section for dynamic symbol lookup.
383   if (hash_section_start_ == nullptr) {
384     *error_msg = StringPrintf("Failed to find hash section in ELF file: '%s'",
385                               file->GetPath().c_str());
386     return false;
387   }
388 
389   // And the hash section should be linking to the dynsym.
390   if (!CheckSectionsLinked(reinterpret_cast<const uint8_t*>(hash_section_start_),
391                            reinterpret_cast<const uint8_t*>(dynsym_section_start_))) {
392     *error_msg = StringPrintf("Hash section is not linked to the dynstr in ELF file: '%s'",
393                               file->GetPath().c_str());
394     return false;
395   }
396 
397   // We'd also like to confirm a shstrtab in program_header_only_ mode (else Open() does this for
398   // us). This is usually the last in an oat file, and a good indicator of whether writing was
399   // successful (or the process crashed and left garbage).
400   if (program_header_only_) {
401     // It might not be mapped, but we can compare against the file size.
402     int64_t offset = static_cast<int64_t>(GetHeader().e_shoff +
403                                           (GetHeader().e_shstrndx * GetHeader().e_shentsize));
404     if (offset >= file->GetLength()) {
405       *error_msg = StringPrintf("Shstrtab is not in the mapped ELF file: '%s'",
406                                 file->GetPath().c_str());
407       return false;
408     }
409   }
410 
411   return true;
412 }
413 
414 template <typename ElfTypes>
SetMap(File * file,MemMap && map,std::string * error_msg)415 bool ElfFileImpl<ElfTypes>::SetMap(File* file, MemMap&& map, std::string* error_msg) {
416   if (!map.IsValid()) {
417     // MemMap::Open should have already set an error.
418     DCHECK(!error_msg->empty());
419     return false;
420   }
421   map_ = std::move(map);
422   CHECK(map_.IsValid()) << file->GetPath();
423   CHECK(map_.Begin() != nullptr) << file->GetPath();
424 
425   header_ = reinterpret_cast<Elf_Ehdr*>(map_.Begin());
426   if ((ELFMAG0 != header_->e_ident[EI_MAG0])
427       || (ELFMAG1 != header_->e_ident[EI_MAG1])
428       || (ELFMAG2 != header_->e_ident[EI_MAG2])
429       || (ELFMAG3 != header_->e_ident[EI_MAG3])) {
430     *error_msg = StringPrintf("Failed to find ELF magic value %d %d %d %d in %s, found %d %d %d %d",
431                               ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3,
432                               file->GetPath().c_str(),
433                               header_->e_ident[EI_MAG0],
434                               header_->e_ident[EI_MAG1],
435                               header_->e_ident[EI_MAG2],
436                               header_->e_ident[EI_MAG3]);
437     return false;
438   }
439   uint8_t elf_class = (sizeof(Elf_Addr) == sizeof(Elf64_Addr)) ? ELFCLASS64 : ELFCLASS32;
440   if (elf_class != header_->e_ident[EI_CLASS]) {
441     *error_msg = StringPrintf("Failed to find expected EI_CLASS value %d in %s, found %d",
442                               elf_class,
443                               file->GetPath().c_str(),
444                               header_->e_ident[EI_CLASS]);
445     return false;
446   }
447   if (ELFDATA2LSB != header_->e_ident[EI_DATA]) {
448     *error_msg = StringPrintf("Failed to find expected EI_DATA value %d in %s, found %d",
449                               ELFDATA2LSB,
450                               file->GetPath().c_str(),
451                               header_->e_ident[EI_CLASS]);
452     return false;
453   }
454   if (EV_CURRENT != header_->e_ident[EI_VERSION]) {
455     *error_msg = StringPrintf("Failed to find expected EI_VERSION value %d in %s, found %d",
456                               EV_CURRENT,
457                               file->GetPath().c_str(),
458                               header_->e_ident[EI_CLASS]);
459     return false;
460   }
461   if (ET_DYN != header_->e_type) {
462     *error_msg = StringPrintf("Failed to find expected e_type value %d in %s, found %d",
463                               ET_DYN,
464                               file->GetPath().c_str(),
465                               header_->e_type);
466     return false;
467   }
468   if (EV_CURRENT != header_->e_version) {
469     *error_msg = StringPrintf("Failed to find expected e_version value %d in %s, found %d",
470                               EV_CURRENT,
471                               file->GetPath().c_str(),
472                               header_->e_version);
473     return false;
474   }
475   if (0 != header_->e_entry) {
476     *error_msg = StringPrintf("Failed to find expected e_entry value %d in %s, found %d",
477                               0,
478                               file->GetPath().c_str(),
479                               static_cast<int32_t>(header_->e_entry));
480     return false;
481   }
482   if (0 == header_->e_phoff) {
483     *error_msg = StringPrintf("Failed to find non-zero e_phoff value in %s",
484                               file->GetPath().c_str());
485     return false;
486   }
487   if (0 == header_->e_shoff) {
488     *error_msg = StringPrintf("Failed to find non-zero e_shoff value in %s",
489                               file->GetPath().c_str());
490     return false;
491   }
492   if (0 == header_->e_ehsize) {
493     *error_msg = StringPrintf("Failed to find non-zero e_ehsize value in %s",
494                               file->GetPath().c_str());
495     return false;
496   }
497   if (0 == header_->e_phentsize) {
498     *error_msg = StringPrintf("Failed to find non-zero e_phentsize value in %s",
499                               file->GetPath().c_str());
500     return false;
501   }
502   if (0 == header_->e_phnum) {
503     *error_msg = StringPrintf("Failed to find non-zero e_phnum value in %s",
504                               file->GetPath().c_str());
505     return false;
506   }
507   if (0 == header_->e_shentsize) {
508     *error_msg = StringPrintf("Failed to find non-zero e_shentsize value in %s",
509                               file->GetPath().c_str());
510     return false;
511   }
512   if (0 == header_->e_shnum) {
513     *error_msg = StringPrintf("Failed to find non-zero e_shnum value in %s",
514                               file->GetPath().c_str());
515     return false;
516   }
517   if (0 == header_->e_shstrndx) {
518     *error_msg = StringPrintf("Failed to find non-zero e_shstrndx value in %s",
519                               file->GetPath().c_str());
520     return false;
521   }
522   if (header_->e_shstrndx >= header_->e_shnum) {
523     *error_msg = StringPrintf("Failed to find e_shnum value %d less than %d in %s",
524                               header_->e_shstrndx,
525                               header_->e_shnum,
526                               file->GetPath().c_str());
527     return false;
528   }
529 
530   if (!program_header_only_) {
531     if (header_->e_phoff >= Size()) {
532       *error_msg = StringPrintf("Failed to find e_phoff value %" PRIu64 " less than %zd in %s",
533                                 static_cast<uint64_t>(header_->e_phoff),
534                                 Size(),
535                                 file->GetPath().c_str());
536       return false;
537     }
538     if (header_->e_shoff >= Size()) {
539       *error_msg = StringPrintf("Failed to find e_shoff value %" PRIu64 " less than %zd in %s",
540                                 static_cast<uint64_t>(header_->e_shoff),
541                                 Size(),
542                                 file->GetPath().c_str());
543       return false;
544     }
545   }
546   return true;
547 }
548 
549 template <typename ElfTypes>
GetHeader() const550 typename ElfTypes::Ehdr& ElfFileImpl<ElfTypes>::GetHeader() const {
551   CHECK(header_ != nullptr);  // Header has been checked in SetMap
552   return *header_;
553 }
554 
555 template <typename ElfTypes>
GetProgramHeadersStart() const556 uint8_t* ElfFileImpl<ElfTypes>::GetProgramHeadersStart() const {
557   CHECK(program_headers_start_ != nullptr);  // Header has been set in Setup
558   return program_headers_start_;
559 }
560 
561 template <typename ElfTypes>
GetSectionHeadersStart() const562 uint8_t* ElfFileImpl<ElfTypes>::GetSectionHeadersStart() const {
563   CHECK(!program_header_only_);              // Only used in "full" mode.
564   CHECK(section_headers_start_ != nullptr);  // Is checked in CheckSectionsExist
565   return section_headers_start_;
566 }
567 
568 template <typename ElfTypes>
GetDynamicProgramHeader() const569 typename ElfTypes::Phdr& ElfFileImpl<ElfTypes>::GetDynamicProgramHeader() const {
570   CHECK(dynamic_program_header_ != nullptr);  // Is checked in CheckSectionsExist
571   return *dynamic_program_header_;
572 }
573 
574 template <typename ElfTypes>
GetDynamicSectionStart() const575 typename ElfTypes::Dyn* ElfFileImpl<ElfTypes>::GetDynamicSectionStart() const {
576   CHECK(dynamic_section_start_ != nullptr);  // Is checked in CheckSectionsExist
577   return dynamic_section_start_;
578 }
579 
580 template <typename ElfTypes>
GetSymbolSectionStart(Elf_Word section_type) const581 typename ElfTypes::Sym* ElfFileImpl<ElfTypes>::GetSymbolSectionStart(
582     Elf_Word section_type) const {
583   CHECK(IsSymbolSectionType(section_type)) << file_path_ << " " << section_type;
584   switch (section_type) {
585     case SHT_SYMTAB: {
586       return symtab_section_start_;
587       break;
588     }
589     case SHT_DYNSYM: {
590       return dynsym_section_start_;
591       break;
592     }
593     default: {
594       LOG(FATAL) << section_type;
595       return nullptr;
596     }
597   }
598 }
599 
600 template <typename ElfTypes>
GetStringSectionStart(Elf_Word section_type) const601 const char* ElfFileImpl<ElfTypes>::GetStringSectionStart(
602     Elf_Word section_type) const {
603   CHECK(IsSymbolSectionType(section_type)) << file_path_ << " " << section_type;
604   switch (section_type) {
605     case SHT_SYMTAB: {
606       return strtab_section_start_;
607     }
608     case SHT_DYNSYM: {
609       return dynstr_section_start_;
610     }
611     default: {
612       LOG(FATAL) << section_type;
613       return nullptr;
614     }
615   }
616 }
617 
618 template <typename ElfTypes>
GetString(Elf_Word section_type,Elf_Word i) const619 const char* ElfFileImpl<ElfTypes>::GetString(Elf_Word section_type,
620                                              Elf_Word i) const {
621   CHECK(IsSymbolSectionType(section_type)) << file_path_ << " " << section_type;
622   if (i == 0) {
623     return nullptr;
624   }
625   const char* string_section_start = GetStringSectionStart(section_type);
626   if (string_section_start == nullptr) {
627     return nullptr;
628   }
629   return string_section_start + i;
630 }
631 
632 // WARNING: The following methods do not check for an error condition (non-existent hash section).
633 //          It is the caller's job to do this.
634 
635 template <typename ElfTypes>
GetHashSectionStart() const636 typename ElfTypes::Word* ElfFileImpl<ElfTypes>::GetHashSectionStart() const {
637   return hash_section_start_;
638 }
639 
640 template <typename ElfTypes>
GetHashBucketNum() const641 typename ElfTypes::Word ElfFileImpl<ElfTypes>::GetHashBucketNum() const {
642   return GetHashSectionStart()[0];
643 }
644 
645 template <typename ElfTypes>
GetHashChainNum() const646 typename ElfTypes::Word ElfFileImpl<ElfTypes>::GetHashChainNum() const {
647   return GetHashSectionStart()[1];
648 }
649 
650 template <typename ElfTypes>
GetHashBucket(size_t i,bool * ok) const651 typename ElfTypes::Word ElfFileImpl<ElfTypes>::GetHashBucket(size_t i, bool* ok) const {
652   if (i >= GetHashBucketNum()) {
653     *ok = false;
654     return 0;
655   }
656   *ok = true;
657   // 0 is nbucket, 1 is nchain
658   return GetHashSectionStart()[2 + i];
659 }
660 
661 template <typename ElfTypes>
GetHashChain(size_t i,bool * ok) const662 typename ElfTypes::Word ElfFileImpl<ElfTypes>::GetHashChain(size_t i, bool* ok) const {
663   if (i >= GetHashChainNum()) {
664     *ok = false;
665     return 0;
666   }
667   *ok = true;
668   // 0 is nbucket, 1 is nchain, & chains are after buckets
669   return GetHashSectionStart()[2 + GetHashBucketNum() + i];
670 }
671 
672 template <typename ElfTypes>
GetProgramHeaderNum() const673 typename ElfTypes::Word ElfFileImpl<ElfTypes>::GetProgramHeaderNum() const {
674   return GetHeader().e_phnum;
675 }
676 
677 template <typename ElfTypes>
GetProgramHeader(Elf_Word i) const678 typename ElfTypes::Phdr* ElfFileImpl<ElfTypes>::GetProgramHeader(Elf_Word i) const {
679   CHECK_LT(i, GetProgramHeaderNum()) << file_path_;  // Validity check for caller.
680   uint8_t* program_header = GetProgramHeadersStart() + (i * GetHeader().e_phentsize);
681   CHECK_LT(program_header, End());
682   return reinterpret_cast<Elf_Phdr*>(program_header);
683 }
684 
685 template <typename ElfTypes>
FindProgamHeaderByType(Elf_Word type) const686 typename ElfTypes::Phdr* ElfFileImpl<ElfTypes>::FindProgamHeaderByType(Elf_Word type) const {
687   for (Elf_Word i = 0; i < GetProgramHeaderNum(); i++) {
688     Elf_Phdr* program_header = GetProgramHeader(i);
689     if (program_header->p_type == type) {
690       return program_header;
691     }
692   }
693   return nullptr;
694 }
695 
696 template <typename ElfTypes>
GetSectionHeaderNum() const697 typename ElfTypes::Word ElfFileImpl<ElfTypes>::GetSectionHeaderNum() const {
698   return GetHeader().e_shnum;
699 }
700 
701 template <typename ElfTypes>
GetSectionHeader(Elf_Word i) const702 typename ElfTypes::Shdr* ElfFileImpl<ElfTypes>::GetSectionHeader(Elf_Word i) const {
703   // Can only access arbitrary sections when we have the whole file, not just program header.
704   // Even if we Load(), it doesn't bring in all the sections.
705   CHECK(!program_header_only_) << file_path_;
706   if (i >= GetSectionHeaderNum()) {
707     return nullptr;  // Failure condition.
708   }
709   uint8_t* section_header = GetSectionHeadersStart() + (i * GetHeader().e_shentsize);
710   if (section_header >= End()) {
711     return nullptr;  // Failure condition.
712   }
713   return reinterpret_cast<Elf_Shdr*>(section_header);
714 }
715 
716 template <typename ElfTypes>
FindSectionByType(Elf_Word type) const717 typename ElfTypes::Shdr* ElfFileImpl<ElfTypes>::FindSectionByType(Elf_Word type) const {
718   // Can only access arbitrary sections when we have the whole file, not just program header.
719   // We could change this to switch on known types if they were detected during loading.
720   CHECK(!program_header_only_) << file_path_;
721   for (Elf_Word i = 0; i < GetSectionHeaderNum(); i++) {
722     Elf_Shdr* section_header = GetSectionHeader(i);
723     if (section_header->sh_type == type) {
724       return section_header;
725     }
726   }
727   return nullptr;
728 }
729 
730 // from bionic
elfhash(const char * _name)731 static unsigned elfhash(const char *_name) {
732   const unsigned char *name = (const unsigned char *) _name;
733   unsigned h = 0, g;
734 
735   while (*name) {
736     h = (h << 4) + *name++;
737     g = h & 0xf0000000;
738     h ^= g;
739     h ^= g >> 24;
740   }
741   return h;
742 }
743 
744 template <typename ElfTypes>
GetSectionNameStringSection() const745 typename ElfTypes::Shdr* ElfFileImpl<ElfTypes>::GetSectionNameStringSection() const {
746   return GetSectionHeader(GetHeader().e_shstrndx);
747 }
748 
749 template <typename ElfTypes>
FindDynamicSymbolAddress(const std::string & symbol_name) const750 const uint8_t* ElfFileImpl<ElfTypes>::FindDynamicSymbolAddress(
751     const std::string& symbol_name) const {
752   // Check that we have a hash section.
753   if (GetHashSectionStart() == nullptr) {
754     return nullptr;  // Failure condition.
755   }
756   const Elf_Sym* sym = FindDynamicSymbol(symbol_name);
757   if (sym != nullptr) {
758     // TODO: we need to change this to calculate base_address_ in ::Open,
759     // otherwise it will be wrongly 0 if ::Load has not yet been called.
760     return base_address_ + sym->st_value;
761   } else {
762     return nullptr;
763   }
764 }
765 
766 // WARNING: Only called from FindDynamicSymbolAddress. Elides check for hash section.
767 template <typename ElfTypes>
FindDynamicSymbol(const std::string & symbol_name) const768 const typename ElfTypes::Sym* ElfFileImpl<ElfTypes>::FindDynamicSymbol(
769     const std::string& symbol_name) const {
770   if (GetHashBucketNum() == 0) {
771     // No dynamic symbols at all.
772     return nullptr;
773   }
774   Elf_Word hash = elfhash(symbol_name.c_str());
775   Elf_Word bucket_index = hash % GetHashBucketNum();
776   bool ok;
777   Elf_Word symbol_and_chain_index = GetHashBucket(bucket_index, &ok);
778   if (!ok) {
779     return nullptr;
780   }
781   while (symbol_and_chain_index != 0 /* STN_UNDEF */) {
782     Elf_Sym* symbol = GetSymbol(SHT_DYNSYM, symbol_and_chain_index);
783     if (symbol == nullptr) {
784       return nullptr;  // Failure condition.
785     }
786     const char* name = GetString(SHT_DYNSYM, symbol->st_name);
787     if (symbol_name == name) {
788       return symbol;
789     }
790     symbol_and_chain_index = GetHashChain(symbol_and_chain_index, &ok);
791     if (!ok) {
792       return nullptr;
793     }
794   }
795   return nullptr;
796 }
797 
798 template <typename ElfTypes>
IsSymbolSectionType(Elf_Word section_type)799 bool ElfFileImpl<ElfTypes>::IsSymbolSectionType(Elf_Word section_type) {
800   return ((section_type == SHT_SYMTAB) || (section_type == SHT_DYNSYM));
801 }
802 
803 template <typename ElfTypes>
GetSymbolNum(Elf_Shdr & section_header) const804 typename ElfTypes::Word ElfFileImpl<ElfTypes>::GetSymbolNum(Elf_Shdr& section_header) const {
805   CHECK(IsSymbolSectionType(section_header.sh_type))
806       << file_path_ << " " << section_header.sh_type;
807   CHECK_NE(0U, section_header.sh_entsize) << file_path_;
808   return section_header.sh_size / section_header.sh_entsize;
809 }
810 
811 template <typename ElfTypes>
GetSymbol(Elf_Word section_type,Elf_Word i) const812 typename ElfTypes::Sym* ElfFileImpl<ElfTypes>::GetSymbol(Elf_Word section_type, Elf_Word i) const {
813   Elf_Sym* sym_start = GetSymbolSectionStart(section_type);
814   if (sym_start == nullptr) {
815     return nullptr;
816   }
817   return sym_start + i;
818 }
819 
820 template <typename ElfTypes>
821 typename ElfFileImpl<ElfTypes>::SymbolTable**
GetSymbolTable(Elf_Word section_type)822 ElfFileImpl<ElfTypes>::GetSymbolTable(Elf_Word section_type) {
823   CHECK(IsSymbolSectionType(section_type)) << file_path_ << " " << section_type;
824   switch (section_type) {
825     case SHT_SYMTAB: {
826       return &symtab_symbol_table_;
827     }
828     case SHT_DYNSYM: {
829       return &dynsym_symbol_table_;
830     }
831     default: {
832       LOG(FATAL) << section_type;
833       return nullptr;
834     }
835   }
836 }
837 
838 template <typename ElfTypes>
FindSymbolByName(Elf_Word section_type,const std::string & symbol_name,bool build_map)839 typename ElfTypes::Sym* ElfFileImpl<ElfTypes>::FindSymbolByName(
840     Elf_Word section_type, const std::string& symbol_name, bool build_map) {
841   CHECK(!program_header_only_) << file_path_;
842   CHECK(IsSymbolSectionType(section_type)) << file_path_ << " " << section_type;
843 
844   SymbolTable** symbol_table = GetSymbolTable(section_type);
845   if (*symbol_table != nullptr || build_map) {
846     if (*symbol_table == nullptr) {
847       DCHECK(build_map);
848       *symbol_table = new SymbolTable;
849       Elf_Shdr* symbol_section = FindSectionByType(section_type);
850       if (symbol_section == nullptr) {
851         return nullptr;  // Failure condition.
852       }
853       Elf_Shdr* string_section = GetSectionHeader(symbol_section->sh_link);
854       if (string_section == nullptr) {
855         return nullptr;  // Failure condition.
856       }
857       for (uint32_t i = 0; i < GetSymbolNum(*symbol_section); i++) {
858         Elf_Sym* symbol = GetSymbol(section_type, i);
859         if (symbol == nullptr) {
860           return nullptr;  // Failure condition.
861         }
862         unsigned char type = (sizeof(Elf_Addr) == sizeof(Elf64_Addr))
863                              ? ELF64_ST_TYPE(symbol->st_info)
864                              : ELF32_ST_TYPE(symbol->st_info);
865         if (type == STT_NOTYPE) {
866           continue;
867         }
868         const char* name = GetString(*string_section, symbol->st_name);
869         if (name == nullptr) {
870           continue;
871         }
872         std::pair<typename SymbolTable::iterator, bool> result =
873             (*symbol_table)->insert(std::make_pair(name, symbol));
874         if (!result.second) {
875           // If a duplicate, make sure it has the same logical value. Seen on x86.
876           if ((symbol->st_value != result.first->second->st_value) ||
877               (symbol->st_size != result.first->second->st_size) ||
878               (symbol->st_info != result.first->second->st_info) ||
879               (symbol->st_other != result.first->second->st_other) ||
880               (symbol->st_shndx != result.first->second->st_shndx)) {
881             return nullptr;  // Failure condition.
882           }
883         }
884       }
885     }
886     CHECK(*symbol_table != nullptr);
887     typename SymbolTable::const_iterator it = (*symbol_table)->find(symbol_name);
888     if (it == (*symbol_table)->end()) {
889       return nullptr;
890     }
891     return it->second;
892   }
893 
894   // Fall back to linear search
895   Elf_Shdr* symbol_section = FindSectionByType(section_type);
896   if (symbol_section == nullptr) {
897     return nullptr;
898   }
899   Elf_Shdr* string_section = GetSectionHeader(symbol_section->sh_link);
900   if (string_section == nullptr) {
901     return nullptr;
902   }
903   for (uint32_t i = 0; i < GetSymbolNum(*symbol_section); i++) {
904     Elf_Sym* symbol = GetSymbol(section_type, i);
905     if (symbol == nullptr) {
906       return nullptr;  // Failure condition.
907     }
908     const char* name = GetString(*string_section, symbol->st_name);
909     if (name == nullptr) {
910       continue;
911     }
912     if (symbol_name == name) {
913       return symbol;
914     }
915   }
916   return nullptr;
917 }
918 
919 template <typename ElfTypes>
FindSymbolAddress(Elf_Word section_type,const std::string & symbol_name,bool build_map)920 typename ElfTypes::Addr ElfFileImpl<ElfTypes>::FindSymbolAddress(
921     Elf_Word section_type, const std::string& symbol_name, bool build_map) {
922   Elf_Sym* symbol = FindSymbolByName(section_type, symbol_name, build_map);
923   if (symbol == nullptr) {
924     return 0;
925   }
926   return symbol->st_value;
927 }
928 
929 template <typename ElfTypes>
GetString(Elf_Shdr & string_section,Elf_Word i) const930 const char* ElfFileImpl<ElfTypes>::GetString(Elf_Shdr& string_section,
931                                              Elf_Word i) const {
932   CHECK(!program_header_only_) << file_path_;
933   // TODO: remove this static_cast from enum when using -std=gnu++0x
934   if (static_cast<Elf_Word>(SHT_STRTAB) != string_section.sh_type) {
935     return nullptr;  // Failure condition.
936   }
937   if (i >= string_section.sh_size) {
938     return nullptr;
939   }
940   if (i == 0) {
941     return nullptr;
942   }
943   uint8_t* strings = Begin() + string_section.sh_offset;
944   uint8_t* string = strings + i;
945   if (string >= End()) {
946     return nullptr;
947   }
948   return reinterpret_cast<const char*>(string);
949 }
950 
951 template <typename ElfTypes>
GetDynamicNum() const952 typename ElfTypes::Word ElfFileImpl<ElfTypes>::GetDynamicNum() const {
953   return GetDynamicProgramHeader().p_filesz / sizeof(Elf_Dyn);
954 }
955 
956 template <typename ElfTypes>
GetDynamic(Elf_Word i) const957 typename ElfTypes::Dyn& ElfFileImpl<ElfTypes>::GetDynamic(Elf_Word i) const {
958   CHECK_LT(i, GetDynamicNum()) << file_path_;
959   return *(GetDynamicSectionStart() + i);
960 }
961 
962 template <typename ElfTypes>
FindDynamicByType(Elf_Sword type) const963 typename ElfTypes::Dyn* ElfFileImpl<ElfTypes>::FindDynamicByType(Elf_Sword type) const {
964   for (Elf_Word i = 0; i < GetDynamicNum(); i++) {
965     Elf_Dyn* dyn = &GetDynamic(i);
966     if (dyn->d_tag == type) {
967       return dyn;
968     }
969   }
970   return nullptr;
971 }
972 
973 template <typename ElfTypes>
FindDynamicValueByType(Elf_Sword type) const974 typename ElfTypes::Word ElfFileImpl<ElfTypes>::FindDynamicValueByType(Elf_Sword type) const {
975   Elf_Dyn* dyn = FindDynamicByType(type);
976   if (dyn == nullptr) {
977     return 0;
978   } else {
979     return dyn->d_un.d_val;
980   }
981 }
982 
983 template <typename ElfTypes>
GetRelSectionStart(Elf_Shdr & section_header) const984 typename ElfTypes::Rel* ElfFileImpl<ElfTypes>::GetRelSectionStart(Elf_Shdr& section_header) const {
985   CHECK(SHT_REL == section_header.sh_type) << file_path_ << " " << section_header.sh_type;
986   return reinterpret_cast<Elf_Rel*>(Begin() + section_header.sh_offset);
987 }
988 
989 template <typename ElfTypes>
GetRelNum(Elf_Shdr & section_header) const990 typename ElfTypes::Word ElfFileImpl<ElfTypes>::GetRelNum(Elf_Shdr& section_header) const {
991   CHECK(SHT_REL == section_header.sh_type) << file_path_ << " " << section_header.sh_type;
992   CHECK_NE(0U, section_header.sh_entsize) << file_path_;
993   return section_header.sh_size / section_header.sh_entsize;
994 }
995 
996 template <typename ElfTypes>
GetRel(Elf_Shdr & section_header,Elf_Word i) const997 typename ElfTypes::Rel& ElfFileImpl<ElfTypes>::GetRel(Elf_Shdr& section_header, Elf_Word i) const {
998   CHECK(SHT_REL == section_header.sh_type) << file_path_ << " " << section_header.sh_type;
999   CHECK_LT(i, GetRelNum(section_header)) << file_path_;
1000   return *(GetRelSectionStart(section_header) + i);
1001 }
1002 
1003 template <typename ElfTypes>
GetRelaSectionStart(Elf_Shdr & section_header) const1004 typename ElfTypes::Rela* ElfFileImpl<ElfTypes>::GetRelaSectionStart(Elf_Shdr& section_header) const {
1005   CHECK(SHT_RELA == section_header.sh_type) << file_path_ << " " << section_header.sh_type;
1006   return reinterpret_cast<Elf_Rela*>(Begin() + section_header.sh_offset);
1007 }
1008 
1009 template <typename ElfTypes>
GetRelaNum(Elf_Shdr & section_header) const1010 typename ElfTypes::Word ElfFileImpl<ElfTypes>::GetRelaNum(Elf_Shdr& section_header) const {
1011   CHECK(SHT_RELA == section_header.sh_type) << file_path_ << " " << section_header.sh_type;
1012   return section_header.sh_size / section_header.sh_entsize;
1013 }
1014 
1015 template <typename ElfTypes>
GetRela(Elf_Shdr & section_header,Elf_Word i) const1016 typename ElfTypes::Rela& ElfFileImpl<ElfTypes>::GetRela(Elf_Shdr& section_header, Elf_Word i) const {
1017   CHECK(SHT_RELA == section_header.sh_type) << file_path_ << " " << section_header.sh_type;
1018   CHECK_LT(i, GetRelaNum(section_header)) << file_path_;
1019   return *(GetRelaSectionStart(section_header) + i);
1020 }
1021 
1022 template <typename ElfTypes>
GetLoadedSize(size_t * size,std::string * error_msg) const1023 bool ElfFileImpl<ElfTypes>::GetLoadedSize(size_t* size, std::string* error_msg) const {
1024   uint8_t* vaddr_begin;
1025   return GetLoadedAddressRange(&vaddr_begin, size, error_msg);
1026 }
1027 
1028 // Base on bionic phdr_table_get_load_size
1029 template <typename ElfTypes>
GetLoadedAddressRange(uint8_t ** vaddr_begin,size_t * vaddr_size,std::string * error_msg) const1030 bool ElfFileImpl<ElfTypes>::GetLoadedAddressRange(/*out*/uint8_t** vaddr_begin,
1031                                                   /*out*/size_t* vaddr_size,
1032                                                   /*out*/std::string* error_msg) const {
1033   Elf_Addr min_vaddr = static_cast<Elf_Addr>(-1);
1034   Elf_Addr max_vaddr = 0u;
1035   for (Elf_Word i = 0; i < GetProgramHeaderNum(); i++) {
1036     Elf_Phdr* program_header = GetProgramHeader(i);
1037     if (program_header->p_type != PT_LOAD) {
1038       continue;
1039     }
1040     Elf_Addr begin_vaddr = program_header->p_vaddr;
1041     if (begin_vaddr < min_vaddr) {
1042        min_vaddr = begin_vaddr;
1043     }
1044     Elf_Addr end_vaddr = program_header->p_vaddr + program_header->p_memsz;
1045     if (UNLIKELY(begin_vaddr > end_vaddr)) {
1046       std::ostringstream oss;
1047       oss << "Program header #" << i << " has overflow in p_vaddr+p_memsz: 0x" << std::hex
1048           << program_header->p_vaddr << "+0x" << program_header->p_memsz << "=0x" << end_vaddr
1049           << " in ELF file \"" << file_path_ << "\"";
1050       *error_msg = oss.str();
1051       *vaddr_begin = nullptr;
1052       *vaddr_size = static_cast<size_t>(-1);
1053       return false;
1054     }
1055     if (end_vaddr > max_vaddr) {
1056       max_vaddr = end_vaddr;
1057     }
1058   }
1059   min_vaddr = RoundDown(min_vaddr, kPageSize);
1060   max_vaddr = RoundUp(max_vaddr, kPageSize);
1061   CHECK_LT(min_vaddr, max_vaddr) << file_path_;
1062   // Check that the range fits into the runtime address space.
1063   if (UNLIKELY(max_vaddr - 1u > std::numeric_limits<size_t>::max())) {
1064     std::ostringstream oss;
1065     oss << "Loaded range is 0x" << std::hex << min_vaddr << "-0x" << max_vaddr
1066         << " but maximum size_t is 0x" << std::numeric_limits<size_t>::max()
1067         << " for ELF file \"" << file_path_ << "\"";
1068     *error_msg = oss.str();
1069     *vaddr_begin = nullptr;
1070     *vaddr_size = static_cast<size_t>(-1);
1071     return false;
1072   }
1073   *vaddr_begin = reinterpret_cast<uint8_t*>(min_vaddr);
1074   *vaddr_size = dchecked_integral_cast<size_t>(max_vaddr - min_vaddr);
1075   return true;
1076 }
1077 
GetInstructionSetFromELF(uint16_t e_machine,uint32_t e_flags ATTRIBUTE_UNUSED)1078 static InstructionSet GetInstructionSetFromELF(uint16_t e_machine,
1079                                                uint32_t e_flags ATTRIBUTE_UNUSED) {
1080   switch (e_machine) {
1081     case EM_ARM:
1082       return InstructionSet::kArm;
1083     case EM_AARCH64:
1084       return InstructionSet::kArm64;
1085     case EM_386:
1086       return InstructionSet::kX86;
1087     case EM_X86_64:
1088       return InstructionSet::kX86_64;
1089   }
1090   return InstructionSet::kNone;
1091 }
1092 
1093 template <typename ElfTypes>
Load(File * file,bool executable,bool low_4gb,MemMap * reservation,std::string * error_msg)1094 bool ElfFileImpl<ElfTypes>::Load(File* file,
1095                                  bool executable,
1096                                  bool low_4gb,
1097                                  /*inout*/MemMap* reservation,
1098                                  /*out*/std::string* error_msg) {
1099   CHECK(program_header_only_) << file->GetPath();
1100 
1101   if (executable) {
1102     InstructionSet elf_ISA = GetInstructionSetFromELF(GetHeader().e_machine, GetHeader().e_flags);
1103     if (elf_ISA != kRuntimeISA) {
1104       std::ostringstream oss;
1105       oss << "Expected ISA " << kRuntimeISA << " but found " << elf_ISA;
1106       *error_msg = oss.str();
1107       return false;
1108     }
1109   }
1110 
1111   bool reserved = false;
1112   for (Elf_Word i = 0; i < GetProgramHeaderNum(); i++) {
1113     Elf_Phdr* program_header = GetProgramHeader(i);
1114 
1115     // Record .dynamic header information for later use
1116     if (program_header->p_type == PT_DYNAMIC) {
1117       dynamic_program_header_ = program_header;
1118       continue;
1119     }
1120 
1121     // Not something to load, move on.
1122     if (program_header->p_type != PT_LOAD) {
1123       continue;
1124     }
1125 
1126     // Found something to load.
1127 
1128     // Before load the actual segments, reserve a contiguous chunk
1129     // of required size and address for all segments, but with no
1130     // permissions. We'll then carve that up with the proper
1131     // permissions as we load the actual segments. If p_vaddr is
1132     // non-zero, the segments require the specific address specified,
1133     // which either was specified in the file because we already set
1134     // base_address_ after the first zero segment).
1135     int64_t temp_file_length = file->GetLength();
1136     if (temp_file_length < 0) {
1137       errno = -temp_file_length;
1138       *error_msg = StringPrintf("Failed to get length of file: '%s' fd=%d: %s",
1139                                 file->GetPath().c_str(), file->Fd(), strerror(errno));
1140       return false;
1141     }
1142     size_t file_length = static_cast<size_t>(temp_file_length);
1143     if (!reserved) {
1144       uint8_t* vaddr_begin;
1145       size_t vaddr_size;
1146       if (!GetLoadedAddressRange(&vaddr_begin, &vaddr_size, error_msg)) {
1147         DCHECK(!error_msg->empty());
1148         return false;
1149       }
1150       std::string reservation_name = "ElfFile reservation for " + file->GetPath();
1151       MemMap local_reservation = MemMap::MapAnonymous(
1152           reservation_name.c_str(),
1153           (reservation != nullptr) ? reservation->Begin() : nullptr,
1154           vaddr_size,
1155           PROT_NONE,
1156           low_4gb,
1157           /* reuse= */ false,
1158           reservation,
1159           error_msg);
1160       if (!local_reservation.IsValid()) {
1161         *error_msg = StringPrintf("Failed to allocate %s: %s",
1162                                   reservation_name.c_str(),
1163                                   error_msg->c_str());
1164         return false;
1165       }
1166       reserved = true;
1167 
1168       // Base address is the difference of actual mapped location and the vaddr_begin.
1169       base_address_ = reinterpret_cast<uint8_t*>(
1170           static_cast<uintptr_t>(local_reservation.Begin() - vaddr_begin));
1171       // By adding the p_vaddr of a section/symbol to base_address_ we will always get the
1172       // dynamic memory address of where that object is actually mapped
1173       //
1174       // TODO: base_address_ needs to be calculated in ::Open, otherwise
1175       // FindDynamicSymbolAddress returns the wrong values until Load is called.
1176       segments_.push_back(std::move(local_reservation));
1177     }
1178     // empty segment, nothing to map
1179     if (program_header->p_memsz == 0) {
1180       continue;
1181     }
1182     uint8_t* p_vaddr = base_address_ + program_header->p_vaddr;
1183     int prot = 0;
1184     if (executable && ((program_header->p_flags & PF_X) != 0)) {
1185       prot |= PROT_EXEC;
1186     }
1187     if ((program_header->p_flags & PF_W) != 0) {
1188       prot |= PROT_WRITE;
1189     }
1190     if ((program_header->p_flags & PF_R) != 0) {
1191       prot |= PROT_READ;
1192     }
1193     int flags = 0;
1194     if (writable_) {
1195       prot |= PROT_WRITE;
1196       flags |= MAP_SHARED;
1197     } else {
1198       flags |= MAP_PRIVATE;
1199     }
1200     if (program_header->p_filesz > program_header->p_memsz) {
1201       *error_msg = StringPrintf("Invalid p_filesz > p_memsz (%" PRIu64 " > %" PRIu64 "): %s",
1202                                 static_cast<uint64_t>(program_header->p_filesz),
1203                                 static_cast<uint64_t>(program_header->p_memsz),
1204                                 file->GetPath().c_str());
1205       return false;
1206     }
1207     if (program_header->p_filesz < program_header->p_memsz &&
1208         !IsAligned<kPageSize>(program_header->p_filesz)) {
1209       *error_msg = StringPrintf("Unsupported unaligned p_filesz < p_memsz (%" PRIu64
1210                                 " < %" PRIu64 "): %s",
1211                                 static_cast<uint64_t>(program_header->p_filesz),
1212                                 static_cast<uint64_t>(program_header->p_memsz),
1213                                 file->GetPath().c_str());
1214       return false;
1215     }
1216     if (file_length < (program_header->p_offset + program_header->p_filesz)) {
1217       *error_msg = StringPrintf("File size of %zd bytes not large enough to contain ELF segment "
1218                                 "%d of %" PRIu64 " bytes: '%s'", file_length, i,
1219                                 static_cast<uint64_t>(program_header->p_offset + program_header->p_filesz),
1220                                 file->GetPath().c_str());
1221       return false;
1222     }
1223     if (program_header->p_filesz != 0u) {
1224       MemMap segment =
1225           MemMap::MapFileAtAddress(p_vaddr,
1226                                    program_header->p_filesz,
1227                                    prot,
1228                                    flags,
1229                                    file->Fd(),
1230                                    program_header->p_offset,
1231                                    /* low_4gb= */ false,
1232                                    file->GetPath().c_str(),
1233                                    /* reuse= */ true,  // implies MAP_FIXED
1234                                    /* reservation= */ nullptr,
1235                                    error_msg);
1236       if (!segment.IsValid()) {
1237         *error_msg = StringPrintf("Failed to map ELF file segment %d from %s: %s",
1238                                   i, file->GetPath().c_str(), error_msg->c_str());
1239         return false;
1240       }
1241       if (segment.Begin() != p_vaddr) {
1242         *error_msg = StringPrintf("Failed to map ELF file segment %d from %s at expected address %p, "
1243                                   "instead mapped to %p",
1244                                   i, file->GetPath().c_str(), p_vaddr, segment.Begin());
1245         return false;
1246       }
1247       segments_.push_back(std::move(segment));
1248     }
1249     if (program_header->p_filesz < program_header->p_memsz) {
1250       std::string name = StringPrintf("Zero-initialized segment %" PRIu64 " of ELF file %s",
1251                                       static_cast<uint64_t>(i), file->GetPath().c_str());
1252       MemMap segment = MemMap::MapAnonymous(name.c_str(),
1253                                             p_vaddr + program_header->p_filesz,
1254                                             program_header->p_memsz - program_header->p_filesz,
1255                                             prot,
1256                                             /* low_4gb= */ false,
1257                                             /* reuse= */ true,
1258                                             /* reservation= */ nullptr,
1259                                             error_msg);
1260       if (!segment.IsValid()) {
1261         *error_msg = StringPrintf("Failed to map zero-initialized ELF file segment %d from %s: %s",
1262                                   i, file->GetPath().c_str(), error_msg->c_str());
1263         return false;
1264       }
1265       if (segment.Begin() != p_vaddr) {
1266         *error_msg = StringPrintf("Failed to map zero-initialized ELF file segment %d from %s "
1267                                   "at expected address %p, instead mapped to %p",
1268                                   i, file->GetPath().c_str(), p_vaddr, segment.Begin());
1269         return false;
1270       }
1271       segments_.push_back(std::move(segment));
1272     }
1273   }
1274 
1275   // Now that we are done loading, .dynamic should be in memory to find .dynstr, .dynsym, .hash
1276   uint8_t* dsptr = base_address_ + GetDynamicProgramHeader().p_vaddr;
1277   if ((dsptr < Begin() || dsptr >= End()) && !ValidPointer(dsptr)) {
1278     *error_msg = StringPrintf("dynamic section address invalid in ELF file %s",
1279                               file->GetPath().c_str());
1280     return false;
1281   }
1282   dynamic_section_start_ = reinterpret_cast<Elf_Dyn*>(dsptr);
1283 
1284   for (Elf_Word i = 0; i < GetDynamicNum(); i++) {
1285     Elf_Dyn& elf_dyn = GetDynamic(i);
1286     uint8_t* d_ptr = base_address_ + elf_dyn.d_un.d_ptr;
1287     switch (elf_dyn.d_tag) {
1288       case DT_HASH: {
1289         if (!ValidPointer(d_ptr)) {
1290           *error_msg = StringPrintf("DT_HASH value %p does not refer to a loaded ELF segment of %s",
1291                                     d_ptr, file->GetPath().c_str());
1292           return false;
1293         }
1294         hash_section_start_ = reinterpret_cast<Elf_Word*>(d_ptr);
1295         break;
1296       }
1297       case DT_STRTAB: {
1298         if (!ValidPointer(d_ptr)) {
1299           *error_msg = StringPrintf("DT_HASH value %p does not refer to a loaded ELF segment of %s",
1300                                     d_ptr, file->GetPath().c_str());
1301           return false;
1302         }
1303         dynstr_section_start_ = reinterpret_cast<char*>(d_ptr);
1304         break;
1305       }
1306       case DT_SYMTAB: {
1307         if (!ValidPointer(d_ptr)) {
1308           *error_msg = StringPrintf("DT_HASH value %p does not refer to a loaded ELF segment of %s",
1309                                     d_ptr, file->GetPath().c_str());
1310           return false;
1311         }
1312         dynsym_section_start_ = reinterpret_cast<Elf_Sym*>(d_ptr);
1313         break;
1314       }
1315       case DT_NULL: {
1316         if (GetDynamicNum() != i+1) {
1317           *error_msg = StringPrintf("DT_NULL found after %d .dynamic entries, "
1318                                     "expected %d as implied by size of PT_DYNAMIC segment in %s",
1319                                     i + 1, GetDynamicNum(), file->GetPath().c_str());
1320           return false;
1321         }
1322         break;
1323       }
1324     }
1325   }
1326 
1327   // Check for the existence of some sections.
1328   if (!CheckSectionsExist(file, error_msg)) {
1329     return false;
1330   }
1331 
1332   return true;
1333 }
1334 
1335 template <typename ElfTypes>
ValidPointer(const uint8_t * start) const1336 bool ElfFileImpl<ElfTypes>::ValidPointer(const uint8_t* start) const {
1337   for (const MemMap& segment : segments_) {
1338     if (segment.Begin() <= start && start < segment.End()) {
1339       return true;
1340     }
1341   }
1342   return false;
1343 }
1344 
1345 
1346 template <typename ElfTypes>
FindSectionByName(const std::string & name) const1347 typename ElfTypes::Shdr* ElfFileImpl<ElfTypes>::FindSectionByName(
1348     const std::string& name) const {
1349   CHECK(!program_header_only_);
1350   Elf_Shdr* shstrtab_sec = GetSectionNameStringSection();
1351   if (shstrtab_sec == nullptr) {
1352     return nullptr;
1353   }
1354   for (uint32_t i = 0; i < GetSectionHeaderNum(); i++) {
1355     Elf_Shdr* shdr = GetSectionHeader(i);
1356     if (shdr == nullptr) {
1357       return nullptr;
1358     }
1359     const char* sec_name = GetString(*shstrtab_sec, shdr->sh_name);
1360     if (sec_name == nullptr) {
1361       continue;
1362     }
1363     if (name == sec_name) {
1364       return shdr;
1365     }
1366   }
1367   return nullptr;
1368 }
1369 
1370 template <typename ElfTypes>
FixupDebugSections(Elf_Addr base_address_delta)1371 bool ElfFileImpl<ElfTypes>::FixupDebugSections(Elf_Addr base_address_delta) {
1372   if (base_address_delta == 0) {
1373     return true;
1374   }
1375   return ApplyOatPatchesTo(".debug_frame", base_address_delta) &&
1376          ApplyOatPatchesTo(".debug_info", base_address_delta) &&
1377          ApplyOatPatchesTo(".debug_line", base_address_delta);
1378 }
1379 
1380 template <typename ElfTypes>
ApplyOatPatchesTo(const char * target_section_name,Elf_Addr delta)1381 bool ElfFileImpl<ElfTypes>::ApplyOatPatchesTo(
1382     const char* target_section_name, Elf_Addr delta) {
1383   auto target_section = FindSectionByName(target_section_name);
1384   if (target_section == nullptr) {
1385     return true;
1386   }
1387   std::string patches_name = target_section_name + std::string(".oat_patches");
1388   auto patches_section = FindSectionByName(patches_name.c_str());
1389   if (patches_section == nullptr) {
1390     LOG(ERROR) << patches_name << " section not found.";
1391     return false;
1392   }
1393   if (patches_section->sh_type != SHT_OAT_PATCH) {
1394     LOG(ERROR) << "Unexpected type of " << patches_name;
1395     return false;
1396   }
1397   ApplyOatPatches(
1398       Begin() + patches_section->sh_offset,
1399       Begin() + patches_section->sh_offset + patches_section->sh_size,
1400       delta,
1401       Begin() + target_section->sh_offset,
1402       Begin() + target_section->sh_offset + target_section->sh_size);
1403   return true;
1404 }
1405 
1406 // Apply LEB128 encoded patches to given section.
1407 template <typename ElfTypes>
ApplyOatPatches(const uint8_t * patches,const uint8_t * patches_end,Elf_Addr delta,uint8_t * to_patch,const uint8_t * to_patch_end)1408 void ElfFileImpl<ElfTypes>::ApplyOatPatches(
1409     const uint8_t* patches, const uint8_t* patches_end, Elf_Addr delta,
1410     uint8_t* to_patch, const uint8_t* to_patch_end) {
1411   using UnalignedAddress __attribute__((__aligned__(1))) = Elf_Addr;
1412   while (patches < patches_end) {
1413     to_patch += DecodeUnsignedLeb128(&patches);
1414     DCHECK_LE(patches, patches_end) << "Unexpected end of patch list.";
1415     DCHECK_LT(to_patch, to_patch_end) << "Patch past the end of section.";
1416     *reinterpret_cast<UnalignedAddress*>(to_patch) += delta;
1417   }
1418 }
1419 
1420 template <typename ElfTypes>
Strip(File * file,std::string * error_msg)1421 bool ElfFileImpl<ElfTypes>::Strip(File* file, std::string* error_msg) {
1422   // ELF files produced by MCLinker look roughly like this
1423   //
1424   // +------------+
1425   // | Elf_Ehdr   | contains number of Elf_Shdr and offset to first
1426   // +------------+
1427   // | Elf_Phdr   | program headers
1428   // | Elf_Phdr   |
1429   // | ...        |
1430   // | Elf_Phdr   |
1431   // +------------+
1432   // | section    | mixture of needed and unneeded sections
1433   // +------------+
1434   // | section    |
1435   // +------------+
1436   // | ...        |
1437   // +------------+
1438   // | section    |
1439   // +------------+
1440   // | Elf_Shdr   | section headers
1441   // | Elf_Shdr   |
1442   // | ...        | contains offset to section start
1443   // | Elf_Shdr   |
1444   // +------------+
1445   //
1446   // To strip:
1447   // - leave the Elf_Ehdr and Elf_Phdr values in place.
1448   // - walk the sections making a new set of Elf_Shdr section headers for what we want to keep
1449   // - move the sections are keeping up to fill in gaps of sections we want to strip
1450   // - write new Elf_Shdr section headers to end of file, updating Elf_Ehdr
1451   // - truncate rest of file
1452   //
1453 
1454   std::vector<Elf_Shdr> section_headers;
1455   std::vector<Elf_Word> section_headers_original_indexes;
1456   section_headers.reserve(GetSectionHeaderNum());
1457 
1458 
1459   Elf_Shdr* string_section = GetSectionNameStringSection();
1460   CHECK(string_section != nullptr);
1461   for (Elf_Word i = 0; i < GetSectionHeaderNum(); i++) {
1462     Elf_Shdr* sh = GetSectionHeader(i);
1463     CHECK(sh != nullptr);
1464     const char* name = GetString(*string_section, sh->sh_name);
1465     if (name == nullptr) {
1466       CHECK_EQ(0U, i);
1467       section_headers.push_back(*sh);
1468       section_headers_original_indexes.push_back(0);
1469       continue;
1470     }
1471     if (android::base::StartsWith(name, ".debug")
1472         || (strcmp(name, ".strtab") == 0)
1473         || (strcmp(name, ".symtab") == 0)) {
1474       continue;
1475     }
1476     section_headers.push_back(*sh);
1477     section_headers_original_indexes.push_back(i);
1478   }
1479   CHECK_NE(0U, section_headers.size());
1480   CHECK_EQ(section_headers.size(), section_headers_original_indexes.size());
1481 
1482   // section 0 is the null section, sections start at offset of first section
1483   CHECK(GetSectionHeader(1) != nullptr);
1484   Elf_Off offset = GetSectionHeader(1)->sh_offset;
1485   for (size_t i = 1; i < section_headers.size(); i++) {
1486     Elf_Shdr& new_sh = section_headers[i];
1487     Elf_Shdr* old_sh = GetSectionHeader(section_headers_original_indexes[i]);
1488     CHECK(old_sh != nullptr);
1489     CHECK_EQ(new_sh.sh_name, old_sh->sh_name);
1490     if (old_sh->sh_addralign > 1) {
1491       offset = RoundUp(offset, old_sh->sh_addralign);
1492     }
1493     if (old_sh->sh_offset == offset) {
1494       // already in place
1495       offset += old_sh->sh_size;
1496       continue;
1497     }
1498     // shift section earlier
1499     memmove(Begin() + offset,
1500             Begin() + old_sh->sh_offset,
1501             old_sh->sh_size);
1502     new_sh.sh_offset = offset;
1503     offset += old_sh->sh_size;
1504   }
1505 
1506   Elf_Off shoff = offset;
1507   size_t section_headers_size_in_bytes = section_headers.size() * sizeof(Elf_Shdr);
1508   memcpy(Begin() + offset, &section_headers[0], section_headers_size_in_bytes);
1509   offset += section_headers_size_in_bytes;
1510 
1511   GetHeader().e_shnum = section_headers.size();
1512   GetHeader().e_shoff = shoff;
1513   int result = ftruncate(file->Fd(), offset);
1514   if (result != 0) {
1515     *error_msg = StringPrintf("Failed to truncate while stripping ELF file: '%s': %s",
1516                               file->GetPath().c_str(), strerror(errno));
1517     return false;
1518   }
1519   return true;
1520 }
1521 
1522 static const bool DEBUG_FIXUP = false;
1523 
1524 template <typename ElfTypes>
Fixup(Elf_Addr base_address)1525 bool ElfFileImpl<ElfTypes>::Fixup(Elf_Addr base_address) {
1526   if (!FixupDynamic(base_address)) {
1527     LOG(WARNING) << "Failed to fixup .dynamic in " << file_path_;
1528     return false;
1529   }
1530   if (!FixupSectionHeaders(base_address)) {
1531     LOG(WARNING) << "Failed to fixup section headers in " << file_path_;
1532     return false;
1533   }
1534   if (!FixupProgramHeaders(base_address)) {
1535     LOG(WARNING) << "Failed to fixup program headers in " << file_path_;
1536     return false;
1537   }
1538   if (!FixupSymbols(base_address, true)) {
1539     LOG(WARNING) << "Failed to fixup .dynsym in " << file_path_;
1540     return false;
1541   }
1542   if (!FixupSymbols(base_address, false)) {
1543     LOG(WARNING) << "Failed to fixup .symtab in " << file_path_;
1544     return false;
1545   }
1546   if (!FixupRelocations(base_address)) {
1547     LOG(WARNING) << "Failed to fixup .rel.dyn in " << file_path_;
1548     return false;
1549   }
1550   static_assert(sizeof(Elf_Off) >= sizeof(base_address), "Potentially losing precision.");
1551   if (!FixupDebugSections(static_cast<Elf_Off>(base_address))) {
1552     LOG(WARNING) << "Failed to fixup debug sections in " << file_path_;
1553     return false;
1554   }
1555   return true;
1556 }
1557 
1558 template <typename ElfTypes>
FixupDynamic(Elf_Addr base_address)1559 bool ElfFileImpl<ElfTypes>::FixupDynamic(Elf_Addr base_address) {
1560   for (Elf_Word i = 0; i < GetDynamicNum(); i++) {
1561     Elf_Dyn& elf_dyn = GetDynamic(i);
1562     Elf_Word d_tag = elf_dyn.d_tag;
1563     if (IsDynamicSectionPointer(d_tag, GetHeader().e_machine)) {
1564       Elf_Addr d_ptr = elf_dyn.d_un.d_ptr;
1565       if (DEBUG_FIXUP) {
1566         LOG(INFO) << StringPrintf("In %s moving Elf_Dyn[%d] from 0x%" PRIx64 " to 0x%" PRIx64,
1567                                   file_path_.c_str(), i,
1568                                   static_cast<uint64_t>(d_ptr),
1569                                   static_cast<uint64_t>(d_ptr + base_address));
1570       }
1571       d_ptr += base_address;
1572       elf_dyn.d_un.d_ptr = d_ptr;
1573     }
1574   }
1575   return true;
1576 }
1577 
1578 template <typename ElfTypes>
FixupSectionHeaders(Elf_Addr base_address)1579 bool ElfFileImpl<ElfTypes>::FixupSectionHeaders(Elf_Addr base_address) {
1580   for (Elf_Word i = 0; i < GetSectionHeaderNum(); i++) {
1581     Elf_Shdr* sh = GetSectionHeader(i);
1582     CHECK(sh != nullptr);
1583     // 0 implies that the section will not exist in the memory of the process
1584     if (sh->sh_addr == 0) {
1585       continue;
1586     }
1587     if (DEBUG_FIXUP) {
1588       LOG(INFO) << StringPrintf("In %s moving Elf_Shdr[%d] from 0x%" PRIx64 " to 0x%" PRIx64,
1589                                 file_path_.c_str(), i,
1590                                 static_cast<uint64_t>(sh->sh_addr),
1591                                 static_cast<uint64_t>(sh->sh_addr + base_address));
1592     }
1593     sh->sh_addr += base_address;
1594   }
1595   return true;
1596 }
1597 
1598 template <typename ElfTypes>
FixupProgramHeaders(Elf_Addr base_address)1599 bool ElfFileImpl<ElfTypes>::FixupProgramHeaders(Elf_Addr base_address) {
1600   // TODO: ELFObjectFile doesn't have give to Elf_Phdr, so we do that ourselves for now.
1601   for (Elf_Word i = 0; i < GetProgramHeaderNum(); i++) {
1602     Elf_Phdr* ph = GetProgramHeader(i);
1603     CHECK(ph != nullptr);
1604     CHECK_EQ(ph->p_vaddr, ph->p_paddr) << file_path_ << " i=" << i;
1605     CHECK((ph->p_align == 0) || (0 == ((ph->p_vaddr - ph->p_offset) & (ph->p_align - 1))))
1606         << file_path_ << " i=" << i;
1607     if (DEBUG_FIXUP) {
1608       LOG(INFO) << StringPrintf("In %s moving Elf_Phdr[%d] from 0x%" PRIx64 " to 0x%" PRIx64,
1609                                 file_path_.c_str(), i,
1610                                 static_cast<uint64_t>(ph->p_vaddr),
1611                                 static_cast<uint64_t>(ph->p_vaddr + base_address));
1612     }
1613     ph->p_vaddr += base_address;
1614     ph->p_paddr += base_address;
1615     CHECK((ph->p_align == 0) || (0 == ((ph->p_vaddr - ph->p_offset) & (ph->p_align - 1))))
1616         << file_path_ << " i=" << i;
1617   }
1618   return true;
1619 }
1620 
1621 template <typename ElfTypes>
FixupSymbols(Elf_Addr base_address,bool dynamic)1622 bool ElfFileImpl<ElfTypes>::FixupSymbols(Elf_Addr base_address, bool dynamic) {
1623   Elf_Word section_type = dynamic ? SHT_DYNSYM : SHT_SYMTAB;
1624   // TODO: Unfortunate ELFObjectFile has protected symbol access, so use ElfFile
1625   Elf_Shdr* symbol_section = FindSectionByType(section_type);
1626   if (symbol_section == nullptr) {
1627     // file is missing optional .symtab
1628     CHECK(!dynamic) << file_path_;
1629     return true;
1630   }
1631   for (uint32_t i = 0; i < GetSymbolNum(*symbol_section); i++) {
1632     Elf_Sym* symbol = GetSymbol(section_type, i);
1633     CHECK(symbol != nullptr);
1634     if (symbol->st_value != 0) {
1635       if (DEBUG_FIXUP) {
1636         LOG(INFO) << StringPrintf("In %s moving Elf_Sym[%d] from 0x%" PRIx64 " to 0x%" PRIx64,
1637                                   file_path_.c_str(), i,
1638                                   static_cast<uint64_t>(symbol->st_value),
1639                                   static_cast<uint64_t>(symbol->st_value + base_address));
1640       }
1641       symbol->st_value += base_address;
1642     }
1643   }
1644   return true;
1645 }
1646 
1647 template <typename ElfTypes>
FixupRelocations(Elf_Addr base_address)1648 bool ElfFileImpl<ElfTypes>::FixupRelocations(Elf_Addr base_address) {
1649   for (Elf_Word i = 0; i < GetSectionHeaderNum(); i++) {
1650     Elf_Shdr* sh = GetSectionHeader(i);
1651     CHECK(sh != nullptr);
1652     if (sh->sh_type == SHT_REL) {
1653       for (uint32_t j = 0; j < GetRelNum(*sh); j++) {
1654         Elf_Rel& rel = GetRel(*sh, j);
1655         if (DEBUG_FIXUP) {
1656           LOG(INFO) << StringPrintf("In %s moving Elf_Rel[%d] from 0x%" PRIx64 " to 0x%" PRIx64,
1657                                     file_path_.c_str(), j,
1658                                     static_cast<uint64_t>(rel.r_offset),
1659                                     static_cast<uint64_t>(rel.r_offset + base_address));
1660         }
1661         rel.r_offset += base_address;
1662       }
1663     } else if (sh->sh_type == SHT_RELA) {
1664       for (uint32_t j = 0; j < GetRelaNum(*sh); j++) {
1665         Elf_Rela& rela = GetRela(*sh, j);
1666         if (DEBUG_FIXUP) {
1667           LOG(INFO) << StringPrintf("In %s moving Elf_Rela[%d] from 0x%" PRIx64 " to 0x%" PRIx64,
1668                                     file_path_.c_str(), j,
1669                                     static_cast<uint64_t>(rela.r_offset),
1670                                     static_cast<uint64_t>(rela.r_offset + base_address));
1671         }
1672         rela.r_offset += base_address;
1673       }
1674     }
1675   }
1676   return true;
1677 }
1678 
1679 // Explicit instantiations
1680 template class ElfFileImpl<ElfTypes32>;
1681 template class ElfFileImpl<ElfTypes64>;
1682 
ElfFile(ElfFileImpl32 * elf32)1683 ElfFile::ElfFile(ElfFileImpl32* elf32) : elf32_(elf32), elf64_(nullptr) {
1684 }
1685 
ElfFile(ElfFileImpl64 * elf64)1686 ElfFile::ElfFile(ElfFileImpl64* elf64) : elf32_(nullptr), elf64_(elf64) {
1687 }
1688 
~ElfFile()1689 ElfFile::~ElfFile() {
1690   // Should never have 32 and 64-bit impls.
1691   CHECK_NE(elf32_.get() == nullptr, elf64_.get() == nullptr);
1692 }
1693 
Open(File * file,bool writable,bool program_header_only,bool low_4gb,std::string * error_msg)1694 ElfFile* ElfFile::Open(File* file,
1695                        bool writable,
1696                        bool program_header_only,
1697                        bool low_4gb,
1698                        /*out*/std::string* error_msg) {
1699   if (file->GetLength() < EI_NIDENT) {
1700     *error_msg = StringPrintf("File %s is too short to be a valid ELF file",
1701                               file->GetPath().c_str());
1702     return nullptr;
1703   }
1704   MemMap map = MemMap::MapFile(EI_NIDENT,
1705                                PROT_READ,
1706                                MAP_PRIVATE,
1707                                file->Fd(),
1708                                0,
1709                                low_4gb,
1710                                file->GetPath().c_str(),
1711                                error_msg);
1712   if (!map.IsValid() || map.Size() != EI_NIDENT) {
1713     return nullptr;
1714   }
1715   uint8_t* header = map.Begin();
1716   if (header[EI_CLASS] == ELFCLASS64) {
1717     ElfFileImpl64* elf_file_impl = ElfFileImpl64::Open(file,
1718                                                        writable,
1719                                                        program_header_only,
1720                                                        low_4gb,
1721                                                        error_msg);
1722     if (elf_file_impl == nullptr) {
1723       return nullptr;
1724     }
1725     return new ElfFile(elf_file_impl);
1726   } else if (header[EI_CLASS] == ELFCLASS32) {
1727     ElfFileImpl32* elf_file_impl = ElfFileImpl32::Open(file,
1728                                                        writable,
1729                                                        program_header_only,
1730                                                        low_4gb,
1731                                                        error_msg);
1732     if (elf_file_impl == nullptr) {
1733       return nullptr;
1734     }
1735     return new ElfFile(elf_file_impl);
1736   } else {
1737     *error_msg = StringPrintf("Failed to find expected EI_CLASS value %d or %d in %s, found %d",
1738                               ELFCLASS32, ELFCLASS64,
1739                               file->GetPath().c_str(),
1740                               header[EI_CLASS]);
1741     return nullptr;
1742   }
1743 }
1744 
Open(File * file,int mmap_prot,int mmap_flags,std::string * error_msg)1745 ElfFile* ElfFile::Open(File* file, int mmap_prot, int mmap_flags, /*out*/std::string* error_msg) {
1746   // low_4gb support not required for this path.
1747   constexpr bool low_4gb = false;
1748   if (file->GetLength() < EI_NIDENT) {
1749     *error_msg = StringPrintf("File %s is too short to be a valid ELF file",
1750                               file->GetPath().c_str());
1751     return nullptr;
1752   }
1753   MemMap map = MemMap::MapFile(EI_NIDENT,
1754                                PROT_READ,
1755                                MAP_PRIVATE,
1756                                file->Fd(),
1757                                /* start= */ 0,
1758                                low_4gb,
1759                                file->GetPath().c_str(),
1760                                error_msg);
1761   if (!map.IsValid() || map.Size() != EI_NIDENT) {
1762     return nullptr;
1763   }
1764   uint8_t* header = map.Begin();
1765   if (header[EI_CLASS] == ELFCLASS64) {
1766     ElfFileImpl64* elf_file_impl = ElfFileImpl64::Open(file,
1767                                                        mmap_prot,
1768                                                        mmap_flags,
1769                                                        low_4gb,
1770                                                        error_msg);
1771     if (elf_file_impl == nullptr) {
1772       return nullptr;
1773     }
1774     return new ElfFile(elf_file_impl);
1775   } else if (header[EI_CLASS] == ELFCLASS32) {
1776     ElfFileImpl32* elf_file_impl = ElfFileImpl32::Open(file,
1777                                                        mmap_prot,
1778                                                        mmap_flags,
1779                                                        low_4gb,
1780                                                        error_msg);
1781     if (elf_file_impl == nullptr) {
1782       return nullptr;
1783     }
1784     return new ElfFile(elf_file_impl);
1785   } else {
1786     *error_msg = StringPrintf("Failed to find expected EI_CLASS value %d or %d in %s, found %d",
1787                               ELFCLASS32, ELFCLASS64,
1788                               file->GetPath().c_str(),
1789                               header[EI_CLASS]);
1790     return nullptr;
1791   }
1792 }
1793 
1794 #define DELEGATE_TO_IMPL(func, ...) \
1795   if (elf64_.get() != nullptr) { \
1796     return elf64_->func(__VA_ARGS__); \
1797   } else { \
1798     DCHECK(elf32_.get() != nullptr); \
1799     return elf32_->func(__VA_ARGS__); \
1800   }
1801 
Load(File * file,bool executable,bool low_4gb,MemMap * reservation,std::string * error_msg)1802 bool ElfFile::Load(File* file,
1803                    bool executable,
1804                    bool low_4gb,
1805                    /*inout*/MemMap* reservation,
1806                    /*out*/std::string* error_msg) {
1807   DELEGATE_TO_IMPL(Load, file, executable, low_4gb, reservation, error_msg);
1808 }
1809 
FindDynamicSymbolAddress(const std::string & symbol_name) const1810 const uint8_t* ElfFile::FindDynamicSymbolAddress(const std::string& symbol_name) const {
1811   DELEGATE_TO_IMPL(FindDynamicSymbolAddress, symbol_name);
1812 }
1813 
Size() const1814 size_t ElfFile::Size() const {
1815   DELEGATE_TO_IMPL(Size);
1816 }
1817 
Begin() const1818 uint8_t* ElfFile::Begin() const {
1819   DELEGATE_TO_IMPL(Begin);
1820 }
1821 
End() const1822 uint8_t* ElfFile::End() const {
1823   DELEGATE_TO_IMPL(End);
1824 }
1825 
GetFilePath() const1826 const std::string& ElfFile::GetFilePath() const {
1827   DELEGATE_TO_IMPL(GetFilePath);
1828 }
1829 
GetSectionOffsetAndSize(const char * section_name,uint64_t * offset,uint64_t * size) const1830 bool ElfFile::GetSectionOffsetAndSize(const char* section_name, uint64_t* offset,
1831                                       uint64_t* size) const {
1832   if (elf32_.get() == nullptr) {
1833     CHECK(elf64_.get() != nullptr);
1834 
1835     Elf64_Shdr *shdr = elf64_->FindSectionByName(section_name);
1836     if (shdr == nullptr) {
1837       return false;
1838     }
1839     if (offset != nullptr) {
1840       *offset = shdr->sh_offset;
1841     }
1842     if (size != nullptr) {
1843       *size = shdr->sh_size;
1844     }
1845     return true;
1846   } else {
1847     Elf32_Shdr *shdr = elf32_->FindSectionByName(section_name);
1848     if (shdr == nullptr) {
1849       return false;
1850     }
1851     if (offset != nullptr) {
1852       *offset = shdr->sh_offset;
1853     }
1854     if (size != nullptr) {
1855       *size = shdr->sh_size;
1856     }
1857     return true;
1858   }
1859 }
1860 
HasSection(const std::string & name) const1861 bool ElfFile::HasSection(const std::string& name) const {
1862   if (elf64_.get() != nullptr) {
1863     return elf64_->FindSectionByName(name) != nullptr;
1864   } else {
1865     return elf32_->FindSectionByName(name) != nullptr;
1866   }
1867 }
1868 
FindSymbolAddress(unsigned section_type,const std::string & symbol_name,bool build_map)1869 uint64_t ElfFile::FindSymbolAddress(unsigned section_type,
1870                                     const std::string& symbol_name,
1871                                     bool build_map) {
1872   DELEGATE_TO_IMPL(FindSymbolAddress, section_type, symbol_name, build_map);
1873 }
1874 
GetLoadedSize(size_t * size,std::string * error_msg) const1875 bool ElfFile::GetLoadedSize(size_t* size, std::string* error_msg) const {
1876   DELEGATE_TO_IMPL(GetLoadedSize, size, error_msg);
1877 }
1878 
Strip(File * file,std::string * error_msg)1879 bool ElfFile::Strip(File* file, std::string* error_msg) {
1880   std::unique_ptr<ElfFile> elf_file(ElfFile::Open(file, true, false, /*low_4gb=*/false, error_msg));
1881   if (elf_file.get() == nullptr) {
1882     return false;
1883   }
1884 
1885   if (elf_file->elf64_.get() != nullptr) {
1886     return elf_file->elf64_->Strip(file, error_msg);
1887   } else {
1888     return elf_file->elf32_->Strip(file, error_msg);
1889   }
1890 }
1891 
Fixup(uint64_t base_address)1892 bool ElfFile::Fixup(uint64_t base_address) {
1893   if (elf64_.get() != nullptr) {
1894     return elf64_->Fixup(static_cast<Elf64_Addr>(base_address));
1895   } else {
1896     DCHECK(elf32_.get() != nullptr);
1897     CHECK(IsUint<32>(base_address)) << std::hex << base_address;
1898     return elf32_->Fixup(static_cast<Elf32_Addr>(base_address));
1899   }
1900   DELEGATE_TO_IMPL(Fixup, base_address);
1901 }
1902 
1903 }  // namespace art
1904