blob: 404e3f869200c8137256b95ff2f51c382ac2ef1c [file] [log] [blame]
/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "elf_fixup.h"
#include <inttypes.h>
#include <memory>
#include "base/logging.h"
#include "base/stringprintf.h"
#include "elf_file.h"
#include "elf_writer.h"
namespace art {
static const bool DEBUG_FIXUP = false;
bool ElfFixup::Fixup(File* file, uintptr_t oat_data_begin) {
std::string error_msg;
std::unique_ptr<ElfFile> elf_file(ElfFile::Open(file, true, false, &error_msg));
CHECK(elf_file.get() != nullptr) << error_msg;
// Lookup "oatdata" symbol address.
Elf32_Addr oatdata_address = ElfWriter::GetOatDataAddress(elf_file.get());
Elf32_Off base_address = oat_data_begin - oatdata_address;
if (!FixupDynamic(*elf_file.get(), base_address)) {
LOG(WARNING) << "Failed fo fixup .dynamic in " << file->GetPath();
return false;
}
if (!FixupSectionHeaders(*elf_file.get(), base_address)) {
LOG(WARNING) << "Failed fo fixup section headers in " << file->GetPath();
return false;
}
if (!FixupProgramHeaders(*elf_file.get(), base_address)) {
LOG(WARNING) << "Failed fo fixup program headers in " << file->GetPath();
return false;
}
if (!FixupSymbols(*elf_file.get(), base_address, true)) {
LOG(WARNING) << "Failed fo fixup .dynsym in " << file->GetPath();
return false;
}
if (!FixupSymbols(*elf_file.get(), base_address, false)) {
LOG(WARNING) << "Failed fo fixup .symtab in " << file->GetPath();
return false;
}
if (!FixupRelocations(*elf_file.get(), base_address)) {
LOG(WARNING) << "Failed fo fixup .rel.dyn in " << file->GetPath();
return false;
}
return true;
}
bool ElfFixup::FixupDynamic(ElfFile& elf_file, uintptr_t base_address) {
for (Elf32_Word i = 0; i < elf_file.GetDynamicNum(); i++) {
Elf32_Dyn& elf_dyn = elf_file.GetDynamic(i);
Elf32_Word d_tag = elf_dyn.d_tag;
bool elf_dyn_needs_fixup = false;
switch (d_tag) {
// case 1: well known d_tag values that imply Elf32_Dyn.d_un contains an address in d_ptr
case DT_PLTGOT:
case DT_HASH:
case DT_STRTAB:
case DT_SYMTAB:
case DT_RELA:
case DT_INIT:
case DT_FINI:
case DT_REL:
case DT_DEBUG:
case DT_JMPREL: {
elf_dyn_needs_fixup = true;
break;
}
// d_val or ignored values
case DT_NULL:
case DT_NEEDED:
case DT_PLTRELSZ:
case DT_RELASZ:
case DT_RELAENT:
case DT_STRSZ:
case DT_SYMENT:
case DT_SONAME:
case DT_RPATH:
case DT_SYMBOLIC:
case DT_RELSZ:
case DT_RELENT:
case DT_PLTREL:
case DT_TEXTREL:
case DT_BIND_NOW:
case DT_INIT_ARRAYSZ:
case DT_FINI_ARRAYSZ:
case DT_RUNPATH:
case DT_FLAGS: {
break;
}
// boundary values that should not be used
case DT_ENCODING:
case DT_LOOS:
case DT_HIOS:
case DT_LOPROC:
case DT_HIPROC: {
LOG(FATAL) << "Illegal d_tag value 0x" << std::hex << d_tag;
break;
}
default: {
// case 2: "regular" DT_* ranges where even d_tag values imply an address in d_ptr
if ((DT_ENCODING < d_tag && d_tag < DT_LOOS)
|| (DT_LOOS < d_tag && d_tag < DT_HIOS)
|| (DT_LOPROC < d_tag && d_tag < DT_HIPROC)) {
// Special case for MIPS which breaks the regular rules between DT_LOPROC and DT_HIPROC
if (elf_file.GetHeader().e_machine == EM_MIPS) {
switch (d_tag) {
case DT_MIPS_RLD_VERSION:
case DT_MIPS_TIME_STAMP:
case DT_MIPS_ICHECKSUM:
case DT_MIPS_IVERSION:
case DT_MIPS_FLAGS:
case DT_MIPS_LOCAL_GOTNO:
case DT_MIPS_CONFLICTNO:
case DT_MIPS_LIBLISTNO:
case DT_MIPS_SYMTABNO:
case DT_MIPS_UNREFEXTNO:
case DT_MIPS_GOTSYM:
case DT_MIPS_HIPAGENO: {
break;
}
case DT_MIPS_BASE_ADDRESS:
case DT_MIPS_CONFLICT:
case DT_MIPS_LIBLIST:
case DT_MIPS_RLD_MAP: {
elf_dyn_needs_fixup = true;
break;
}
default: {
LOG(FATAL) << "Unknown MIPS d_tag value 0x" << std::hex << d_tag;
break;
}
}
} else if ((elf_dyn.d_tag % 2) == 0) {
elf_dyn_needs_fixup = true;
}
} else {
LOG(FATAL) << "Unknown d_tag value 0x" << std::hex << d_tag;
}
break;
}
}
if (elf_dyn_needs_fixup) {
uint32_t d_ptr = elf_dyn.d_un.d_ptr;
if (DEBUG_FIXUP) {
LOG(INFO) << StringPrintf("In %s moving Elf32_Dyn[%d] from 0x%08x to 0x%08" PRIxPTR,
elf_file.GetFile().GetPath().c_str(), i,
d_ptr, d_ptr + base_address);
}
d_ptr += base_address;
elf_dyn.d_un.d_ptr = d_ptr;
}
}
return true;
}
bool ElfFixup::FixupSectionHeaders(ElfFile& elf_file, uintptr_t base_address) {
for (Elf32_Word i = 0; i < elf_file.GetSectionHeaderNum(); i++) {
Elf32_Shdr& sh = elf_file.GetSectionHeader(i);
// 0 implies that the section will not exist in the memory of the process
if (sh.sh_addr == 0) {
continue;
}
if (DEBUG_FIXUP) {
LOG(INFO) << StringPrintf("In %s moving Elf32_Shdr[%d] from 0x%08x to 0x%08" PRIxPTR,
elf_file.GetFile().GetPath().c_str(), i,
sh.sh_addr, sh.sh_addr + base_address);
}
sh.sh_addr += base_address;
}
return true;
}
bool ElfFixup::FixupProgramHeaders(ElfFile& elf_file, uintptr_t base_address) {
// TODO: ELFObjectFile doesn't have give to Elf32_Phdr, so we do that ourselves for now.
for (Elf32_Word i = 0; i < elf_file.GetProgramHeaderNum(); i++) {
Elf32_Phdr& ph = elf_file.GetProgramHeader(i);
CHECK_EQ(ph.p_vaddr, ph.p_paddr) << elf_file.GetFile().GetPath() << " i=" << i;
CHECK((ph.p_align == 0) || (0 == ((ph.p_vaddr - ph.p_offset) & (ph.p_align - 1))))
<< elf_file.GetFile().GetPath() << " i=" << i;
if (DEBUG_FIXUP) {
LOG(INFO) << StringPrintf("In %s moving Elf32_Phdr[%d] from 0x%08x to 0x%08" PRIxPTR,
elf_file.GetFile().GetPath().c_str(), i,
ph.p_vaddr, ph.p_vaddr + base_address);
}
ph.p_vaddr += base_address;
ph.p_paddr += base_address;
CHECK((ph.p_align == 0) || (0 == ((ph.p_vaddr - ph.p_offset) & (ph.p_align - 1))))
<< elf_file.GetFile().GetPath() << " i=" << i;
}
return true;
}
bool ElfFixup::FixupSymbols(ElfFile& elf_file, uintptr_t base_address, bool dynamic) {
Elf32_Word section_type = dynamic ? SHT_DYNSYM : SHT_SYMTAB;
// TODO: Unfortunate ELFObjectFile has protected symbol access, so use ElfFile
Elf32_Shdr* symbol_section = elf_file.FindSectionByType(section_type);
if (symbol_section == NULL) {
// file is missing optional .symtab
CHECK(!dynamic) << elf_file.GetFile().GetPath();
return true;
}
for (uint32_t i = 0; i < elf_file.GetSymbolNum(*symbol_section); i++) {
Elf32_Sym& symbol = elf_file.GetSymbol(section_type, i);
if (symbol.st_value != 0) {
if (DEBUG_FIXUP) {
LOG(INFO) << StringPrintf("In %s moving Elf32_Sym[%d] from 0x%08x to 0x%08" PRIxPTR,
elf_file.GetFile().GetPath().c_str(), i,
symbol.st_value, symbol.st_value + base_address);
}
symbol.st_value += base_address;
}
}
return true;
}
bool ElfFixup::FixupRelocations(ElfFile& elf_file, uintptr_t base_address) {
for (Elf32_Word i = 0; i < elf_file.GetSectionHeaderNum(); i++) {
Elf32_Shdr& sh = elf_file.GetSectionHeader(i);
if (sh.sh_type == SHT_REL) {
for (uint32_t i = 0; i < elf_file.GetRelNum(sh); i++) {
Elf32_Rel& rel = elf_file.GetRel(sh, i);
if (DEBUG_FIXUP) {
LOG(INFO) << StringPrintf("In %s moving Elf32_Rel[%d] from 0x%08x to 0x%08" PRIxPTR,
elf_file.GetFile().GetPath().c_str(), i,
rel.r_offset, rel.r_offset + base_address);
}
rel.r_offset += base_address;
}
} else if (sh.sh_type == SHT_RELA) {
for (uint32_t i = 0; i < elf_file.GetRelaNum(sh); i++) {
Elf32_Rela& rela = elf_file.GetRela(sh, i);
if (DEBUG_FIXUP) {
LOG(INFO) << StringPrintf("In %s moving Elf32_Rela[%d] from 0x%08x to 0x%08" PRIxPTR,
elf_file.GetFile().GetPath().c_str(), i,
rela.r_offset, rela.r_offset + base_address);
}
rela.r_offset += base_address;
}
}
}
return true;
}
} // namespace art