1 /* Support for the generic parts of PE/PEI, for BFD. 2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 3 2005, 2006, 2007, 2008 Free Software Foundation, Inc. 4 Written by Cygnus Solutions. 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 MA 02110-1301, USA. */ 22 23 24 /* Most of this hacked by Steve Chamberlain, 25 sac@cygnus.com 26 27 PE/PEI rearrangement (and code added): Donn Terry 28 Softway Systems, Inc. */ 29 30 /* Hey look, some documentation [and in a place you expect to find it]! 31 32 The main reference for the pei format is "Microsoft Portable Executable 33 and Common Object File Format Specification 4.1". Get it if you need to 34 do some serious hacking on this code. 35 36 Another reference: 37 "Peering Inside the PE: A Tour of the Win32 Portable Executable 38 File Format", MSJ 1994, Volume 9. 39 40 The *sole* difference between the pe format and the pei format is that the 41 latter has an MSDOS 2.0 .exe header on the front that prints the message 42 "This app must be run under Windows." (or some such). 43 (FIXME: Whether that statement is *really* true or not is unknown. 44 Are there more subtle differences between pe and pei formats? 45 For now assume there aren't. If you find one, then for God sakes 46 document it here!) 47 48 The Microsoft docs use the word "image" instead of "executable" because 49 the former can also refer to a DLL (shared library). Confusion can arise 50 because the `i' in `pei' also refers to "image". The `pe' format can 51 also create images (i.e. executables), it's just that to run on a win32 52 system you need to use the pei format. 53 54 FIXME: Please add more docs here so the next poor fool that has to hack 55 on this code has a chance of getting something accomplished without 56 wasting too much time. */ 57 58 #include "libpei.h" 59 60 static bfd_boolean (*pe_saved_coff_bfd_print_private_bfd_data) (bfd *, void *) = 61 #ifndef coff_bfd_print_private_bfd_data 62 NULL; 63 #else 64 coff_bfd_print_private_bfd_data; 65 #undef coff_bfd_print_private_bfd_data 66 #endif 67 68 static bfd_boolean pe_print_private_bfd_data (bfd *, void *); 69 #define coff_bfd_print_private_bfd_data pe_print_private_bfd_data 70 71 static bfd_boolean (*pe_saved_coff_bfd_copy_private_bfd_data) (bfd *, bfd *) = 72 #ifndef coff_bfd_copy_private_bfd_data 73 NULL; 74 #else 75 coff_bfd_copy_private_bfd_data; 76 #undef coff_bfd_copy_private_bfd_data 77 #endif 78 79 static bfd_boolean pe_bfd_copy_private_bfd_data (bfd *, bfd *); 80 #define coff_bfd_copy_private_bfd_data pe_bfd_copy_private_bfd_data 81 82 #define coff_mkobject pe_mkobject 83 #define coff_mkobject_hook pe_mkobject_hook 84 85 #ifdef COFF_IMAGE_WITH_PE 86 /* This structure contains static variables used by the ILF code. */ 87 typedef asection * asection_ptr; 88 89 typedef struct 90 { 91 bfd * abfd; 92 bfd_byte * data; 93 struct bfd_in_memory * bim; 94 unsigned short magic; 95 96 arelent * reltab; 97 unsigned int relcount; 98 99 coff_symbol_type * sym_cache; 100 coff_symbol_type * sym_ptr; 101 unsigned int sym_index; 102 103 unsigned int * sym_table; 104 unsigned int * table_ptr; 105 106 combined_entry_type * native_syms; 107 combined_entry_type * native_ptr; 108 109 coff_symbol_type ** sym_ptr_table; 110 coff_symbol_type ** sym_ptr_ptr; 111 112 unsigned int sec_index; 113 114 char * string_table; 115 char * string_ptr; 116 char * end_string_ptr; 117 118 SYMENT * esym_table; 119 SYMENT * esym_ptr; 120 121 struct internal_reloc * int_reltab; 122 } 123 pe_ILF_vars; 124 #endif /* COFF_IMAGE_WITH_PE */ 125 126 #ifndef NO_COFF_RELOCS 127 static void 128 coff_swap_reloc_in (bfd * abfd, void * src, void * dst) 129 { 130 RELOC *reloc_src = (RELOC *) src; 131 struct internal_reloc *reloc_dst = (struct internal_reloc *) dst; 132 133 reloc_dst->r_vaddr = H_GET_32 (abfd, reloc_src->r_vaddr); 134 reloc_dst->r_symndx = H_GET_S32 (abfd, reloc_src->r_symndx); 135 reloc_dst->r_type = H_GET_16 (abfd, reloc_src->r_type); 136 #ifdef SWAP_IN_RELOC_OFFSET 137 reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET (abfd, reloc_src->r_offset); 138 #endif 139 } 140 141 static unsigned int 142 coff_swap_reloc_out (bfd * abfd, void * src, void * dst) 143 { 144 struct internal_reloc *reloc_src = (struct internal_reloc *) src; 145 struct external_reloc *reloc_dst = (struct external_reloc *) dst; 146 147 H_PUT_32 (abfd, reloc_src->r_vaddr, reloc_dst->r_vaddr); 148 H_PUT_32 (abfd, reloc_src->r_symndx, reloc_dst->r_symndx); 149 H_PUT_16 (abfd, reloc_src->r_type, reloc_dst->r_type); 150 151 #ifdef SWAP_OUT_RELOC_OFFSET 152 SWAP_OUT_RELOC_OFFSET (abfd, reloc_src->r_offset, reloc_dst->r_offset); 153 #endif 154 #ifdef SWAP_OUT_RELOC_EXTRA 155 SWAP_OUT_RELOC_EXTRA (abfd, reloc_src, reloc_dst); 156 #endif 157 return RELSZ; 158 } 159 #endif /* not NO_COFF_RELOCS */ 160 161 static void 162 coff_swap_filehdr_in (bfd * abfd, void * src, void * dst) 163 { 164 FILHDR *filehdr_src = (FILHDR *) src; 165 struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst; 166 167 filehdr_dst->f_magic = H_GET_16 (abfd, filehdr_src->f_magic); 168 filehdr_dst->f_nscns = H_GET_16 (abfd, filehdr_src->f_nscns); 169 filehdr_dst->f_timdat = H_GET_32 (abfd, filehdr_src->f_timdat); 170 filehdr_dst->f_nsyms = H_GET_32 (abfd, filehdr_src->f_nsyms); 171 filehdr_dst->f_flags = H_GET_16 (abfd, filehdr_src->f_flags); 172 filehdr_dst->f_symptr = H_GET_32 (abfd, filehdr_src->f_symptr); 173 174 /* Other people's tools sometimes generate headers with an nsyms but 175 a zero symptr. */ 176 if (filehdr_dst->f_nsyms != 0 && filehdr_dst->f_symptr == 0) 177 { 178 filehdr_dst->f_nsyms = 0; 179 filehdr_dst->f_flags |= F_LSYMS; 180 } 181 182 filehdr_dst->f_opthdr = H_GET_16 (abfd, filehdr_src-> f_opthdr); 183 } 184 185 #ifdef COFF_IMAGE_WITH_PE 186 # define coff_swap_filehdr_out _bfd_XXi_only_swap_filehdr_out 187 #elif defined COFF_WITH_pex64 188 # define coff_swap_filehdr_out _bfd_pex64_only_swap_filehdr_out 189 #elif defined COFF_WITH_pep 190 # define coff_swap_filehdr_out _bfd_pep_only_swap_filehdr_out 191 #else 192 # define coff_swap_filehdr_out _bfd_pe_only_swap_filehdr_out 193 #endif 194 195 static void 196 coff_swap_scnhdr_in (bfd * abfd, void * ext, void * in) 197 { 198 SCNHDR *scnhdr_ext = (SCNHDR *) ext; 199 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in; 200 201 memcpy (scnhdr_int->s_name, scnhdr_ext->s_name, sizeof (scnhdr_int->s_name)); 202 203 scnhdr_int->s_vaddr = GET_SCNHDR_VADDR (abfd, scnhdr_ext->s_vaddr); 204 scnhdr_int->s_paddr = GET_SCNHDR_PADDR (abfd, scnhdr_ext->s_paddr); 205 scnhdr_int->s_size = GET_SCNHDR_SIZE (abfd, scnhdr_ext->s_size); 206 scnhdr_int->s_scnptr = GET_SCNHDR_SCNPTR (abfd, scnhdr_ext->s_scnptr); 207 scnhdr_int->s_relptr = GET_SCNHDR_RELPTR (abfd, scnhdr_ext->s_relptr); 208 scnhdr_int->s_lnnoptr = GET_SCNHDR_LNNOPTR (abfd, scnhdr_ext->s_lnnoptr); 209 scnhdr_int->s_flags = H_GET_32 (abfd, scnhdr_ext->s_flags); 210 211 /* MS handles overflow of line numbers by carrying into the reloc 212 field (it appears). Since it's supposed to be zero for PE 213 *IMAGE* format, that's safe. This is still a bit iffy. */ 214 #ifdef COFF_IMAGE_WITH_PE 215 scnhdr_int->s_nlnno = (H_GET_16 (abfd, scnhdr_ext->s_nlnno) 216 + (H_GET_16 (abfd, scnhdr_ext->s_nreloc) << 16)); 217 scnhdr_int->s_nreloc = 0; 218 #else 219 scnhdr_int->s_nreloc = H_GET_16 (abfd, scnhdr_ext->s_nreloc); 220 scnhdr_int->s_nlnno = H_GET_16 (abfd, scnhdr_ext->s_nlnno); 221 #endif 222 223 if (scnhdr_int->s_vaddr != 0) 224 { 225 scnhdr_int->s_vaddr += pe_data (abfd)->pe_opthdr.ImageBase; 226 /* Do not cut upper 32-bits for 64-bit vma. */ 227 #ifndef COFF_WITH_pex64 228 scnhdr_int->s_vaddr &= 0xffffffff; 229 #endif 230 } 231 232 #ifndef COFF_NO_HACK_SCNHDR_SIZE 233 /* If this section holds uninitialized data and is from an object file 234 or from an executable image that has not initialized the field, 235 or if the image is an executable file and the physical size is padded, 236 use the virtual size (stored in s_paddr) instead. */ 237 if (scnhdr_int->s_paddr > 0 238 && (((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0 239 && (! bfd_pe_executable_p (abfd) || scnhdr_int->s_size == 0)) 240 || (bfd_pe_executable_p (abfd) && (scnhdr_int->s_size > scnhdr_int->s_paddr)))) 241 /* This code used to set scnhdr_int->s_paddr to 0. However, 242 coff_set_alignment_hook stores s_paddr in virt_size, which 243 only works if it correctly holds the virtual size of the 244 section. */ 245 scnhdr_int->s_size = scnhdr_int->s_paddr; 246 #endif 247 } 248 249 static bfd_boolean 250 pe_mkobject (bfd * abfd) 251 { 252 pe_data_type *pe; 253 bfd_size_type amt = sizeof (pe_data_type); 254 255 abfd->tdata.pe_obj_data = (struct pe_tdata *) bfd_zalloc (abfd, amt); 256 257 if (abfd->tdata.pe_obj_data == 0) 258 return FALSE; 259 260 pe = pe_data (abfd); 261 262 pe->coff.pe = 1; 263 264 /* in_reloc_p is architecture dependent. */ 265 pe->in_reloc_p = in_reloc_p; 266 267 #ifdef PEI_FORCE_MINIMUM_ALIGNMENT 268 pe->force_minimum_alignment = 1; 269 #endif 270 #ifdef PEI_TARGET_SUBSYSTEM 271 pe->target_subsystem = PEI_TARGET_SUBSYSTEM; 272 #endif 273 274 return TRUE; 275 } 276 277 /* Create the COFF backend specific information. */ 278 279 static void * 280 pe_mkobject_hook (bfd * abfd, 281 void * filehdr, 282 void * aouthdr ATTRIBUTE_UNUSED) 283 { 284 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 285 pe_data_type *pe; 286 287 if (! pe_mkobject (abfd)) 288 return NULL; 289 290 pe = pe_data (abfd); 291 pe->coff.sym_filepos = internal_f->f_symptr; 292 /* These members communicate important constants about the symbol 293 table to GDB's symbol-reading code. These `constants' 294 unfortunately vary among coff implementations... */ 295 pe->coff.local_n_btmask = N_BTMASK; 296 pe->coff.local_n_btshft = N_BTSHFT; 297 pe->coff.local_n_tmask = N_TMASK; 298 pe->coff.local_n_tshift = N_TSHIFT; 299 pe->coff.local_symesz = SYMESZ; 300 pe->coff.local_auxesz = AUXESZ; 301 pe->coff.local_linesz = LINESZ; 302 303 pe->coff.timestamp = internal_f->f_timdat; 304 305 obj_raw_syment_count (abfd) = 306 obj_conv_table_size (abfd) = 307 internal_f->f_nsyms; 308 309 pe->real_flags = internal_f->f_flags; 310 311 if ((internal_f->f_flags & F_DLL) != 0) 312 pe->dll = 1; 313 314 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0) 315 abfd->flags |= HAS_DEBUG; 316 317 #ifdef COFF_IMAGE_WITH_PE 318 if (aouthdr) 319 pe->pe_opthdr = ((struct internal_aouthdr *) aouthdr)->pe; 320 #endif 321 322 #ifdef ARM 323 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags)) 324 coff_data (abfd) ->flags = 0; 325 #endif 326 327 return (void *) pe; 328 } 329 330 static bfd_boolean 331 pe_print_private_bfd_data (bfd *abfd, void * vfile) 332 { 333 FILE *file = (FILE *) vfile; 334 335 if (!_bfd_XX_print_private_bfd_data_common (abfd, vfile)) 336 return FALSE; 337 338 if (pe_saved_coff_bfd_print_private_bfd_data == NULL) 339 return TRUE; 340 341 fputc ('\n', file); 342 343 return pe_saved_coff_bfd_print_private_bfd_data (abfd, vfile); 344 } 345 346 /* Copy any private info we understand from the input bfd 347 to the output bfd. */ 348 349 static bfd_boolean 350 pe_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 351 { 352 /* PR binutils/716: Copy the large address aware flag. 353 XXX: Should we be copying other flags or other fields in the pe_data() 354 structure ? */ 355 if (pe_data (obfd) != NULL 356 && pe_data (ibfd) != NULL 357 && pe_data (ibfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE) 358 pe_data (obfd)->real_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE; 359 360 if (!_bfd_XX_bfd_copy_private_bfd_data_common (ibfd, obfd)) 361 return FALSE; 362 363 if (pe_saved_coff_bfd_copy_private_bfd_data) 364 return pe_saved_coff_bfd_copy_private_bfd_data (ibfd, obfd); 365 366 return TRUE; 367 } 368 369 #define coff_bfd_copy_private_section_data \ 370 _bfd_XX_bfd_copy_private_section_data 371 372 #define coff_get_symbol_info _bfd_XX_get_symbol_info 373 374 #ifdef COFF_IMAGE_WITH_PE 375 376 /* Code to handle Microsoft's Image Library Format. 377 Also known as LINK6 format. 378 Documentation about this format can be found at: 379 380 http://msdn.microsoft.com/library/specs/pecoff_section8.htm */ 381 382 /* The following constants specify the sizes of the various data 383 structures that we have to create in order to build a bfd describing 384 an ILF object file. The final "+ 1" in the definitions of SIZEOF_IDATA6 385 and SIZEOF_IDATA7 below is to allow for the possibility that we might 386 need a padding byte in order to ensure 16 bit alignment for the section's 387 contents. 388 389 The value for SIZEOF_ILF_STRINGS is computed as follows: 390 391 There will be NUM_ILF_SECTIONS section symbols. Allow 9 characters 392 per symbol for their names (longest section name is .idata$x). 393 394 There will be two symbols for the imported value, one the symbol name 395 and one with _imp__ prefixed. Allowing for the terminating nul's this 396 is strlen (symbol_name) * 2 + 8 + 21 + strlen (source_dll). 397 398 The strings in the string table must start STRING__SIZE_SIZE bytes into 399 the table in order to for the string lookup code in coffgen/coffcode to 400 work. */ 401 #define NUM_ILF_RELOCS 8 402 #define NUM_ILF_SECTIONS 6 403 #define NUM_ILF_SYMS (2 + NUM_ILF_SECTIONS) 404 405 #define SIZEOF_ILF_SYMS (NUM_ILF_SYMS * sizeof (* vars.sym_cache)) 406 #define SIZEOF_ILF_SYM_TABLE (NUM_ILF_SYMS * sizeof (* vars.sym_table)) 407 #define SIZEOF_ILF_NATIVE_SYMS (NUM_ILF_SYMS * sizeof (* vars.native_syms)) 408 #define SIZEOF_ILF_SYM_PTR_TABLE (NUM_ILF_SYMS * sizeof (* vars.sym_ptr_table)) 409 #define SIZEOF_ILF_EXT_SYMS (NUM_ILF_SYMS * sizeof (* vars.esym_table)) 410 #define SIZEOF_ILF_RELOCS (NUM_ILF_RELOCS * sizeof (* vars.reltab)) 411 #define SIZEOF_ILF_INT_RELOCS (NUM_ILF_RELOCS * sizeof (* vars.int_reltab)) 412 #define SIZEOF_ILF_STRINGS (strlen (symbol_name) * 2 + 8 \ 413 + 21 + strlen (source_dll) \ 414 + NUM_ILF_SECTIONS * 9 \ 415 + STRING_SIZE_SIZE) 416 #define SIZEOF_IDATA2 (5 * 4) 417 418 /* For PEx64 idata4 & 5 have thumb size of 8 bytes. */ 419 #ifdef COFF_WITH_pex64 420 #define SIZEOF_IDATA4 (2 * 4) 421 #define SIZEOF_IDATA5 (2 * 4) 422 #else 423 #define SIZEOF_IDATA4 (1 * 4) 424 #define SIZEOF_IDATA5 (1 * 4) 425 #endif 426 427 #define SIZEOF_IDATA6 (2 + strlen (symbol_name) + 1 + 1) 428 #define SIZEOF_IDATA7 (strlen (source_dll) + 1 + 1) 429 #define SIZEOF_ILF_SECTIONS (NUM_ILF_SECTIONS * sizeof (struct coff_section_tdata)) 430 431 #define ILF_DATA_SIZE \ 432 sizeof (* vars.bim) \ 433 + SIZEOF_ILF_SYMS \ 434 + SIZEOF_ILF_SYM_TABLE \ 435 + SIZEOF_ILF_NATIVE_SYMS \ 436 + SIZEOF_ILF_SYM_PTR_TABLE \ 437 + SIZEOF_ILF_EXT_SYMS \ 438 + SIZEOF_ILF_RELOCS \ 439 + SIZEOF_ILF_INT_RELOCS \ 440 + SIZEOF_ILF_STRINGS \ 441 + SIZEOF_IDATA2 \ 442 + SIZEOF_IDATA4 \ 443 + SIZEOF_IDATA5 \ 444 + SIZEOF_IDATA6 \ 445 + SIZEOF_IDATA7 \ 446 + SIZEOF_ILF_SECTIONS \ 447 + MAX_TEXT_SECTION_SIZE 448 449 /* Create an empty relocation against the given symbol. */ 450 451 static void 452 pe_ILF_make_a_symbol_reloc (pe_ILF_vars * vars, 453 bfd_vma address, 454 bfd_reloc_code_real_type reloc, 455 struct bfd_symbol ** sym, 456 unsigned int sym_index) 457 { 458 arelent * entry; 459 struct internal_reloc * internal; 460 461 entry = vars->reltab + vars->relcount; 462 internal = vars->int_reltab + vars->relcount; 463 464 entry->address = address; 465 entry->addend = 0; 466 entry->howto = bfd_reloc_type_lookup (vars->abfd, reloc); 467 entry->sym_ptr_ptr = sym; 468 469 internal->r_vaddr = address; 470 internal->r_symndx = sym_index; 471 internal->r_type = entry->howto->type; 472 473 vars->relcount ++; 474 475 BFD_ASSERT (vars->relcount <= NUM_ILF_RELOCS); 476 } 477 478 /* Create an empty relocation against the given section. */ 479 480 static void 481 pe_ILF_make_a_reloc (pe_ILF_vars * vars, 482 bfd_vma address, 483 bfd_reloc_code_real_type reloc, 484 asection_ptr sec) 485 { 486 pe_ILF_make_a_symbol_reloc (vars, address, reloc, sec->symbol_ptr_ptr, 487 coff_section_data (vars->abfd, sec)->i); 488 } 489 490 /* Move the queued relocs into the given section. */ 491 492 static void 493 pe_ILF_save_relocs (pe_ILF_vars * vars, 494 asection_ptr sec) 495 { 496 /* Make sure that there is somewhere to store the internal relocs. */ 497 if (coff_section_data (vars->abfd, sec) == NULL) 498 /* We should probably return an error indication here. */ 499 abort (); 500 501 coff_section_data (vars->abfd, sec)->relocs = vars->int_reltab; 502 coff_section_data (vars->abfd, sec)->keep_relocs = TRUE; 503 504 sec->relocation = vars->reltab; 505 sec->reloc_count = vars->relcount; 506 sec->flags |= SEC_RELOC; 507 508 vars->reltab += vars->relcount; 509 vars->int_reltab += vars->relcount; 510 vars->relcount = 0; 511 512 BFD_ASSERT ((bfd_byte *) vars->int_reltab < (bfd_byte *) vars->string_table); 513 } 514 515 /* Create a global symbol and add it to the relevant tables. */ 516 517 static void 518 pe_ILF_make_a_symbol (pe_ILF_vars * vars, 519 const char * prefix, 520 const char * symbol_name, 521 asection_ptr section, 522 flagword extra_flags) 523 { 524 coff_symbol_type * sym; 525 combined_entry_type * ent; 526 SYMENT * esym; 527 unsigned short sclass; 528 529 if (extra_flags & BSF_LOCAL) 530 sclass = C_STAT; 531 else 532 sclass = C_EXT; 533 534 #ifdef THUMBPEMAGIC 535 if (vars->magic == THUMBPEMAGIC) 536 { 537 if (extra_flags & BSF_FUNCTION) 538 sclass = C_THUMBEXTFUNC; 539 else if (extra_flags & BSF_LOCAL) 540 sclass = C_THUMBSTAT; 541 else 542 sclass = C_THUMBEXT; 543 } 544 #endif 545 546 BFD_ASSERT (vars->sym_index < NUM_ILF_SYMS); 547 548 sym = vars->sym_ptr; 549 ent = vars->native_ptr; 550 esym = vars->esym_ptr; 551 552 /* Copy the symbol's name into the string table. */ 553 sprintf (vars->string_ptr, "%s%s", prefix, symbol_name); 554 555 if (section == NULL) 556 section = (asection_ptr) & bfd_und_section; 557 558 /* Initialise the external symbol. */ 559 H_PUT_32 (vars->abfd, vars->string_ptr - vars->string_table, 560 esym->e.e.e_offset); 561 H_PUT_16 (vars->abfd, section->target_index, esym->e_scnum); 562 esym->e_sclass[0] = sclass; 563 564 /* The following initialisations are unnecessary - the memory is 565 zero initialised. They are just kept here as reminders. */ 566 567 /* Initialise the internal symbol structure. */ 568 ent->u.syment.n_sclass = sclass; 569 ent->u.syment.n_scnum = section->target_index; 570 ent->u.syment._n._n_n._n_offset = (bfd_hostptr_t) sym; 571 572 sym->symbol.the_bfd = vars->abfd; 573 sym->symbol.name = vars->string_ptr; 574 sym->symbol.flags = BSF_EXPORT | BSF_GLOBAL | extra_flags; 575 sym->symbol.section = section; 576 sym->native = ent; 577 578 * vars->table_ptr = vars->sym_index; 579 * vars->sym_ptr_ptr = sym; 580 581 /* Adjust pointers for the next symbol. */ 582 vars->sym_index ++; 583 vars->sym_ptr ++; 584 vars->sym_ptr_ptr ++; 585 vars->table_ptr ++; 586 vars->native_ptr ++; 587 vars->esym_ptr ++; 588 vars->string_ptr += strlen (symbol_name) + strlen (prefix) + 1; 589 590 BFD_ASSERT (vars->string_ptr < vars->end_string_ptr); 591 } 592 593 /* Create a section. */ 594 595 static asection_ptr 596 pe_ILF_make_a_section (pe_ILF_vars * vars, 597 const char * name, 598 unsigned int size, 599 flagword extra_flags) 600 { 601 asection_ptr sec; 602 flagword flags; 603 604 sec = bfd_make_section_old_way (vars->abfd, name); 605 if (sec == NULL) 606 return NULL; 607 608 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_IN_MEMORY; 609 610 bfd_set_section_flags (vars->abfd, sec, flags | extra_flags); 611 612 bfd_set_section_alignment (vars->abfd, sec, 2); 613 614 /* Check that we will not run out of space. */ 615 BFD_ASSERT (vars->data + size < vars->bim->buffer + vars->bim->size); 616 617 /* Set the section size and contents. The actual 618 contents are filled in by our parent. */ 619 bfd_set_section_size (vars->abfd, sec, (bfd_size_type) size); 620 sec->contents = vars->data; 621 sec->target_index = vars->sec_index ++; 622 623 /* Advance data pointer in the vars structure. */ 624 vars->data += size; 625 626 /* Skip the padding byte if it was not needed. 627 The logic here is that if the string length is odd, 628 then the entire string length, including the null byte, 629 is even and so the extra, padding byte, is not needed. */ 630 if (size & 1) 631 vars->data --; 632 633 /* Create a coff_section_tdata structure for our use. */ 634 sec->used_by_bfd = (struct coff_section_tdata *) vars->data; 635 vars->data += sizeof (struct coff_section_tdata); 636 637 BFD_ASSERT (vars->data <= vars->bim->buffer + vars->bim->size); 638 639 /* Create a symbol to refer to this section. */ 640 pe_ILF_make_a_symbol (vars, "", name, sec, BSF_LOCAL); 641 642 /* Cache the index to the symbol in the coff_section_data structure. */ 643 coff_section_data (vars->abfd, sec)->i = vars->sym_index - 1; 644 645 return sec; 646 } 647 648 /* This structure contains the code that goes into the .text section 649 in order to perform a jump into the DLL lookup table. The entries 650 in the table are index by the magic number used to represent the 651 machine type in the PE file. The contents of the data[] arrays in 652 these entries are stolen from the jtab[] arrays in ld/pe-dll.c. 653 The SIZE field says how many bytes in the DATA array are actually 654 used. The OFFSET field says where in the data array the address 655 of the .idata$5 section should be placed. */ 656 #define MAX_TEXT_SECTION_SIZE 32 657 658 typedef struct 659 { 660 unsigned short magic; 661 unsigned char data[MAX_TEXT_SECTION_SIZE]; 662 unsigned int size; 663 unsigned int offset; 664 } 665 jump_table; 666 667 static jump_table jtab[] = 668 { 669 #ifdef I386MAGIC 670 { I386MAGIC, 671 { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 }, 672 8, 2 673 }, 674 #endif 675 676 #ifdef AMD64MAGIC 677 { AMD64MAGIC, 678 { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 }, 679 8, 2 680 }, 681 #endif 682 683 #ifdef MC68MAGIC 684 { MC68MAGIC, 685 { /* XXX fill me in */ }, 686 0, 0 687 }, 688 #endif 689 690 #ifdef MIPS_ARCH_MAGIC_WINCE 691 { MIPS_ARCH_MAGIC_WINCE, 692 { 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d, 693 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 }, 694 16, 0 695 }, 696 #endif 697 698 #ifdef SH_ARCH_MAGIC_WINCE 699 { SH_ARCH_MAGIC_WINCE, 700 { 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 701 0x09, 0x00, 0x00, 0x00, 0x00, 0x00 }, 702 12, 8 703 }, 704 #endif 705 706 #ifdef ARMPEMAGIC 707 { ARMPEMAGIC, 708 { 0x00, 0xc0, 0x9f, 0xe5, 0x00, 0xf0, 709 0x9c, 0xe5, 0x00, 0x00, 0x00, 0x00}, 710 12, 8 711 }, 712 #endif 713 714 #ifdef THUMBPEMAGIC 715 { THUMBPEMAGIC, 716 { 0x40, 0xb4, 0x02, 0x4e, 0x36, 0x68, 0xb4, 0x46, 717 0x40, 0xbc, 0x60, 0x47, 0x00, 0x00, 0x00, 0x00 }, 718 16, 12 719 }, 720 #endif 721 { 0, { 0 }, 0, 0 } 722 }; 723 724 #ifndef NUM_ENTRIES 725 #define NUM_ENTRIES(a) (sizeof (a) / sizeof (a)[0]) 726 #endif 727 728 /* Build a full BFD from the information supplied in a ILF object. */ 729 730 static bfd_boolean 731 pe_ILF_build_a_bfd (bfd * abfd, 732 unsigned int magic, 733 char * symbol_name, 734 char * source_dll, 735 unsigned int ordinal, 736 unsigned int types) 737 { 738 bfd_byte * ptr; 739 pe_ILF_vars vars; 740 struct internal_filehdr internal_f; 741 unsigned int import_type; 742 unsigned int import_name_type; 743 asection_ptr id4, id5, id6 = NULL, text = NULL; 744 coff_symbol_type ** imp_sym; 745 unsigned int imp_index; 746 747 /* Decode and verify the types field of the ILF structure. */ 748 import_type = types & 0x3; 749 import_name_type = (types & 0x1c) >> 2; 750 751 switch (import_type) 752 { 753 case IMPORT_CODE: 754 case IMPORT_DATA: 755 break; 756 757 case IMPORT_CONST: 758 /* XXX code yet to be written. */ 759 _bfd_error_handler (_("%B: Unhandled import type; %x"), 760 abfd, import_type); 761 return FALSE; 762 763 default: 764 _bfd_error_handler (_("%B: Unrecognised import type; %x"), 765 abfd, import_type); 766 return FALSE; 767 } 768 769 switch (import_name_type) 770 { 771 case IMPORT_ORDINAL: 772 case IMPORT_NAME: 773 case IMPORT_NAME_NOPREFIX: 774 case IMPORT_NAME_UNDECORATE: 775 break; 776 777 default: 778 _bfd_error_handler (_("%B: Unrecognised import name type; %x"), 779 abfd, import_name_type); 780 return FALSE; 781 } 782 783 /* Initialise local variables. 784 785 Note these are kept in a structure rather than being 786 declared as statics since bfd frowns on global variables. 787 788 We are going to construct the contents of the BFD in memory, 789 so allocate all the space that we will need right now. */ 790 ptr = bfd_zalloc (abfd, (bfd_size_type) ILF_DATA_SIZE); 791 if (ptr == NULL) 792 return FALSE; 793 794 /* Create a bfd_in_memory structure. */ 795 vars.bim = (struct bfd_in_memory *) ptr; 796 vars.bim->buffer = ptr; 797 vars.bim->size = ILF_DATA_SIZE; 798 ptr += sizeof (* vars.bim); 799 800 /* Initialise the pointers to regions of the memory and the 801 other contents of the pe_ILF_vars structure as well. */ 802 vars.sym_cache = (coff_symbol_type *) ptr; 803 vars.sym_ptr = (coff_symbol_type *) ptr; 804 vars.sym_index = 0; 805 ptr += SIZEOF_ILF_SYMS; 806 807 vars.sym_table = (unsigned int *) ptr; 808 vars.table_ptr = (unsigned int *) ptr; 809 ptr += SIZEOF_ILF_SYM_TABLE; 810 811 vars.native_syms = (combined_entry_type *) ptr; 812 vars.native_ptr = (combined_entry_type *) ptr; 813 ptr += SIZEOF_ILF_NATIVE_SYMS; 814 815 vars.sym_ptr_table = (coff_symbol_type **) ptr; 816 vars.sym_ptr_ptr = (coff_symbol_type **) ptr; 817 ptr += SIZEOF_ILF_SYM_PTR_TABLE; 818 819 vars.esym_table = (SYMENT *) ptr; 820 vars.esym_ptr = (SYMENT *) ptr; 821 ptr += SIZEOF_ILF_EXT_SYMS; 822 823 vars.reltab = (arelent *) ptr; 824 vars.relcount = 0; 825 ptr += SIZEOF_ILF_RELOCS; 826 827 vars.int_reltab = (struct internal_reloc *) ptr; 828 ptr += SIZEOF_ILF_INT_RELOCS; 829 830 vars.string_table = (char *) ptr; 831 vars.string_ptr = (char *) ptr + STRING_SIZE_SIZE; 832 ptr += SIZEOF_ILF_STRINGS; 833 vars.end_string_ptr = (char *) ptr; 834 835 /* The remaining space in bim->buffer is used 836 by the pe_ILF_make_a_section() function. */ 837 vars.data = ptr; 838 vars.abfd = abfd; 839 vars.sec_index = 0; 840 vars.magic = magic; 841 842 /* Create the initial .idata$<n> sections: 843 [.idata$2: Import Directory Table -- not needed] 844 .idata$4: Import Lookup Table 845 .idata$5: Import Address Table 846 847 Note we do not create a .idata$3 section as this is 848 created for us by the linker script. */ 849 id4 = pe_ILF_make_a_section (& vars, ".idata$4", SIZEOF_IDATA4, 0); 850 id5 = pe_ILF_make_a_section (& vars, ".idata$5", SIZEOF_IDATA5, 0); 851 if (id4 == NULL || id5 == NULL) 852 return FALSE; 853 854 /* Fill in the contents of these sections. */ 855 if (import_name_type == IMPORT_ORDINAL) 856 { 857 if (ordinal == 0) 858 /* XXX - treat as IMPORT_NAME ??? */ 859 abort (); 860 861 #ifdef COFF_WITH_pex64 862 ((unsigned int *) id4->contents)[0] = ordinal; 863 ((unsigned int *) id4->contents)[1] = 0x80000000; 864 ((unsigned int *) id5->contents)[0] = ordinal; 865 ((unsigned int *) id5->contents)[1] = 0x80000000; 866 #else 867 * (unsigned int *) id4->contents = ordinal | 0x80000000; 868 * (unsigned int *) id5->contents = ordinal | 0x80000000; 869 #endif 870 } 871 else 872 { 873 char * symbol; 874 unsigned int len; 875 876 /* Create .idata$6 - the Hint Name Table. */ 877 id6 = pe_ILF_make_a_section (& vars, ".idata$6", SIZEOF_IDATA6, 0); 878 if (id6 == NULL) 879 return FALSE; 880 881 /* If necessary, trim the import symbol name. */ 882 symbol = symbol_name; 883 884 /* As used by MS compiler, '_', '@', and '?' are alternative 885 forms of USER_LABEL_PREFIX, with '?' for c++ mangled names, 886 '@' used for fastcall (in C), '_' everywhere else. Only one 887 of these is used for a symbol. We strip this leading char for 888 IMPORT_NAME_NOPREFIX and IMPORT_NAME_UNDECORATE as per the 889 PE COFF 6.0 spec (section 8.3, Import Name Type). */ 890 891 if (import_name_type != IMPORT_NAME) 892 { 893 char c = symbol[0]; 894 if (c == '_' || c == '@' || c == '?') 895 symbol++; 896 } 897 898 len = strlen (symbol); 899 if (import_name_type == IMPORT_NAME_UNDECORATE) 900 { 901 /* Truncate at the first '@'. */ 902 char *at = strchr (symbol, '@'); 903 904 if (at != NULL) 905 len = at - symbol; 906 } 907 908 id6->contents[0] = ordinal & 0xff; 909 id6->contents[1] = ordinal >> 8; 910 911 memcpy ((char *) id6->contents + 2, symbol, len); 912 id6->contents[len + 2] = '\0'; 913 } 914 915 if (import_name_type != IMPORT_ORDINAL) 916 { 917 pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_RVA, id6); 918 pe_ILF_save_relocs (&vars, id4); 919 920 pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_RVA, id6); 921 pe_ILF_save_relocs (&vars, id5); 922 } 923 924 /* Create extra sections depending upon the type of import we are dealing with. */ 925 switch (import_type) 926 { 927 int i; 928 929 case IMPORT_CODE: 930 /* Create a .text section. 931 First we need to look up its contents in the jump table. */ 932 for (i = NUM_ENTRIES (jtab); i--;) 933 { 934 if (jtab[i].size == 0) 935 continue; 936 if (jtab[i].magic == magic) 937 break; 938 } 939 /* If we did not find a matching entry something is wrong. */ 940 if (i < 0) 941 abort (); 942 943 /* Create the .text section. */ 944 text = pe_ILF_make_a_section (& vars, ".text", jtab[i].size, SEC_CODE); 945 if (text == NULL) 946 return FALSE; 947 948 /* Copy in the jump code. */ 949 memcpy (text->contents, jtab[i].data, jtab[i].size); 950 951 /* Create an import symbol. */ 952 pe_ILF_make_a_symbol (& vars, "__imp_", symbol_name, id5, 0); 953 imp_sym = vars.sym_ptr_ptr - 1; 954 imp_index = vars.sym_index - 1; 955 956 /* Create a reloc for the data in the text section. */ 957 #ifdef MIPS_ARCH_MAGIC_WINCE 958 if (magic == MIPS_ARCH_MAGIC_WINCE) 959 { 960 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 0, BFD_RELOC_HI16_S, 961 (struct bfd_symbol **) imp_sym, 962 imp_index); 963 pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_LO16, text); 964 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 4, BFD_RELOC_LO16, 965 (struct bfd_symbol **) imp_sym, 966 imp_index); 967 } 968 else 969 #endif 970 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset, 971 BFD_RELOC_32, (asymbol **) imp_sym, 972 imp_index); 973 974 pe_ILF_save_relocs (& vars, text); 975 break; 976 977 case IMPORT_DATA: 978 break; 979 980 default: 981 /* XXX code not yet written. */ 982 abort (); 983 } 984 985 /* Initialise the bfd. */ 986 memset (& internal_f, 0, sizeof (internal_f)); 987 988 internal_f.f_magic = magic; 989 internal_f.f_symptr = 0; 990 internal_f.f_nsyms = 0; 991 internal_f.f_flags = F_AR32WR | F_LNNO; /* XXX is this correct ? */ 992 993 if ( ! bfd_set_start_address (abfd, (bfd_vma) 0) 994 || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f)) 995 return FALSE; 996 997 if (bfd_coff_mkobject_hook (abfd, (void *) & internal_f, NULL) == NULL) 998 return FALSE; 999 1000 coff_data (abfd)->pe = 1; 1001 #ifdef THUMBPEMAGIC 1002 if (vars.magic == THUMBPEMAGIC) 1003 /* Stop some linker warnings about thumb code not supporting interworking. */ 1004 coff_data (abfd)->flags |= F_INTERWORK | F_INTERWORK_SET; 1005 #endif 1006 1007 /* Switch from file contents to memory contents. */ 1008 bfd_cache_close (abfd); 1009 1010 abfd->iostream = (void *) vars.bim; 1011 abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */; 1012 abfd->where = 0; 1013 obj_sym_filepos (abfd) = 0; 1014 1015 /* Now create a symbol describing the imported value. */ 1016 switch (import_type) 1017 { 1018 case IMPORT_CODE: 1019 pe_ILF_make_a_symbol (& vars, "", symbol_name, text, 1020 BSF_NOT_AT_END | BSF_FUNCTION); 1021 1022 /* Create an import symbol for the DLL, without the 1023 .dll suffix. */ 1024 ptr = (bfd_byte *) strrchr (source_dll, '.'); 1025 if (ptr) 1026 * ptr = 0; 1027 pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0); 1028 if (ptr) 1029 * ptr = '.'; 1030 break; 1031 1032 case IMPORT_DATA: 1033 /* Nothing to do here. */ 1034 break; 1035 1036 default: 1037 /* XXX code not yet written. */ 1038 abort (); 1039 } 1040 1041 /* Point the bfd at the symbol table. */ 1042 obj_symbols (abfd) = vars.sym_cache; 1043 bfd_get_symcount (abfd) = vars.sym_index; 1044 1045 obj_raw_syments (abfd) = vars.native_syms; 1046 obj_raw_syment_count (abfd) = vars.sym_index; 1047 1048 obj_coff_external_syms (abfd) = (void *) vars.esym_table; 1049 obj_coff_keep_syms (abfd) = TRUE; 1050 1051 obj_convert (abfd) = vars.sym_table; 1052 obj_conv_table_size (abfd) = vars.sym_index; 1053 1054 obj_coff_strings (abfd) = vars.string_table; 1055 obj_coff_keep_strings (abfd) = TRUE; 1056 1057 abfd->flags |= HAS_SYMS; 1058 1059 return TRUE; 1060 } 1061 1062 /* We have detected a Image Library Format archive element. 1063 Decode the element and return the appropriate target. */ 1064 1065 static const bfd_target * 1066 pe_ILF_object_p (bfd * abfd) 1067 { 1068 bfd_byte buffer[16]; 1069 bfd_byte * ptr; 1070 char * symbol_name; 1071 char * source_dll; 1072 unsigned int machine; 1073 bfd_size_type size; 1074 unsigned int ordinal; 1075 unsigned int types; 1076 unsigned int magic; 1077 1078 /* Upon entry the first four buyes of the ILF header have 1079 already been read. Now read the rest of the header. */ 1080 if (bfd_bread (buffer, (bfd_size_type) 16, abfd) != 16) 1081 return NULL; 1082 1083 ptr = buffer; 1084 1085 /* We do not bother to check the version number. 1086 version = H_GET_16 (abfd, ptr); */ 1087 ptr += 2; 1088 1089 machine = H_GET_16 (abfd, ptr); 1090 ptr += 2; 1091 1092 /* Check that the machine type is recognised. */ 1093 magic = 0; 1094 1095 switch (machine) 1096 { 1097 case IMAGE_FILE_MACHINE_UNKNOWN: 1098 case IMAGE_FILE_MACHINE_ALPHA: 1099 case IMAGE_FILE_MACHINE_ALPHA64: 1100 case IMAGE_FILE_MACHINE_IA64: 1101 break; 1102 1103 case IMAGE_FILE_MACHINE_I386: 1104 #ifdef I386MAGIC 1105 magic = I386MAGIC; 1106 #endif 1107 break; 1108 1109 case IMAGE_FILE_MACHINE_AMD64: 1110 #ifdef AMD64MAGIC 1111 magic = AMD64MAGIC; 1112 #endif 1113 break; 1114 1115 case IMAGE_FILE_MACHINE_M68K: 1116 #ifdef MC68AGIC 1117 magic = MC68MAGIC; 1118 #endif 1119 break; 1120 1121 case IMAGE_FILE_MACHINE_R3000: 1122 case IMAGE_FILE_MACHINE_R4000: 1123 case IMAGE_FILE_MACHINE_R10000: 1124 1125 case IMAGE_FILE_MACHINE_MIPS16: 1126 case IMAGE_FILE_MACHINE_MIPSFPU: 1127 case IMAGE_FILE_MACHINE_MIPSFPU16: 1128 #ifdef MIPS_ARCH_MAGIC_WINCE 1129 magic = MIPS_ARCH_MAGIC_WINCE; 1130 #endif 1131 break; 1132 1133 case IMAGE_FILE_MACHINE_SH3: 1134 case IMAGE_FILE_MACHINE_SH4: 1135 #ifdef SH_ARCH_MAGIC_WINCE 1136 magic = SH_ARCH_MAGIC_WINCE; 1137 #endif 1138 break; 1139 1140 case IMAGE_FILE_MACHINE_ARM: 1141 #ifdef ARMPEMAGIC 1142 magic = ARMPEMAGIC; 1143 #endif 1144 break; 1145 1146 case IMAGE_FILE_MACHINE_THUMB: 1147 #ifdef THUMBPEMAGIC 1148 { 1149 extern const bfd_target TARGET_LITTLE_SYM; 1150 1151 if (abfd->xvec == & TARGET_LITTLE_SYM) 1152 magic = THUMBPEMAGIC; 1153 } 1154 #endif 1155 break; 1156 1157 case IMAGE_FILE_MACHINE_POWERPC: 1158 /* We no longer support PowerPC. */ 1159 default: 1160 _bfd_error_handler 1161 (_("%B: Unrecognised machine type (0x%x)" 1162 " in Import Library Format archive"), 1163 abfd, machine); 1164 bfd_set_error (bfd_error_malformed_archive); 1165 1166 return NULL; 1167 break; 1168 } 1169 1170 if (magic == 0) 1171 { 1172 _bfd_error_handler 1173 (_("%B: Recognised but unhandled machine type (0x%x)" 1174 " in Import Library Format archive"), 1175 abfd, machine); 1176 bfd_set_error (bfd_error_wrong_format); 1177 1178 return NULL; 1179 } 1180 1181 /* We do not bother to check the date. 1182 date = H_GET_32 (abfd, ptr); */ 1183 ptr += 4; 1184 1185 size = H_GET_32 (abfd, ptr); 1186 ptr += 4; 1187 1188 if (size == 0) 1189 { 1190 _bfd_error_handler 1191 (_("%B: size field is zero in Import Library Format header"), abfd); 1192 bfd_set_error (bfd_error_malformed_archive); 1193 1194 return NULL; 1195 } 1196 1197 ordinal = H_GET_16 (abfd, ptr); 1198 ptr += 2; 1199 1200 types = H_GET_16 (abfd, ptr); 1201 /* ptr += 2; */ 1202 1203 /* Now read in the two strings that follow. */ 1204 ptr = bfd_alloc (abfd, size); 1205 if (ptr == NULL) 1206 return NULL; 1207 1208 if (bfd_bread (ptr, size, abfd) != size) 1209 { 1210 bfd_release (abfd, ptr); 1211 return NULL; 1212 } 1213 1214 symbol_name = (char *) ptr; 1215 source_dll = symbol_name + strlen (symbol_name) + 1; 1216 1217 /* Verify that the strings are null terminated. */ 1218 if (ptr[size - 1] != 0 1219 || (bfd_size_type) ((bfd_byte *) source_dll - ptr) >= size) 1220 { 1221 _bfd_error_handler 1222 (_("%B: string not null terminated in ILF object file."), abfd); 1223 bfd_set_error (bfd_error_malformed_archive); 1224 bfd_release (abfd, ptr); 1225 return NULL; 1226 } 1227 1228 /* Now construct the bfd. */ 1229 if (! pe_ILF_build_a_bfd (abfd, magic, symbol_name, 1230 source_dll, ordinal, types)) 1231 { 1232 bfd_release (abfd, ptr); 1233 return NULL; 1234 } 1235 1236 return abfd->xvec; 1237 } 1238 1239 enum arch_type 1240 { 1241 arch_type_unknown, 1242 arch_type_i386, 1243 arch_type_x86_64 1244 }; 1245 1246 static enum arch_type 1247 pe_arch (const char *arch) 1248 { 1249 if (strcmp (arch, "i386") == 0 || strcmp (arch, "ia32") == 0) 1250 return arch_type_i386; 1251 1252 if (strcmp (arch, "x86_64") == 0 || strcmp (arch, "x86-64") == 0) 1253 return arch_type_x86_64; 1254 1255 return arch_type_unknown; 1256 } 1257 1258 static const bfd_target * 1259 pe_bfd_object_p (bfd * abfd) 1260 { 1261 bfd_byte buffer[4]; 1262 struct external_PEI_DOS_hdr dos_hdr; 1263 struct external_PEI_IMAGE_hdr image_hdr; 1264 file_ptr offset; 1265 const bfd_target *target; 1266 struct bfd_preserve preserve; 1267 1268 /* Detect if this a Microsoft Import Library Format element. */ 1269 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 1270 || bfd_bread (buffer, (bfd_size_type) 4, abfd) != 4) 1271 { 1272 if (bfd_get_error () != bfd_error_system_call) 1273 bfd_set_error (bfd_error_wrong_format); 1274 return NULL; 1275 } 1276 1277 if (H_GET_32 (abfd, buffer) == 0xffff0000) 1278 return pe_ILF_object_p (abfd); 1279 1280 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 1281 || bfd_bread (&dos_hdr, (bfd_size_type) sizeof (dos_hdr), abfd) 1282 != sizeof (dos_hdr)) 1283 { 1284 if (bfd_get_error () != bfd_error_system_call) 1285 bfd_set_error (bfd_error_wrong_format); 1286 return NULL; 1287 } 1288 1289 /* There are really two magic numbers involved; the magic number 1290 that says this is a NT executable (PEI) and the magic number that 1291 determines the architecture. The former is DOSMAGIC, stored in 1292 the e_magic field. The latter is stored in the f_magic field. 1293 If the NT magic number isn't valid, the architecture magic number 1294 could be mimicked by some other field (specifically, the number 1295 of relocs in section 3). Since this routine can only be called 1296 correctly for a PEI file, check the e_magic number here, and, if 1297 it doesn't match, clobber the f_magic number so that we don't get 1298 a false match. */ 1299 if (H_GET_16 (abfd, dos_hdr.e_magic) != DOSMAGIC) 1300 { 1301 bfd_set_error (bfd_error_wrong_format); 1302 return NULL; 1303 } 1304 1305 offset = H_GET_32 (abfd, dos_hdr.e_lfanew); 1306 if (bfd_seek (abfd, offset, SEEK_SET) != 0 1307 || (bfd_bread (&image_hdr, (bfd_size_type) sizeof (image_hdr), abfd) 1308 != sizeof (image_hdr))) 1309 { 1310 if (bfd_get_error () != bfd_error_system_call) 1311 bfd_set_error (bfd_error_wrong_format); 1312 return NULL; 1313 } 1314 1315 if (H_GET_32 (abfd, image_hdr.nt_signature) != 0x4550) 1316 { 1317 bfd_set_error (bfd_error_wrong_format); 1318 return NULL; 1319 } 1320 1321 /* Here is the hack. coff_object_p wants to read filhsz bytes to 1322 pick up the COFF header for PE, see "struct external_PEI_filehdr" 1323 in include/coff/pe.h. We adjust so that that will work. */ 1324 if (bfd_seek (abfd, (file_ptr) (offset - sizeof (dos_hdr)), SEEK_SET) != 0) 1325 { 1326 if (bfd_get_error () != bfd_error_system_call) 1327 bfd_set_error (bfd_error_wrong_format); 1328 return NULL; 1329 } 1330 1331 preserve.marker = NULL; 1332 if (! bfd_preserve_save (abfd, &preserve)) 1333 return NULL; 1334 1335 target = coff_object_p (abfd); 1336 if (target) 1337 { 1338 pe_data_type *pe = pe_data (abfd); 1339 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr; 1340 bfd_boolean efi = i->Subsystem == IMAGE_SUBSYSTEM_EFI_APPLICATION 1341 || i->Subsystem == IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER 1342 || i->Subsystem == IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER; 1343 enum arch_type arch; 1344 const bfd_target * const *target_ptr; 1345 1346 /* Get the machine. */ 1347 if (bfd_target_efi_app_p (abfd->xvec)) 1348 arch = pe_arch (bfd_target_efi_app_arch (abfd->xvec)); 1349 else if (bfd_target_efi_bsdrv_p (abfd->xvec)) 1350 arch = pe_arch (bfd_target_efi_bsdrv_arch (abfd->xvec)); 1351 else if (bfd_target_efi_rtdrv_p (abfd->xvec)) 1352 arch = pe_arch (bfd_target_efi_rtdrv_arch (abfd->xvec)); 1353 else 1354 arch = pe_arch (bfd_target_pei_arch (abfd->xvec)); 1355 1356 /* Don't check PE vs. EFI if arch is unknown. */ 1357 if (arch == arch_type_unknown) 1358 { 1359 bfd_preserve_finish (abfd, &preserve); 1360 return target; 1361 } 1362 1363 for (target_ptr = bfd_target_vector; *target_ptr != NULL; 1364 target_ptr++) 1365 { 1366 if (*target_ptr == target 1367 || (*target_ptr)->flavour != bfd_target_coff_flavour) 1368 continue; 1369 1370 if (bfd_target_efi_app_p (*target_ptr)) 1371 { 1372 /* Skip incompatible arch. */ 1373 if (pe_arch (bfd_target_efi_app_arch (*target_ptr)) != arch) 1374 continue; 1375 1376 if (efi) 1377 { 1378 /* TARGET_PTR is an EFI backend. Don't match 1379 TARGET with a EFI file. */ 1380 bfd_set_error (bfd_error_wrong_format); 1381 return NULL; 1382 } 1383 } 1384 else if (bfd_target_efi_bsdrv_p (*target_ptr)) 1385 { 1386 /* Skip incompatible arch. */ 1387 if (pe_arch (bfd_target_efi_bsdrv_arch (*target_ptr)) != arch) 1388 continue; 1389 1390 if (efi) 1391 { 1392 /* TARGET_PTR is an EFI backend. Don't match 1393 TARGET with a EFI file. */ 1394 bfd_set_error (bfd_error_wrong_format); 1395 return NULL; 1396 } 1397 } 1398 else if (bfd_target_efi_rtdrv_p (*target_ptr)) 1399 { 1400 /* Skip incompatible arch. */ 1401 if (pe_arch (bfd_target_efi_rtdrv_arch (*target_ptr)) != arch) 1402 continue; 1403 1404 if (efi) 1405 { 1406 no_match: 1407 /* TARGET_PTR is an EFI backend. Don't match 1408 TARGET with a EFI file. */ 1409 bfd_preserve_restore (abfd, &preserve); 1410 bfd_set_error (bfd_error_wrong_format); 1411 return NULL; 1412 } 1413 } 1414 else if (bfd_target_pei_p (*target_ptr)) 1415 { 1416 /* Skip incompatible arch. */ 1417 if (pe_arch (bfd_target_pei_arch (*target_ptr)) != arch) 1418 continue; 1419 1420 if (!efi) 1421 { 1422 /* TARGET_PTR is a PE backend. Don't match 1423 TARGET with a PE file. */ 1424 goto no_match; 1425 } 1426 } 1427 } 1428 1429 bfd_preserve_finish (abfd, &preserve); 1430 } 1431 else 1432 bfd_preserve_restore (abfd, &preserve); 1433 1434 return target; 1435 } 1436 1437 #define coff_object_p pe_bfd_object_p 1438 #endif /* COFF_IMAGE_WITH_PE */ 1439