1 /* Read the export table symbols from a portable executable and 2 convert to internal format, for GDB. Used as a last resort if no 3 debugging symbols recognized. 4 5 Copyright (C) 2003, 2007, 2008, 2009, 2010, 2011 6 Free Software Foundation, Inc. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. 22 23 Contributed by Raoul M. Gough (RaoulGough@yahoo.co.uk). */ 24 25 #include "coff-pe-read.h" 26 27 #include "bfd.h" 28 29 #include "defs.h" 30 #include "gdbtypes.h" 31 32 #include "symtab.h" 33 #include "symfile.h" 34 #include "objfiles.h" 35 36 /* Internal section information */ 37 38 struct read_pe_section_data 39 { 40 CORE_ADDR vma_offset; /* Offset to loaded address of section. */ 41 unsigned long rva_start; /* Start offset within the pe. */ 42 unsigned long rva_end; /* End offset within the pe. */ 43 enum minimal_symbol_type ms_type; /* Type to assign symbols in 44 section. */ 45 }; 46 47 #define PE_SECTION_INDEX_TEXT 0 48 #define PE_SECTION_INDEX_DATA 1 49 #define PE_SECTION_INDEX_BSS 2 50 #define PE_SECTION_TABLE_SIZE 3 51 #define PE_SECTION_INDEX_INVALID -1 52 53 /* Get the index of the named section in our own array, which contains 54 text, data and bss in that order. Return PE_SECTION_INDEX_INVALID 55 if passed an unrecognised section name. */ 56 57 static int 58 read_pe_section_index (const char *section_name) 59 { 60 if (strcmp (section_name, ".text") == 0) 61 { 62 return PE_SECTION_INDEX_TEXT; 63 } 64 65 else if (strcmp (section_name, ".data") == 0) 66 { 67 return PE_SECTION_INDEX_DATA; 68 } 69 70 else if (strcmp (section_name, ".bss") == 0) 71 { 72 return PE_SECTION_INDEX_BSS; 73 } 74 75 else 76 { 77 return PE_SECTION_INDEX_INVALID; 78 } 79 } 80 81 /* Record the virtual memory address of a section. */ 82 83 static void 84 get_section_vmas (bfd *abfd, asection *sectp, void *context) 85 { 86 struct read_pe_section_data *sections = context; 87 int sectix = read_pe_section_index (sectp->name); 88 89 if (sectix != PE_SECTION_INDEX_INVALID) 90 { 91 /* Data within the section start at rva_start in the pe and at 92 bfd_get_section_vma() within memory. Store the offset. */ 93 94 sections[sectix].vma_offset 95 = bfd_get_section_vma (abfd, sectp) - sections[sectix].rva_start; 96 } 97 } 98 99 /* Create a minimal symbol entry for an exported symbol. */ 100 101 static void 102 add_pe_exported_sym (char *sym_name, 103 unsigned long func_rva, 104 const struct read_pe_section_data *section_data, 105 const char *dll_name, struct objfile *objfile) 106 { 107 /* Add the stored offset to get the loaded address of the symbol. */ 108 109 CORE_ADDR vma = func_rva + section_data->vma_offset; 110 111 char *qualified_name = 0; 112 int dll_name_len = strlen (dll_name); 113 114 /* Generate a (hopefully unique) qualified name using the first part 115 of the dll name, e.g. KERNEL32!AddAtomA. This matches the style 116 used by windbg from the "Microsoft Debugging Tools for Windows". */ 117 118 qualified_name = xmalloc (dll_name_len + strlen (sym_name) + 2); 119 120 strncpy (qualified_name, dll_name, dll_name_len); 121 qualified_name[dll_name_len] = '!'; 122 strcpy (qualified_name + dll_name_len + 1, sym_name); 123 124 prim_record_minimal_symbol (qualified_name, 125 vma, section_data->ms_type, objfile); 126 127 xfree (qualified_name); 128 129 /* Enter the plain name as well, which might not be unique. */ 130 prim_record_minimal_symbol (sym_name, vma, 131 section_data->ms_type, objfile); 132 } 133 134 /* Truncate a dll_name at the first dot character. */ 135 136 static void 137 read_pe_truncate_name (char *dll_name) 138 { 139 while (*dll_name) 140 { 141 if ((*dll_name) == '.') 142 { 143 *dll_name = '\0'; /* truncates and causes loop exit. */ 144 } 145 146 else 147 { 148 ++dll_name; 149 } 150 } 151 } 152 153 /* Low-level support functions, direct from the ld module pe-dll.c. */ 154 static unsigned int 155 pe_get16 (bfd *abfd, int where) 156 { 157 unsigned char b[2]; 158 159 bfd_seek (abfd, (file_ptr) where, SEEK_SET); 160 bfd_bread (b, (bfd_size_type) 2, abfd); 161 return b[0] + (b[1] << 8); 162 } 163 164 static unsigned int 165 pe_get32 (bfd *abfd, int where) 166 { 167 unsigned char b[4]; 168 169 bfd_seek (abfd, (file_ptr) where, SEEK_SET); 170 bfd_bread (b, (bfd_size_type) 4, abfd); 171 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24); 172 } 173 174 static unsigned int 175 pe_as32 (void *ptr) 176 { 177 unsigned char *b = ptr; 178 179 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24); 180 } 181 182 /* Read the (non-debug) export symbol table from a portable 183 executable. Code originally lifted from the ld function 184 pe_implied_import_dll in pe-dll.c. */ 185 186 void 187 read_pe_exported_syms (struct objfile *objfile) 188 { 189 bfd *dll = objfile->obfd; 190 unsigned long pe_header_offset, opthdr_ofs, num_entries, i; 191 unsigned long export_rva, export_size, nsections, secptr, expptr; 192 unsigned long exp_funcbase; 193 unsigned char *expdata, *erva; 194 unsigned long name_rvas, ordinals, nexp, ordbase; 195 char *dll_name; 196 int is_pe64 = 0; 197 int is_pe32 = 0; 198 199 /* Array elements are for text, data and bss in that order 200 Initialization with start_rva > end_rva guarantees that 201 unused sections won't be matched. */ 202 struct read_pe_section_data section_data[PE_SECTION_TABLE_SIZE] 203 = { {0, 1, 0, mst_text}, 204 {0, 1, 0, mst_data}, 205 {0, 1, 0, mst_bss} 206 }; 207 208 struct cleanup *back_to = 0; 209 210 char const *target = bfd_get_target (objfile->obfd); 211 212 is_pe64 = (strcmp (target, "pe-x86-64") == 0 213 || strcmp (target, "pei-x86-64") == 0); 214 is_pe32 = (strcmp (target, "pe-i386") == 0 215 || strcmp (target, "pei-i386") == 0 216 || strcmp (target, "pe-arm-wince-little") == 0 217 || strcmp (target, "pei-arm-wince-little") == 0); 218 219 if (!is_pe32 && !is_pe64) 220 { 221 /* This is not a recognized PE format file. Abort now, because 222 the code is untested on anything else. *FIXME* test on 223 further architectures and loosen or remove this test. */ 224 return; 225 } 226 227 /* Get pe_header, optional header and numbers of export entries. */ 228 pe_header_offset = pe_get32 (dll, 0x3c); 229 opthdr_ofs = pe_header_offset + 4 + 20; 230 if (is_pe64) 231 num_entries = pe_get32 (dll, opthdr_ofs + 108); 232 else 233 num_entries = pe_get32 (dll, opthdr_ofs + 92); 234 235 if (num_entries < 1) /* No exports. */ 236 { 237 return; 238 } 239 240 if (is_pe64) 241 { 242 export_rva = pe_get32 (dll, opthdr_ofs + 112); 243 export_size = pe_get32 (dll, opthdr_ofs + 116); 244 } 245 else 246 { 247 export_rva = pe_get32 (dll, opthdr_ofs + 96); 248 export_size = pe_get32 (dll, opthdr_ofs + 100); 249 } 250 nsections = pe_get16 (dll, pe_header_offset + 4 + 2); 251 secptr = (pe_header_offset + 4 + 20 + 252 pe_get16 (dll, pe_header_offset + 4 + 16)); 253 expptr = 0; 254 255 /* Get the rva and size of the export section. */ 256 for (i = 0; i < nsections; i++) 257 { 258 char sname[8]; 259 unsigned long secptr1 = secptr + 40 * i; 260 unsigned long vaddr = pe_get32 (dll, secptr1 + 12); 261 unsigned long vsize = pe_get32 (dll, secptr1 + 16); 262 unsigned long fptr = pe_get32 (dll, secptr1 + 20); 263 264 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET); 265 bfd_bread (sname, (bfd_size_type) 8, dll); 266 267 if (vaddr <= export_rva && vaddr + vsize > export_rva) 268 { 269 expptr = fptr + (export_rva - vaddr); 270 if (export_rva + export_size > vaddr + vsize) 271 export_size = vsize - (export_rva - vaddr); 272 break; 273 } 274 } 275 276 if (export_size == 0) 277 { 278 /* Empty export table. */ 279 return; 280 } 281 282 /* Scan sections and store the base and size of the relevant 283 sections. */ 284 for (i = 0; i < nsections; i++) 285 { 286 unsigned long secptr1 = secptr + 40 * i; 287 unsigned long vsize = pe_get32 (dll, secptr1 + 8); 288 unsigned long vaddr = pe_get32 (dll, secptr1 + 12); 289 char sec_name[9]; 290 int sectix; 291 292 sec_name[8] = '\0'; 293 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET); 294 bfd_bread (sec_name, (bfd_size_type) 8, dll); 295 296 sectix = read_pe_section_index (sec_name); 297 298 if (sectix != PE_SECTION_INDEX_INVALID) 299 { 300 section_data[sectix].rva_start = vaddr; 301 section_data[sectix].rva_end = vaddr + vsize; 302 } 303 } 304 305 expdata = (unsigned char *) xmalloc (export_size); 306 back_to = make_cleanup (xfree, expdata); 307 308 bfd_seek (dll, (file_ptr) expptr, SEEK_SET); 309 bfd_bread (expdata, (bfd_size_type) export_size, dll); 310 erva = expdata - export_rva; 311 312 nexp = pe_as32 (expdata + 24); 313 name_rvas = pe_as32 (expdata + 32); 314 ordinals = pe_as32 (expdata + 36); 315 ordbase = pe_as32 (expdata + 16); 316 exp_funcbase = pe_as32 (expdata + 28); 317 318 /* Use internal dll name instead of full pathname. */ 319 dll_name = pe_as32 (expdata + 12) + erva; 320 321 bfd_map_over_sections (dll, get_section_vmas, section_data); 322 323 /* Adjust the vma_offsets in case this PE got relocated. This 324 assumes that *all* sections share the same relocation offset 325 as the text section. */ 326 for (i = 0; i < PE_SECTION_TABLE_SIZE; i++) 327 { 328 section_data[i].vma_offset 329 += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 330 } 331 332 /* Truncate name at first dot. Should maybe also convert to all 333 lower case for convenience on Windows. */ 334 read_pe_truncate_name (dll_name); 335 336 /* Iterate through the list of symbols. */ 337 for (i = 0; i < nexp; i++) 338 { 339 /* Pointer to the names vector. */ 340 unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4); 341 342 /* Pointer to the function address vector. */ 343 unsigned long func_rva = pe_as32 (erva + exp_funcbase + i * 4); 344 345 /* Find this symbol's section in our own array. */ 346 int sectix = 0; 347 348 for (sectix = 0; sectix < PE_SECTION_TABLE_SIZE; ++sectix) 349 { 350 if ((func_rva >= section_data[sectix].rva_start) 351 && (func_rva < section_data[sectix].rva_end)) 352 { 353 add_pe_exported_sym (erva + name_rva, 354 func_rva, 355 section_data + sectix, dll_name, objfile); 356 break; 357 } 358 } 359 } 360 361 /* Discard expdata. */ 362 do_cleanups (back_to); 363 } 364