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