1 /*
2 * Copyright 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 "ELFObjectLoaderImpl.h"
18
19 #include <llvm/Support/ELF.h>
20
21 // The following files are included from librsloader.
22 #include "ELFObject.h"
23 #include "ELFSectionSymTab.h"
24 #include "ELFSymbol.h"
25 #include "utils/serialize.h"
26
27 #include "bcc/ExecutionEngine/SymbolResolverInterface.h"
28 #include "bcc/Support/Log.h"
29
30 using namespace bcc;
31
load(const void * pMem,size_t pMemSize)32 bool ELFObjectLoaderImpl::load(const void *pMem, size_t pMemSize) {
33 ArchiveReaderLE reader(reinterpret_cast<const unsigned char *>(pMem),
34 pMemSize);
35
36 #ifdef __LP64__
37 mObject = ELFObject<64>::read(reader);
38 #else
39 mObject = ELFObject<32>::read(reader);
40 #endif
41 if (mObject == NULL) {
42 ALOGE("Unable to load the ELF object!");
43 return false;
44 }
45
46 // Retrive the pointer to the symbol table.
47 #ifdef __LP64__
48 mSymTab = static_cast<ELFSectionSymTab<64> *>(
49 mObject->getSectionByName(".symtab"));
50 #else
51 mSymTab = static_cast<ELFSectionSymTab<32> *>(
52 mObject->getSectionByName(".symtab"));
53 #endif
54 if (mSymTab == NULL) {
55 ALOGW("Object doesn't contain any symbol table.");
56 }
57
58 return true;
59 }
60
relocate(SymbolResolverInterface & pResolver)61 bool ELFObjectLoaderImpl::relocate(SymbolResolverInterface &pResolver) {
62 mObject->relocate(SymbolResolverInterface::LookupFunction, &pResolver);
63
64 if (mObject->getMissingSymbols()) {
65 ALOGE("Some symbols are found to be undefined during relocation!");
66 return false;
67 }
68
69 return true;
70 }
71
prepareDebugImage(void * pDebugImg,size_t pDebugImgSize)72 bool ELFObjectLoaderImpl::prepareDebugImage(void *pDebugImg,
73 size_t pDebugImgSize) {
74 // Update the value of sh_addr in pDebugImg to its corresponding section in
75 // the mObject.
76 #ifdef __LP64__
77 llvm::ELF::Elf64_Ehdr *elf_header =
78 reinterpret_cast<llvm::ELF::Elf64_Ehdr *>(pDebugImg);
79 #else
80 llvm::ELF::Elf32_Ehdr *elf_header =
81 reinterpret_cast<llvm::ELF::Elf32_Ehdr *>(pDebugImg);
82 #endif
83
84 if (elf_header->e_shoff > pDebugImgSize) {
85 #ifdef __LP64__
86 ALOGE("Invalid section header table offset found! (e_shoff = %ld)",
87 elf_header->e_shoff);
88 #else
89 ALOGE("Invalid section header table offset found! (e_shoff = %d)",
90 elf_header->e_shoff);
91 #endif
92 return false;
93 }
94
95 if ((elf_header->e_shoff +
96 sizeof(llvm::ELF::Elf32_Shdr) * elf_header->e_shnum) > pDebugImgSize) {
97 #ifdef __LP64__
98 ALOGE("Invalid image supplied (debug image doesn't contain all the section"
99 "header or corrupted image)! (e_shoff = %ld, e_shnum = %d)",
100 elf_header->e_shoff, elf_header->e_shnum);
101 #else
102 ALOGE("Invalid image supplied (debug image doesn't contain all the section"
103 "header or corrupted image)! (e_shoff = %d, e_shnum = %d)",
104 elf_header->e_shoff, elf_header->e_shnum);
105 #endif
106 return false;
107 }
108
109 #ifdef __LP64__
110 llvm::ELF::Elf64_Shdr *section_header_table =
111 reinterpret_cast<llvm::ELF::Elf64_Shdr *>(
112 reinterpret_cast<uint8_t*>(pDebugImg) + elf_header->e_shoff);
113 #else
114 llvm::ELF::Elf32_Shdr *section_header_table =
115 reinterpret_cast<llvm::ELF::Elf32_Shdr *>(
116 reinterpret_cast<uint8_t*>(pDebugImg) + elf_header->e_shoff);
117 #endif
118
119 for (unsigned i = 0; i < elf_header->e_shnum; i++) {
120 if (section_header_table[i].sh_flags & llvm::ELF::SHF_ALLOC) {
121 #ifdef __LP64__
122 ELFSectionBits<64> *section =
123 static_cast<ELFSectionBits<64> *>(mObject->getSectionByIndex(i));
124 #else
125 ELFSectionBits<32> *section =
126 static_cast<ELFSectionBits<32> *>(mObject->getSectionByIndex(i));
127 #endif
128 if (section != NULL) {
129 uintptr_t address = reinterpret_cast<uintptr_t>(section->getBuffer());
130 #ifdef __LP64__
131 LOG_FATAL_IF(address > 0xFFFFFFFFFFFFFFFFu, "Out of bound address for Elf64_Addr");
132 section_header_table[i].sh_addr = static_cast<llvm::ELF::Elf64_Addr>(address);
133 #else
134 LOG_FATAL_IF(address > 0xFFFFFFFFu, "Out of bound address for Elf32_Addr");
135 section_header_table[i].sh_addr = static_cast<llvm::ELF::Elf32_Addr>(address);
136 #endif
137 }
138 }
139 }
140
141 return true;
142 }
143
getSymbolAddress(const char * pName) const144 void *ELFObjectLoaderImpl::getSymbolAddress(const char *pName) const {
145 if (mSymTab == NULL) {
146 return NULL;
147 }
148
149 #ifdef __LP64__
150 const ELFSymbol<64> *symbol = mSymTab->getByName(pName);
151 #else
152 const ELFSymbol<32> *symbol = mSymTab->getByName(pName);
153 #endif
154 if (symbol == NULL) {
155 ALOGV("Request symbol '%s' is not found in the object!", pName);
156 return NULL;
157 }
158
159 return symbol->getAddress(mObject->getHeader()->getMachine(),
160 /* autoAlloc */false);
161 }
162
getSymbolSize(const char * pName) const163 size_t ELFObjectLoaderImpl::getSymbolSize(const char *pName) const {
164 if (mSymTab == NULL) {
165 return 0;
166 }
167
168 #ifdef __LP64__
169 const ELFSymbol<64> *symbol = mSymTab->getByName(pName);
170 #else
171 const ELFSymbol<32> *symbol = mSymTab->getByName(pName);
172 #endif
173
174 if (symbol == NULL) {
175 ALOGV("Request symbol '%s' is not found in the object!", pName);
176 return 0;
177 }
178
179 return static_cast<size_t>(symbol->getSize());
180
181 }
182
183 bool
getSymbolNameList(android::Vector<const char * > & pNameList,ObjectLoader::SymbolType pType) const184 ELFObjectLoaderImpl::getSymbolNameList(android::Vector<const char *>& pNameList,
185 ObjectLoader::SymbolType pType) const {
186 if (mSymTab == NULL) {
187 return false;
188 }
189
190 unsigned elf_type;
191 switch (pType) {
192 case ObjectLoader::kFunctionType: {
193 elf_type = llvm::ELF::STT_FUNC;
194 break;
195 }
196 case ObjectLoader::kUnknownType: {
197 break;
198 }
199 default: {
200 assert(false && "Invalid symbol type given!");
201 return false;
202 }
203 }
204
205 for (size_t i = 0, e = mSymTab->size(); i != e; i++) {
206 #ifdef __LP64__
207 ELFSymbol<64> *symbol = (*mSymTab)[i];
208 #else
209 ELFSymbol<32> *symbol = (*mSymTab)[i];
210 #endif
211 if (symbol == NULL) {
212 continue;
213 }
214
215 if ((pType == ObjectLoader::kUnknownType) ||
216 (symbol->getType() == elf_type)) {
217 const char *symbol_name = symbol->getName();
218 if (symbol_name != NULL) {
219 pNameList.push_back(symbol_name);
220 }
221 }
222 }
223
224 return true;
225 }
226
~ELFObjectLoaderImpl()227 ELFObjectLoaderImpl::~ELFObjectLoaderImpl() {
228 delete mObject;
229 return;
230 }
231