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