ElfFile should protect itself from bad input
Bug: 13207536
Change-Id: Ia0406a7e8fce4030570503471e003d4da581652f
diff --git a/runtime/elf_file.cc b/runtime/elf_file.cc
index e4e58b8..f16db8b 100644
--- a/runtime/elf_file.cc
+++ b/runtime/elf_file.cc
@@ -22,10 +22,10 @@
namespace art {
-ElfFile::ElfFile()
- : file_(NULL),
- writable_(false),
- program_header_only_(false),
+ElfFile::ElfFile(File* file, bool writable, bool program_header_only)
+ : file_(file),
+ writable_(writable),
+ program_header_only_(program_header_only),
header_(NULL),
base_address_(NULL),
program_headers_start_(NULL),
@@ -38,23 +38,20 @@
dynstr_section_start_(NULL),
hash_section_start_(NULL),
symtab_symbol_table_(NULL),
- dynsym_symbol_table_(NULL) {}
+ dynsym_symbol_table_(NULL) {
+ CHECK(file != NULL);
+}
ElfFile* ElfFile::Open(File* file, bool writable, bool program_header_only,
std::string* error_msg) {
- UniquePtr<ElfFile> elf_file(new ElfFile());
- if (!elf_file->Setup(file, writable, program_header_only, error_msg)) {
+ UniquePtr<ElfFile> elf_file(new ElfFile(file, writable, program_header_only));
+ if (!elf_file->Setup(error_msg)) {
return nullptr;
}
return elf_file.release();
}
-bool ElfFile::Setup(File* file, bool writable, bool program_header_only, std::string* error_msg) {
- CHECK(file != NULL);
- file_ = file;
- writable_ = writable;
- program_header_only_ = program_header_only;
-
+bool ElfFile::Setup(std::string* error_msg) {
int prot;
int flags;
if (writable_) {
@@ -79,7 +76,7 @@
return false;
}
- if (program_header_only) {
+ if (program_header_only_) {
// first just map ELF header to get program header size information
size_t elf_header_size = sizeof(Elf32_Ehdr);
if (!SetMap(MemMap::MapFile(elf_header_size, prot, flags, file_->Fd(), 0,
@@ -114,7 +111,7 @@
// Either way, the program header is relative to the elf header
program_headers_start_ = Begin() + GetHeader().e_phoff;
- if (!program_header_only) {
+ if (!program_header_only_) {
// Setup section headers.
section_headers_start_ = Begin() + GetHeader().e_shoff;
@@ -192,7 +189,8 @@
|| (ELFMAG1 != header_->e_ident[EI_MAG1])
|| (ELFMAG2 != header_->e_ident[EI_MAG2])
|| (ELFMAG3 != header_->e_ident[EI_MAG3])) {
- *error_msg = StringPrintf("Failed to find ELF magic in %s: %c%c%c%c",
+ *error_msg = StringPrintf("Failed to find ELF magic value %d %d %d %d in %s, found %d %d %d %d",
+ ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3,
file_->GetPath().c_str(),
header_->e_ident[EI_MAG0],
header_->e_ident[EI_MAG1],
@@ -200,61 +198,142 @@
header_->e_ident[EI_MAG3]);
return false;
}
+ if (ELFCLASS32 != header_->e_ident[EI_CLASS]) {
+ *error_msg = StringPrintf("Failed to find expected EI_CLASS value %d in %s, found %d",
+ ELFCLASS32,
+ file_->GetPath().c_str(),
+ header_->e_ident[EI_CLASS]);
+ return false;
+ }
+ if (ELFDATA2LSB != header_->e_ident[EI_DATA]) {
+ *error_msg = StringPrintf("Failed to find expected EI_DATA value %d in %s, found %d",
+ ELFDATA2LSB,
+ file_->GetPath().c_str(),
+ header_->e_ident[EI_CLASS]);
+ return false;
+ }
+ if (EV_CURRENT != header_->e_ident[EI_VERSION]) {
+ *error_msg = StringPrintf("Failed to find expected EI_VERSION value %d in %s, found %d",
+ EV_CURRENT,
+ file_->GetPath().c_str(),
+ header_->e_ident[EI_CLASS]);
+ return false;
+ }
+ if (ET_DYN != header_->e_type) {
+ *error_msg = StringPrintf("Failed to find expected e_type value %d in %s, found %d",
+ ET_DYN,
+ file_->GetPath().c_str(),
+ header_->e_type);
+ return false;
+ }
+ if (EV_CURRENT != header_->e_version) {
+ *error_msg = StringPrintf("Failed to find expected e_version value %d in %s, found %d",
+ EV_CURRENT,
+ file_->GetPath().c_str(),
+ header_->e_version);
+ return false;
+ }
+ if (0 != header_->e_entry) {
+ *error_msg = StringPrintf("Failed to find expected e_entry value %d in %s, found %d",
+ 0,
+ file_->GetPath().c_str(),
+ header_->e_entry);
+ return false;
+ }
+ if (0 == header_->e_phoff) {
+ *error_msg = StringPrintf("Failed to find non-zero e_phoff value in %s",
+ file_->GetPath().c_str());
+ return false;
+ }
+ if (0 == header_->e_shoff) {
+ *error_msg = StringPrintf("Failed to find non-zero e_shoff value in %s",
+ file_->GetPath().c_str());
+ return false;
+ }
+ if (0 == header_->e_ehsize) {
+ *error_msg = StringPrintf("Failed to find non-zero e_ehsize value in %s",
+ file_->GetPath().c_str());
+ return false;
+ }
+ if (0 == header_->e_phentsize) {
+ *error_msg = StringPrintf("Failed to find non-zero e_phentsize value in %s",
+ file_->GetPath().c_str());
+ return false;
+ }
+ if (0 == header_->e_phnum) {
+ *error_msg = StringPrintf("Failed to find non-zero e_phnum value in %s",
+ file_->GetPath().c_str());
+ return false;
+ }
+ if (0 == header_->e_shentsize) {
+ *error_msg = StringPrintf("Failed to find non-zero e_shentsize value in %s",
+ file_->GetPath().c_str());
+ return false;
+ }
+ if (0 == header_->e_shnum) {
+ *error_msg = StringPrintf("Failed to find non-zero e_shnum value in %s",
+ file_->GetPath().c_str());
+ return false;
+ }
+ if (0 == header_->e_shstrndx) {
+ *error_msg = StringPrintf("Failed to find non-zero e_shstrndx value in %s",
+ file_->GetPath().c_str());
+ return false;
+ }
+ if (header_->e_shstrndx >= header_->e_shnum) {
+ *error_msg = StringPrintf("Failed to find e_shnum value %d less than %d in %s",
+ header_->e_shstrndx,
+ header_->e_shnum,
+ file_->GetPath().c_str());
+ return false;
+ }
-
- // TODO: remove these static_casts from enum when using -std=gnu++0x
- CHECK_EQ(static_cast<unsigned char>(ELFCLASS32), header_->e_ident[EI_CLASS]) << file_->GetPath();
- CHECK_EQ(static_cast<unsigned char>(ELFDATA2LSB), header_->e_ident[EI_DATA]) << file_->GetPath();
- CHECK_EQ(static_cast<unsigned char>(EV_CURRENT), header_->e_ident[EI_VERSION]) << file_->GetPath();
-
- // TODO: remove these static_casts from enum when using -std=gnu++0x
- CHECK_EQ(static_cast<Elf32_Half>(ET_DYN), header_->e_type) << file_->GetPath();
- CHECK_EQ(static_cast<Elf32_Word>(EV_CURRENT), header_->e_version) << file_->GetPath();
- CHECK_EQ(0U, header_->e_entry) << file_->GetPath();
-
- CHECK_NE(0U, header_->e_phoff) << file_->GetPath();
- CHECK_NE(0U, header_->e_shoff) << file_->GetPath();
- CHECK_NE(0U, header_->e_ehsize) << file_->GetPath();
- CHECK_NE(0U, header_->e_phentsize) << file_->GetPath();
- CHECK_NE(0U, header_->e_phnum) << file_->GetPath();
- CHECK_NE(0U, header_->e_shentsize) << file_->GetPath();
- CHECK_NE(0U, header_->e_shnum) << file_->GetPath();
- CHECK_NE(0U, header_->e_shstrndx) << file_->GetPath();
- CHECK_GE(header_->e_shnum, header_->e_shstrndx) << file_->GetPath();
if (!program_header_only_) {
- CHECK_GT(Size(), header_->e_phoff) << file_->GetPath();
- CHECK_GT(Size(), header_->e_shoff) << file_->GetPath();
+ if (header_->e_phoff >= Size()) {
+ *error_msg = StringPrintf("Failed to find e_phoff value %d less than %d in %s",
+ header_->e_phoff,
+ Size(),
+ file_->GetPath().c_str());
+ return false;
+ }
+ if (header_->e_shoff >= Size()) {
+ *error_msg = StringPrintf("Failed to find e_shoff value %d less than %d in %s",
+ header_->e_shoff,
+ Size(),
+ file_->GetPath().c_str());
+ return false;
+ }
}
return true;
}
-Elf32_Ehdr& ElfFile::GetHeader() {
+Elf32_Ehdr& ElfFile::GetHeader() const {
CHECK(header_ != NULL);
return *header_;
}
-byte* ElfFile::GetProgramHeadersStart() {
+byte* ElfFile::GetProgramHeadersStart() const {
CHECK(program_headers_start_ != NULL);
return program_headers_start_;
}
-byte* ElfFile::GetSectionHeadersStart() {
+byte* ElfFile::GetSectionHeadersStart() const {
CHECK(section_headers_start_ != NULL);
return section_headers_start_;
}
-Elf32_Phdr& ElfFile::GetDynamicProgramHeader() {
+Elf32_Phdr& ElfFile::GetDynamicProgramHeader() const {
CHECK(dynamic_program_header_ != NULL);
return *dynamic_program_header_;
}
-Elf32_Dyn* ElfFile::GetDynamicSectionStart() {
+Elf32_Dyn* ElfFile::GetDynamicSectionStart() const {
CHECK(dynamic_section_start_ != NULL);
return dynamic_section_start_;
}
-Elf32_Sym* ElfFile::GetSymbolSectionStart(Elf32_Word section_type) {
+Elf32_Sym* ElfFile::GetSymbolSectionStart(Elf32_Word section_type) const {
CHECK(IsSymbolSectionType(section_type)) << file_->GetPath() << " " << section_type;
Elf32_Sym* symbol_section_start;
switch (section_type) {
@@ -275,7 +354,7 @@
return symbol_section_start;
}
-const char* ElfFile::GetStringSectionStart(Elf32_Word section_type) {
+const char* ElfFile::GetStringSectionStart(Elf32_Word section_type) const {
CHECK(IsSymbolSectionType(section_type)) << file_->GetPath() << " " << section_type;
const char* string_section_start;
switch (section_type) {
@@ -296,7 +375,7 @@
return string_section_start;
}
-const char* ElfFile::GetString(Elf32_Word section_type, Elf32_Word i) {
+const char* ElfFile::GetString(Elf32_Word section_type, Elf32_Word i) const {
CHECK(IsSymbolSectionType(section_type)) << file_->GetPath() << " " << section_type;
if (i == 0) {
return NULL;
@@ -306,43 +385,43 @@
return string;
}
-Elf32_Word* ElfFile::GetHashSectionStart() {
+Elf32_Word* ElfFile::GetHashSectionStart() const {
CHECK(hash_section_start_ != NULL);
return hash_section_start_;
}
-Elf32_Word ElfFile::GetHashBucketNum() {
+Elf32_Word ElfFile::GetHashBucketNum() const {
return GetHashSectionStart()[0];
}
-Elf32_Word ElfFile::GetHashChainNum() {
+Elf32_Word ElfFile::GetHashChainNum() const {
return GetHashSectionStart()[1];
}
-Elf32_Word ElfFile::GetHashBucket(size_t i) {
+Elf32_Word ElfFile::GetHashBucket(size_t i) const {
CHECK_LT(i, GetHashBucketNum());
// 0 is nbucket, 1 is nchain
return GetHashSectionStart()[2 + i];
}
-Elf32_Word ElfFile::GetHashChain(size_t i) {
+Elf32_Word ElfFile::GetHashChain(size_t i) const {
CHECK_LT(i, GetHashChainNum());
// 0 is nbucket, 1 is nchain, & chains are after buckets
return GetHashSectionStart()[2 + GetHashBucketNum() + i];
}
-Elf32_Word ElfFile::GetProgramHeaderNum() {
+Elf32_Word ElfFile::GetProgramHeaderNum() const {
return GetHeader().e_phnum;
}
-Elf32_Phdr& ElfFile::GetProgramHeader(Elf32_Word i) {
+Elf32_Phdr& ElfFile::GetProgramHeader(Elf32_Word i) const {
CHECK_LT(i, GetProgramHeaderNum()) << file_->GetPath();
byte* program_header = GetProgramHeadersStart() + (i * GetHeader().e_phentsize);
CHECK_LT(program_header, End()) << file_->GetPath();
return *reinterpret_cast<Elf32_Phdr*>(program_header);
}
-Elf32_Phdr* ElfFile::FindProgamHeaderByType(Elf32_Word type) {
+Elf32_Phdr* ElfFile::FindProgamHeaderByType(Elf32_Word type) const {
for (Elf32_Word i = 0; i < GetProgramHeaderNum(); i++) {
Elf32_Phdr& program_header = GetProgramHeader(i);
if (program_header.p_type == type) {
@@ -352,11 +431,11 @@
return NULL;
}
-Elf32_Word ElfFile::GetSectionHeaderNum() {
+Elf32_Word ElfFile::GetSectionHeaderNum() const {
return GetHeader().e_shnum;
}
-Elf32_Shdr& ElfFile::GetSectionHeader(Elf32_Word i) {
+Elf32_Shdr& ElfFile::GetSectionHeader(Elf32_Word i) const {
// Can only access arbitrary sections when we have the whole file, not just program header.
// Even if we Load(), it doesn't bring in all the sections.
CHECK(!program_header_only_) << file_->GetPath();
@@ -366,7 +445,7 @@
return *reinterpret_cast<Elf32_Shdr*>(section_header);
}
-Elf32_Shdr* ElfFile::FindSectionByType(Elf32_Word type) {
+Elf32_Shdr* ElfFile::FindSectionByType(Elf32_Word type) const {
// Can only access arbitrary sections when we have the whole file, not just program header.
// We could change this to switch on known types if they were detected during loading.
CHECK(!program_header_only_) << file_->GetPath();
@@ -393,11 +472,11 @@
return h;
}
-Elf32_Shdr& ElfFile::GetSectionNameStringSection() {
+Elf32_Shdr& ElfFile::GetSectionNameStringSection() const {
return GetSectionHeader(GetHeader().e_shstrndx);
}
-byte* ElfFile::FindDynamicSymbolAddress(const std::string& symbol_name) {
+const byte* ElfFile::FindDynamicSymbolAddress(const std::string& symbol_name) const {
Elf32_Word hash = elfhash(symbol_name.c_str());
Elf32_Word bucket_index = hash % GetHashBucketNum();
Elf32_Word symbol_and_chain_index = GetHashBucket(bucket_index);
@@ -416,14 +495,15 @@
return ((section_type == SHT_SYMTAB) || (section_type == SHT_DYNSYM));
}
-Elf32_Word ElfFile::GetSymbolNum(Elf32_Shdr& section_header) {
- CHECK(IsSymbolSectionType(section_header.sh_type)) << file_->GetPath() << " " << section_header.sh_type;
+Elf32_Word ElfFile::GetSymbolNum(Elf32_Shdr& section_header) const {
+ CHECK(IsSymbolSectionType(section_header.sh_type))
+ << file_->GetPath() << " " << section_header.sh_type;
CHECK_NE(0U, section_header.sh_entsize) << file_->GetPath();
return section_header.sh_size / section_header.sh_entsize;
}
Elf32_Sym& ElfFile::GetSymbol(Elf32_Word section_type,
- Elf32_Word i) {
+ Elf32_Word i) const {
return *(GetSymbolSectionStart(section_type) + i);
}
@@ -467,7 +547,8 @@
if (name == NULL) {
continue;
}
- std::pair<SymbolTable::iterator, bool> result = (*symbol_table)->insert(std::make_pair(name, &symbol));
+ std::pair<SymbolTable::iterator, bool> result =
+ (*symbol_table)->insert(std::make_pair(name, &symbol));
if (!result.second) {
// If a duplicate, make sure it has the same logical value. Seen on x86.
CHECK_EQ(symbol.st_value, result.first->second->st_value);
@@ -504,8 +585,8 @@
}
Elf32_Addr ElfFile::FindSymbolAddress(Elf32_Word section_type,
- const std::string& symbol_name,
- bool build_map) {
+ const std::string& symbol_name,
+ bool build_map) {
Elf32_Sym* symbol = FindSymbolByName(section_type, symbol_name, build_map);
if (symbol == NULL) {
return 0;
@@ -513,7 +594,7 @@
return symbol->st_value;
}
-const char* ElfFile::GetString(Elf32_Shdr& string_section, Elf32_Word i) {
+const char* ElfFile::GetString(Elf32_Shdr& string_section, Elf32_Word i) const {
CHECK(!program_header_only_) << file_->GetPath();
// TODO: remove this static_cast from enum when using -std=gnu++0x
CHECK_EQ(static_cast<Elf32_Word>(SHT_STRTAB), string_section.sh_type) << file_->GetPath();
@@ -527,16 +608,16 @@
return reinterpret_cast<const char*>(string);
}
-Elf32_Word ElfFile::GetDynamicNum() {
+Elf32_Word ElfFile::GetDynamicNum() const {
return GetDynamicProgramHeader().p_filesz / sizeof(Elf32_Dyn);
}
-Elf32_Dyn& ElfFile::GetDynamic(Elf32_Word i) {
+Elf32_Dyn& ElfFile::GetDynamic(Elf32_Word i) const {
CHECK_LT(i, GetDynamicNum()) << file_->GetPath();
return *(GetDynamicSectionStart() + i);
}
-Elf32_Word ElfFile::FindDynamicValueByType(Elf32_Sword type) {
+Elf32_Word ElfFile::FindDynamicValueByType(Elf32_Sword type) const {
for (Elf32_Word i = 0; i < GetDynamicNum(); i++) {
Elf32_Dyn& elf_dyn = GetDynamic(i);
if (elf_dyn.d_tag == type) {
@@ -546,41 +627,41 @@
return 0;
}
-Elf32_Rel* ElfFile::GetRelSectionStart(Elf32_Shdr& section_header) {
+Elf32_Rel* ElfFile::GetRelSectionStart(Elf32_Shdr& section_header) const {
CHECK(SHT_REL == section_header.sh_type) << file_->GetPath() << " " << section_header.sh_type;
return reinterpret_cast<Elf32_Rel*>(Begin() + section_header.sh_offset);
}
-Elf32_Word ElfFile::GetRelNum(Elf32_Shdr& section_header) {
+Elf32_Word ElfFile::GetRelNum(Elf32_Shdr& section_header) const {
CHECK(SHT_REL == section_header.sh_type) << file_->GetPath() << " " << section_header.sh_type;
CHECK_NE(0U, section_header.sh_entsize) << file_->GetPath();
return section_header.sh_size / section_header.sh_entsize;
}
-Elf32_Rel& ElfFile::GetRel(Elf32_Shdr& section_header, Elf32_Word i) {
+Elf32_Rel& ElfFile::GetRel(Elf32_Shdr& section_header, Elf32_Word i) const {
CHECK(SHT_REL == section_header.sh_type) << file_->GetPath() << " " << section_header.sh_type;
CHECK_LT(i, GetRelNum(section_header)) << file_->GetPath();
return *(GetRelSectionStart(section_header) + i);
}
-Elf32_Rela* ElfFile::GetRelaSectionStart(Elf32_Shdr& section_header) {
+Elf32_Rela* ElfFile::GetRelaSectionStart(Elf32_Shdr& section_header) const {
CHECK(SHT_RELA == section_header.sh_type) << file_->GetPath() << " " << section_header.sh_type;
return reinterpret_cast<Elf32_Rela*>(Begin() + section_header.sh_offset);
}
-Elf32_Word ElfFile::GetRelaNum(Elf32_Shdr& section_header) {
+Elf32_Word ElfFile::GetRelaNum(Elf32_Shdr& section_header) const {
CHECK(SHT_RELA == section_header.sh_type) << file_->GetPath() << " " << section_header.sh_type;
return section_header.sh_size / section_header.sh_entsize;
}
-Elf32_Rela& ElfFile::GetRela(Elf32_Shdr& section_header, Elf32_Word i) {
+Elf32_Rela& ElfFile::GetRela(Elf32_Shdr& section_header, Elf32_Word i) const {
CHECK(SHT_RELA == section_header.sh_type) << file_->GetPath() << " " << section_header.sh_type;
CHECK_LT(i, GetRelaNum(section_header)) << file_->GetPath();
return *(GetRelaSectionStart(section_header) + i);
}
// Base on bionic phdr_table_get_load_size
-size_t ElfFile::GetLoadedSize() {
+size_t ElfFile::GetLoadedSize() const {
Elf32_Addr min_vaddr = 0xFFFFFFFFu;
Elf32_Addr max_vaddr = 0x00000000u;
for (Elf32_Word i = 0; i < GetProgramHeaderNum(); i++) {
@@ -605,7 +686,6 @@
}
bool ElfFile::Load(bool executable, std::string* error_msg) {
- // TODO: actually return false error
CHECK(program_header_only_) << file_->GetPath();
for (Elf32_Word i = 0; i < GetProgramHeaderNum(); i++) {
Elf32_Phdr& program_header = GetProgramHeader(i);
@@ -643,11 +723,14 @@
if (program_header.p_vaddr == 0) {
std::string reservation_name("ElfFile reservation for ");
reservation_name += file_->GetPath();
- std::string error_msg;
UniquePtr<MemMap> reserve(MemMap::MapAnonymous(reservation_name.c_str(),
NULL, GetLoadedSize(), PROT_NONE, false,
- &error_msg));
- CHECK(reserve.get() != NULL) << file_->GetPath() << ": " << error_msg;
+ error_msg));
+ if (reserve.get() == nullptr) {
+ *error_msg = StringPrintf("Failed to allocate %s: %s",
+ reservation_name.c_str(), error_msg->c_str());
+ return false;
+ }
base_address_ = reserve->Begin();
segments_.push_back(reserve.release());
}
@@ -687,8 +770,17 @@
true,
file_->GetPath().c_str(),
error_msg));
- CHECK(segment.get() != nullptr) << *error_msg;
- CHECK_EQ(segment->Begin(), p_vaddr) << file_->GetPath();
+ if (segment.get() == nullptr) {
+ *error_msg = StringPrintf("Failed to map ELF file segment %d from %s: %s",
+ i, file_->GetPath().c_str(), error_msg->c_str());
+ return false;
+ }
+ if (segment->Begin() != p_vaddr) {
+ *error_msg = StringPrintf("Failed to map ELF file segment %d from %s at expected address %p, "
+ "instead mapped to %p",
+ i, file_->GetPath().c_str(), p_vaddr, segment->Begin());
+ return false;
+ }
segments_.push_back(segment.release());
}
@@ -700,19 +792,39 @@
byte* d_ptr = base_address_ + elf_dyn.d_un.d_ptr;
switch (elf_dyn.d_tag) {
case DT_HASH: {
+ if (!ValidPointer(d_ptr)) {
+ *error_msg = StringPrintf("DT_HASH value %p does not refer to a loaded ELF segment of %s",
+ d_ptr, file_->GetPath().c_str());
+ return false;
+ }
hash_section_start_ = reinterpret_cast<Elf32_Word*>(d_ptr);
break;
}
case DT_STRTAB: {
+ if (!ValidPointer(d_ptr)) {
+ *error_msg = StringPrintf("DT_HASH value %p does not refer to a loaded ELF segment of %s",
+ d_ptr, file_->GetPath().c_str());
+ return false;
+ }
dynstr_section_start_ = reinterpret_cast<char*>(d_ptr);
break;
}
case DT_SYMTAB: {
+ if (!ValidPointer(d_ptr)) {
+ *error_msg = StringPrintf("DT_HASH value %p does not refer to a loaded ELF segment of %s",
+ d_ptr, file_->GetPath().c_str());
+ return false;
+ }
dynsym_section_start_ = reinterpret_cast<Elf32_Sym*>(d_ptr);
break;
}
case DT_NULL: {
- CHECK_EQ(GetDynamicNum(), i+1);
+ if (GetDynamicNum() != i+1) {
+ *error_msg = StringPrintf("DT_NULL found after %d .dynamic entries, "
+ "expected %d as implied by size of PT_DYNAMIC segment in %s",
+ i + 1, GetDynamicNum(), file_->GetPath().c_str());
+ return false;
+ }
break;
}
}
@@ -721,4 +833,14 @@
return true;
}
+bool ElfFile::ValidPointer(const byte* start) const {
+ for (size_t i = 0; i < segments_.size(); ++i) {
+ const MemMap* segment = segments_[i];
+ if (segment->Begin() <= start && start < segment->End()) {
+ return true;
+ }
+ }
+ return false;
+}
+
} // namespace art
diff --git a/runtime/elf_file.h b/runtime/elf_file.h
index baf4356..8a0a5f8 100644
--- a/runtime/elf_file.h
+++ b/runtime/elf_file.h
@@ -39,15 +39,15 @@
// Load segments into memory based on PT_LOAD program headers
- File& GetFile() const {
+ const File& GetFile() const {
return *file_;
}
- byte* Begin() {
+ byte* Begin() const {
return map_->Begin();
}
- byte* End() {
+ byte* End() const {
return map_->End();
}
@@ -55,24 +55,24 @@
return map_->Size();
}
- Elf32_Ehdr& GetHeader();
+ Elf32_Ehdr& GetHeader() const;
- Elf32_Word GetProgramHeaderNum();
- Elf32_Phdr& GetProgramHeader(Elf32_Word);
- Elf32_Phdr* FindProgamHeaderByType(Elf32_Word type);
+ Elf32_Word GetProgramHeaderNum() const;
+ Elf32_Phdr& GetProgramHeader(Elf32_Word) const;
+ Elf32_Phdr* FindProgamHeaderByType(Elf32_Word type) const;
- Elf32_Word GetSectionHeaderNum();
- Elf32_Shdr& GetSectionHeader(Elf32_Word);
- Elf32_Shdr* FindSectionByType(Elf32_Word type);
+ Elf32_Word GetSectionHeaderNum() const;
+ Elf32_Shdr& GetSectionHeader(Elf32_Word) const;
+ Elf32_Shdr* FindSectionByType(Elf32_Word type) const;
- Elf32_Shdr& GetSectionNameStringSection();
+ Elf32_Shdr& GetSectionNameStringSection() const;
// Find .dynsym using .hash for more efficient lookup than FindSymbolAddress.
- byte* FindDynamicSymbolAddress(const std::string& symbol_name);
+ const byte* FindDynamicSymbolAddress(const std::string& symbol_name) const;
static bool IsSymbolSectionType(Elf32_Word section_type);
- Elf32_Word GetSymbolNum(Elf32_Shdr&);
- Elf32_Sym& GetSymbol(Elf32_Word section_type, Elf32_Word i);
+ Elf32_Word GetSymbolNum(Elf32_Shdr&) const;
+ Elf32_Sym& GetSymbol(Elf32_Word section_type, Elf32_Word i) const;
// Find symbol in specified table, returning NULL if it is not found.
//
@@ -83,73 +83,77 @@
// should be set unless only a small number of symbols will be
// looked up.
Elf32_Sym* FindSymbolByName(Elf32_Word section_type,
- const std::string& symbol_name,
- bool build_map);
+ const std::string& symbol_name,
+ bool build_map);
// Find address of symbol in specified table, returning 0 if it is
// not found. See FindSymbolByName for an explanation of build_map.
Elf32_Addr FindSymbolAddress(Elf32_Word section_type,
- const std::string& symbol_name,
- bool build_map);
+ const std::string& symbol_name,
+ bool build_map);
// Lookup a string given string section and offset. Returns NULL for
// special 0 offset.
- const char* GetString(Elf32_Shdr&, Elf32_Word);
+ const char* GetString(Elf32_Shdr&, Elf32_Word) const;
// Lookup a string by section type. Returns NULL for special 0 offset.
- const char* GetString(Elf32_Word section_type, Elf32_Word);
+ const char* GetString(Elf32_Word section_type, Elf32_Word) const;
- Elf32_Word GetDynamicNum();
- Elf32_Dyn& GetDynamic(Elf32_Word);
- Elf32_Word FindDynamicValueByType(Elf32_Sword type);
+ Elf32_Word GetDynamicNum() const;
+ Elf32_Dyn& GetDynamic(Elf32_Word) const;
+ Elf32_Word FindDynamicValueByType(Elf32_Sword type) const;
- Elf32_Word GetRelNum(Elf32_Shdr&);
- Elf32_Rel& GetRel(Elf32_Shdr&, Elf32_Word);
+ Elf32_Word GetRelNum(Elf32_Shdr&) const;
+ Elf32_Rel& GetRel(Elf32_Shdr&, Elf32_Word) const;
- Elf32_Word GetRelaNum(Elf32_Shdr&);
- Elf32_Rela& GetRela(Elf32_Shdr&, Elf32_Word);
+ Elf32_Word GetRelaNum(Elf32_Shdr&) const;
+ Elf32_Rela& GetRela(Elf32_Shdr&, Elf32_Word) const;
// Returns the expected size when the file is loaded at runtime
- size_t GetLoadedSize();
+ size_t GetLoadedSize() const;
// Load segments into memory based on PT_LOAD program headers.
// executable is true at run time, false at compile time.
bool Load(bool executable, std::string* error_msg);
private:
- ElfFile();
+ ElfFile(File* file, bool writable, bool program_header_only);
- bool Setup(File* file, bool writable, bool program_header_only, std::string* error_msg);
+ bool Setup(std::string* error_msg);
bool SetMap(MemMap* map, std::string* error_msg);
- byte* GetProgramHeadersStart();
- byte* GetSectionHeadersStart();
- Elf32_Phdr& GetDynamicProgramHeader();
- Elf32_Dyn* GetDynamicSectionStart();
- Elf32_Sym* GetSymbolSectionStart(Elf32_Word section_type);
- const char* GetStringSectionStart(Elf32_Word section_type);
- Elf32_Rel* GetRelSectionStart(Elf32_Shdr&);
- Elf32_Rela* GetRelaSectionStart(Elf32_Shdr&);
- Elf32_Word* GetHashSectionStart();
- Elf32_Word GetHashBucketNum();
- Elf32_Word GetHashChainNum();
- Elf32_Word GetHashBucket(size_t i);
- Elf32_Word GetHashChain(size_t i);
+ byte* GetProgramHeadersStart() const;
+ byte* GetSectionHeadersStart() const;
+ Elf32_Phdr& GetDynamicProgramHeader() const;
+ Elf32_Dyn* GetDynamicSectionStart() const;
+ Elf32_Sym* GetSymbolSectionStart(Elf32_Word section_type) const;
+ const char* GetStringSectionStart(Elf32_Word section_type) const;
+ Elf32_Rel* GetRelSectionStart(Elf32_Shdr&) const;
+ Elf32_Rela* GetRelaSectionStart(Elf32_Shdr&) const;
+ Elf32_Word* GetHashSectionStart() const;
+ Elf32_Word GetHashBucketNum() const;
+ Elf32_Word GetHashChainNum() const;
+ Elf32_Word GetHashBucket(size_t i) const;
+ Elf32_Word GetHashChain(size_t i) const;
typedef std::map<std::string, Elf32_Sym*> SymbolTable;
SymbolTable** GetSymbolTable(Elf32_Word section_type);
- File* file_;
- bool writable_;
- bool program_header_only_;
+ bool ValidPointer(const byte* start) const;
- // ELF header mapping. If program_header_only_ is false, will actually point to the entire elf file.
+ const File* const file_;
+ const bool writable_;
+ const bool program_header_only_;
+
+ // ELF header mapping. If program_header_only_ is false, will
+ // actually point to the entire elf file.
UniquePtr<MemMap> map_;
Elf32_Ehdr* header_;
std::vector<MemMap*> segments_;
- // Pointer to start of first PT_LOAD program segment after Load() when program_header_only_ is true.
+ // Pointer to start of first PT_LOAD program segment after Load()
+ // when program_header_only_ is true.
byte* base_address_;
// The program header should always available but use GetProgramHeadersStart() to be sure.
@@ -161,8 +165,8 @@
Elf32_Dyn* dynamic_section_start_;
Elf32_Sym* symtab_section_start_;
Elf32_Sym* dynsym_section_start_;
- const char* strtab_section_start_;
- const char* dynstr_section_start_;
+ char* strtab_section_start_;
+ char* dynstr_section_start_;
Elf32_Word* hash_section_start_;
SymbolTable* symtab_symbol_table_;