1 /*
2 * Copyright (C) 2011 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 #define LOG_TAG "Corkscrew"
18 //#define LOG_NDEBUG 0
19
20 #include <corkscrew/symbol_table.h>
21
22 #include <stdbool.h>
23 #include <stdlib.h>
24 #include <fcntl.h>
25 #include <string.h>
26 #include <sys/stat.h>
27 #include <sys/mman.h>
28 #include <cutils/log.h>
29
30 #if defined(__APPLE__)
31 #else
32
33 #include <elf.h>
34
is_elf(Elf32_Ehdr * e)35 static bool is_elf(Elf32_Ehdr* e) {
36 return (e->e_ident[EI_MAG0] == ELFMAG0 &&
37 e->e_ident[EI_MAG1] == ELFMAG1 &&
38 e->e_ident[EI_MAG2] == ELFMAG2 &&
39 e->e_ident[EI_MAG3] == ELFMAG3);
40 }
41
42 #endif
43
44 // Compare function for qsort
qcompar(const void * a,const void * b)45 static int qcompar(const void *a, const void *b) {
46 const symbol_t* asym = (const symbol_t*)a;
47 const symbol_t* bsym = (const symbol_t*)b;
48 if (asym->start > bsym->start) return 1;
49 if (asym->start < bsym->start) return -1;
50 return 0;
51 }
52
53 // Compare function for bsearch
bcompar(const void * key,const void * element)54 static int bcompar(const void *key, const void *element) {
55 uintptr_t addr = *(const uintptr_t*)key;
56 const symbol_t* symbol = (const symbol_t*)element;
57 if (addr < symbol->start) return -1;
58 if (addr >= symbol->end) return 1;
59 return 0;
60 }
61
load_symbol_table(const char * filename)62 symbol_table_t* load_symbol_table(const char *filename) {
63 symbol_table_t* table = NULL;
64 #if !defined(__APPLE__)
65 ALOGV("Loading symbol table from '%s'.", filename);
66
67 int fd = open(filename, O_RDONLY);
68 if (fd < 0) {
69 goto out;
70 }
71
72 struct stat sb;
73 if (fstat(fd, &sb)) {
74 goto out_close;
75 }
76
77 size_t length = sb.st_size;
78 char* base = mmap(NULL, length, PROT_READ, MAP_PRIVATE, fd, 0);
79 if (base == MAP_FAILED) {
80 goto out_close;
81 }
82
83 // Parse the file header
84 Elf32_Ehdr *hdr = (Elf32_Ehdr*)base;
85 if (!is_elf(hdr)) {
86 goto out_close;
87 }
88 Elf32_Shdr *shdr = (Elf32_Shdr*)(base + hdr->e_shoff);
89
90 // Search for the dynamic symbols section
91 int sym_idx = -1;
92 int dynsym_idx = -1;
93 for (Elf32_Half i = 0; i < hdr->e_shnum; i++) {
94 if (shdr[i].sh_type == SHT_SYMTAB) {
95 sym_idx = i;
96 }
97 if (shdr[i].sh_type == SHT_DYNSYM) {
98 dynsym_idx = i;
99 }
100 }
101 if (dynsym_idx == -1 && sym_idx == -1) {
102 goto out_unmap;
103 }
104
105 table = malloc(sizeof(symbol_table_t));
106 if(!table) {
107 goto out_unmap;
108 }
109 table->num_symbols = 0;
110
111 Elf32_Sym *dynsyms = NULL;
112 int dynnumsyms = 0;
113 char *dynstr = NULL;
114 if (dynsym_idx != -1) {
115 dynsyms = (Elf32_Sym*)(base + shdr[dynsym_idx].sh_offset);
116 dynnumsyms = shdr[dynsym_idx].sh_size / shdr[dynsym_idx].sh_entsize;
117 int dynstr_idx = shdr[dynsym_idx].sh_link;
118 dynstr = base + shdr[dynstr_idx].sh_offset;
119 }
120
121 Elf32_Sym *syms = NULL;
122 int numsyms = 0;
123 char *str = NULL;
124 if (sym_idx != -1) {
125 syms = (Elf32_Sym*)(base + shdr[sym_idx].sh_offset);
126 numsyms = shdr[sym_idx].sh_size / shdr[sym_idx].sh_entsize;
127 int str_idx = shdr[sym_idx].sh_link;
128 str = base + shdr[str_idx].sh_offset;
129 }
130
131 int dynsymbol_count = 0;
132 if (dynsym_idx != -1) {
133 // Iterate through the dynamic symbol table, and count how many symbols
134 // are actually defined
135 for (int i = 0; i < dynnumsyms; i++) {
136 if (dynsyms[i].st_shndx != SHN_UNDEF) {
137 dynsymbol_count++;
138 }
139 }
140 }
141
142 size_t symbol_count = 0;
143 if (sym_idx != -1) {
144 // Iterate through the symbol table, and count how many symbols
145 // are actually defined
146 for (int i = 0; i < numsyms; i++) {
147 if (syms[i].st_shndx != SHN_UNDEF
148 && str[syms[i].st_name]
149 && syms[i].st_value
150 && syms[i].st_size) {
151 symbol_count++;
152 }
153 }
154 }
155
156 // Now, create an entry in our symbol table structure for each symbol...
157 table->num_symbols += symbol_count + dynsymbol_count;
158 table->symbols = malloc(table->num_symbols * sizeof(symbol_t));
159 if (!table->symbols) {
160 free(table);
161 table = NULL;
162 goto out_unmap;
163 }
164
165 size_t symbol_index = 0;
166 if (dynsym_idx != -1) {
167 // ...and populate them
168 for (int i = 0; i < dynnumsyms; i++) {
169 if (dynsyms[i].st_shndx != SHN_UNDEF) {
170 table->symbols[symbol_index].name = strdup(dynstr + dynsyms[i].st_name);
171 table->symbols[symbol_index].start = dynsyms[i].st_value;
172 table->symbols[symbol_index].end = dynsyms[i].st_value + dynsyms[i].st_size;
173 ALOGV(" [%d] '%s' 0x%08x-0x%08x (DYNAMIC)",
174 symbol_index, table->symbols[symbol_index].name,
175 table->symbols[symbol_index].start, table->symbols[symbol_index].end);
176 symbol_index += 1;
177 }
178 }
179 }
180
181 if (sym_idx != -1) {
182 // ...and populate them
183 for (int i = 0; i < numsyms; i++) {
184 if (syms[i].st_shndx != SHN_UNDEF
185 && str[syms[i].st_name]
186 && syms[i].st_value
187 && syms[i].st_size) {
188 table->symbols[symbol_index].name = strdup(str + syms[i].st_name);
189 table->symbols[symbol_index].start = syms[i].st_value;
190 table->symbols[symbol_index].end = syms[i].st_value + syms[i].st_size;
191 ALOGV(" [%d] '%s' 0x%08x-0x%08x",
192 symbol_index, table->symbols[symbol_index].name,
193 table->symbols[symbol_index].start, table->symbols[symbol_index].end);
194 symbol_index += 1;
195 }
196 }
197 }
198
199 // Sort the symbol table entries, so they can be bsearched later
200 qsort(table->symbols, table->num_symbols, sizeof(symbol_t), qcompar);
201
202 out_unmap:
203 munmap(base, length);
204
205 out_close:
206 close(fd);
207 #endif
208
209 out:
210 return table;
211 }
212
free_symbol_table(symbol_table_t * table)213 void free_symbol_table(symbol_table_t* table) {
214 if (table) {
215 for (size_t i = 0; i < table->num_symbols; i++) {
216 free(table->symbols[i].name);
217 }
218 free(table->symbols);
219 free(table);
220 }
221 }
222
find_symbol(const symbol_table_t * table,uintptr_t addr)223 const symbol_t* find_symbol(const symbol_table_t* table, uintptr_t addr) {
224 if (!table) return NULL;
225 return (const symbol_t*)bsearch(&addr, table->symbols, table->num_symbols,
226 sizeof(symbol_t), bcompar);
227 }
228