1 /* Support for the generic parts of PE/PEI, for BFD. 2 Copyright (C) 1995-2015 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 extra sections depending upon the type of import we are dealing with. */ 963 switch (import_type) 964 { 965 int i; 966 967 case IMPORT_CODE: 968 /* Create a .text section. 969 First we need to look up its contents in the jump table. */ 970 for (i = NUM_ENTRIES (jtab); i--;) 971 { 972 if (jtab[i].size == 0) 973 continue; 974 if (jtab[i].magic == magic) 975 break; 976 } 977 /* If we did not find a matching entry something is wrong. */ 978 if (i < 0) 979 abort (); 980 981 /* Create the .text section. */ 982 text = pe_ILF_make_a_section (& vars, ".text", jtab[i].size, SEC_CODE); 983 if (text == NULL) 984 goto error_return; 985 986 /* Copy in the jump code. */ 987 memcpy (text->contents, jtab[i].data, jtab[i].size); 988 989 /* Create an import symbol. */ 990 pe_ILF_make_a_symbol (& vars, "__imp_", symbol_name, id5, 0); 991 imp_sym = vars.sym_ptr_ptr - 1; 992 imp_index = vars.sym_index - 1; 993 994 /* Create a reloc for the data in the text section. */ 995 #ifdef MIPS_ARCH_MAGIC_WINCE 996 if (magic == MIPS_ARCH_MAGIC_WINCE) 997 { 998 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 0, BFD_RELOC_HI16_S, 999 (struct bfd_symbol **) imp_sym, 1000 imp_index); 1001 pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_LO16, text); 1002 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 4, BFD_RELOC_LO16, 1003 (struct bfd_symbol **) imp_sym, 1004 imp_index); 1005 } 1006 else 1007 #endif 1008 #ifdef AMD64MAGIC 1009 if (magic == AMD64MAGIC) 1010 { 1011 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset, 1012 BFD_RELOC_32_PCREL, (asymbol **) imp_sym, 1013 imp_index); 1014 } 1015 else 1016 #endif 1017 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset, 1018 BFD_RELOC_32, (asymbol **) imp_sym, 1019 imp_index); 1020 1021 pe_ILF_save_relocs (& vars, text); 1022 break; 1023 1024 case IMPORT_DATA: 1025 break; 1026 1027 default: 1028 /* XXX code not yet written. */ 1029 abort (); 1030 } 1031 1032 /* Initialise the bfd. */ 1033 memset (& internal_f, 0, sizeof (internal_f)); 1034 1035 internal_f.f_magic = magic; 1036 internal_f.f_symptr = 0; 1037 internal_f.f_nsyms = 0; 1038 internal_f.f_flags = F_AR32WR | F_LNNO; /* XXX is this correct ? */ 1039 1040 if ( ! bfd_set_start_address (abfd, (bfd_vma) 0) 1041 || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f)) 1042 goto error_return; 1043 1044 if (bfd_coff_mkobject_hook (abfd, (void *) & internal_f, NULL) == NULL) 1045 goto error_return; 1046 1047 coff_data (abfd)->pe = 1; 1048 #ifdef THUMBPEMAGIC 1049 if (vars.magic == THUMBPEMAGIC) 1050 /* Stop some linker warnings about thumb code not supporting interworking. */ 1051 coff_data (abfd)->flags |= F_INTERWORK | F_INTERWORK_SET; 1052 #endif 1053 1054 /* Switch from file contents to memory contents. */ 1055 bfd_cache_close (abfd); 1056 1057 abfd->iostream = (void *) vars.bim; 1058 abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */; 1059 abfd->iovec = &_bfd_memory_iovec; 1060 abfd->where = 0; 1061 abfd->origin = 0; 1062 obj_sym_filepos (abfd) = 0; 1063 1064 /* Now create a symbol describing the imported value. */ 1065 switch (import_type) 1066 { 1067 case IMPORT_CODE: 1068 pe_ILF_make_a_symbol (& vars, "", symbol_name, text, 1069 BSF_NOT_AT_END | BSF_FUNCTION); 1070 1071 /* Create an import symbol for the DLL, without the 1072 .dll suffix. */ 1073 ptr = (bfd_byte *) strrchr (source_dll, '.'); 1074 if (ptr) 1075 * ptr = 0; 1076 pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0); 1077 if (ptr) 1078 * ptr = '.'; 1079 break; 1080 1081 case IMPORT_DATA: 1082 /* Nothing to do here. */ 1083 break; 1084 1085 default: 1086 /* XXX code not yet written. */ 1087 abort (); 1088 } 1089 1090 /* Point the bfd at the symbol table. */ 1091 obj_symbols (abfd) = vars.sym_cache; 1092 bfd_get_symcount (abfd) = vars.sym_index; 1093 1094 obj_raw_syments (abfd) = vars.native_syms; 1095 obj_raw_syment_count (abfd) = vars.sym_index; 1096 1097 obj_coff_external_syms (abfd) = (void *) vars.esym_table; 1098 obj_coff_keep_syms (abfd) = TRUE; 1099 1100 obj_convert (abfd) = vars.sym_table; 1101 obj_conv_table_size (abfd) = vars.sym_index; 1102 1103 obj_coff_strings (abfd) = vars.string_table; 1104 obj_coff_keep_strings (abfd) = TRUE; 1105 1106 abfd->flags |= HAS_SYMS; 1107 1108 return TRUE; 1109 1110 error_return: 1111 if (vars.bim->buffer != NULL) 1112 free (vars.bim->buffer); 1113 free (vars.bim); 1114 return FALSE; 1115 } 1116 1117 /* We have detected a Image Library Format archive element. 1118 Decode the element and return the appropriate target. */ 1119 1120 static const bfd_target * 1121 pe_ILF_object_p (bfd * abfd) 1122 { 1123 bfd_byte buffer[14]; 1124 bfd_byte * ptr; 1125 char * symbol_name; 1126 char * source_dll; 1127 unsigned int machine; 1128 bfd_size_type size; 1129 unsigned int ordinal; 1130 unsigned int types; 1131 unsigned int magic; 1132 1133 /* Upon entry the first six bytes of the ILF header have 1134 already been read. Now read the rest of the header. */ 1135 if (bfd_bread (buffer, (bfd_size_type) 14, abfd) != 14) 1136 return NULL; 1137 1138 ptr = buffer; 1139 1140 machine = H_GET_16 (abfd, ptr); 1141 ptr += 2; 1142 1143 /* Check that the machine type is recognised. */ 1144 magic = 0; 1145 1146 switch (machine) 1147 { 1148 case IMAGE_FILE_MACHINE_UNKNOWN: 1149 case IMAGE_FILE_MACHINE_ALPHA: 1150 case IMAGE_FILE_MACHINE_ALPHA64: 1151 case IMAGE_FILE_MACHINE_IA64: 1152 break; 1153 1154 case IMAGE_FILE_MACHINE_I386: 1155 #ifdef I386MAGIC 1156 magic = I386MAGIC; 1157 #endif 1158 break; 1159 1160 case IMAGE_FILE_MACHINE_AMD64: 1161 #ifdef AMD64MAGIC 1162 magic = AMD64MAGIC; 1163 #endif 1164 break; 1165 1166 case IMAGE_FILE_MACHINE_M68K: 1167 #ifdef MC68AGIC 1168 magic = MC68MAGIC; 1169 #endif 1170 break; 1171 1172 case IMAGE_FILE_MACHINE_R3000: 1173 case IMAGE_FILE_MACHINE_R4000: 1174 case IMAGE_FILE_MACHINE_R10000: 1175 1176 case IMAGE_FILE_MACHINE_MIPS16: 1177 case IMAGE_FILE_MACHINE_MIPSFPU: 1178 case IMAGE_FILE_MACHINE_MIPSFPU16: 1179 #ifdef MIPS_ARCH_MAGIC_WINCE 1180 magic = MIPS_ARCH_MAGIC_WINCE; 1181 #endif 1182 break; 1183 1184 case IMAGE_FILE_MACHINE_SH3: 1185 case IMAGE_FILE_MACHINE_SH4: 1186 #ifdef SH_ARCH_MAGIC_WINCE 1187 magic = SH_ARCH_MAGIC_WINCE; 1188 #endif 1189 break; 1190 1191 case IMAGE_FILE_MACHINE_ARM: 1192 #ifdef ARMPEMAGIC 1193 magic = ARMPEMAGIC; 1194 #endif 1195 break; 1196 1197 case IMAGE_FILE_MACHINE_THUMB: 1198 #ifdef THUMBPEMAGIC 1199 { 1200 extern const bfd_target TARGET_LITTLE_SYM; 1201 1202 if (abfd->xvec == & TARGET_LITTLE_SYM) 1203 magic = THUMBPEMAGIC; 1204 } 1205 #endif 1206 break; 1207 1208 case IMAGE_FILE_MACHINE_POWERPC: 1209 /* We no longer support PowerPC. */ 1210 default: 1211 _bfd_error_handler 1212 (_("%B: Unrecognised machine type (0x%x)" 1213 " in Import Library Format archive"), 1214 abfd, machine); 1215 bfd_set_error (bfd_error_malformed_archive); 1216 1217 return NULL; 1218 break; 1219 } 1220 1221 if (magic == 0) 1222 { 1223 _bfd_error_handler 1224 (_("%B: Recognised but unhandled machine type (0x%x)" 1225 " in Import Library Format archive"), 1226 abfd, machine); 1227 bfd_set_error (bfd_error_wrong_format); 1228 1229 return NULL; 1230 } 1231 1232 /* We do not bother to check the date. 1233 date = H_GET_32 (abfd, ptr); */ 1234 ptr += 4; 1235 1236 size = H_GET_32 (abfd, ptr); 1237 ptr += 4; 1238 1239 if (size == 0) 1240 { 1241 _bfd_error_handler 1242 (_("%B: size field is zero in Import Library Format header"), abfd); 1243 bfd_set_error (bfd_error_malformed_archive); 1244 1245 return NULL; 1246 } 1247 1248 ordinal = H_GET_16 (abfd, ptr); 1249 ptr += 2; 1250 1251 types = H_GET_16 (abfd, ptr); 1252 /* ptr += 2; */ 1253 1254 /* Now read in the two strings that follow. */ 1255 ptr = (bfd_byte *) bfd_alloc (abfd, size); 1256 if (ptr == NULL) 1257 return NULL; 1258 1259 if (bfd_bread (ptr, size, abfd) != size) 1260 { 1261 bfd_release (abfd, ptr); 1262 return NULL; 1263 } 1264 1265 symbol_name = (char *) ptr; 1266 source_dll = symbol_name + strlen (symbol_name) + 1; 1267 1268 /* Verify that the strings are null terminated. */ 1269 if (ptr[size - 1] != 0 1270 || (bfd_size_type) ((bfd_byte *) source_dll - ptr) >= size) 1271 { 1272 _bfd_error_handler 1273 (_("%B: string not null terminated in ILF object file."), abfd); 1274 bfd_set_error (bfd_error_malformed_archive); 1275 bfd_release (abfd, ptr); 1276 return NULL; 1277 } 1278 1279 /* Now construct the bfd. */ 1280 if (! pe_ILF_build_a_bfd (abfd, magic, symbol_name, 1281 source_dll, ordinal, types)) 1282 { 1283 bfd_release (abfd, ptr); 1284 return NULL; 1285 } 1286 1287 return abfd->xvec; 1288 } 1289 1290 static void 1291 pe_bfd_read_buildid(bfd *abfd) 1292 { 1293 pe_data_type *pe = pe_data (abfd); 1294 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr; 1295 asection *section; 1296 bfd_byte *data = 0; 1297 bfd_size_type dataoff; 1298 unsigned int i; 1299 1300 bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress; 1301 bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size; 1302 1303 if (size == 0) 1304 return; 1305 1306 addr += extra->ImageBase; 1307 1308 /* Search for the section containing the DebugDirectory */ 1309 for (section = abfd->sections; section != NULL; section = section->next) 1310 { 1311 if ((addr >= section->vma) && (addr < (section->vma + section->size))) 1312 break; 1313 } 1314 1315 if (section == NULL) 1316 { 1317 return; 1318 } 1319 else if (!(section->flags & SEC_HAS_CONTENTS)) 1320 { 1321 return; 1322 } 1323 1324 dataoff = addr - section->vma; 1325 1326 /* Read the whole section. */ 1327 if (!bfd_malloc_and_get_section (abfd, section, &data)) 1328 { 1329 if (data != NULL) 1330 free (data); 1331 return; 1332 } 1333 1334 /* Search for a CodeView entry in the DebugDirectory */ 1335 for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++) 1336 { 1337 struct external_IMAGE_DEBUG_DIRECTORY *ext 1338 = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i]; 1339 struct internal_IMAGE_DEBUG_DIRECTORY idd; 1340 1341 _bfd_XXi_swap_debugdir_in (abfd, ext, &idd); 1342 1343 if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW) 1344 { 1345 char buffer[256 + 1]; 1346 CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer; 1347 1348 /* 1349 The debug entry doesn't have to have to be in a section, in which 1350 case AddressOfRawData is 0, so always use PointerToRawData. 1351 */ 1352 if (_bfd_XXi_slurp_codeview_record (abfd, 1353 (file_ptr) idd.PointerToRawData, 1354 idd.SizeOfData, cvinfo)) 1355 { 1356 struct bfd_build_id* build_id = bfd_alloc(abfd, 1357 sizeof(struct bfd_build_id) + cvinfo->SignatureLength); 1358 if (build_id) 1359 { 1360 build_id->size = cvinfo->SignatureLength; 1361 memcpy(build_id->data, cvinfo->Signature, 1362 cvinfo->SignatureLength); 1363 abfd->build_id = build_id; 1364 } 1365 } 1366 break; 1367 } 1368 } 1369 } 1370 1371 static const bfd_target * 1372 pe_bfd_object_p (bfd * abfd) 1373 { 1374 bfd_byte buffer[6]; 1375 struct external_PEI_DOS_hdr dos_hdr; 1376 struct external_PEI_IMAGE_hdr image_hdr; 1377 struct internal_filehdr internal_f; 1378 struct internal_aouthdr internal_a; 1379 file_ptr opt_hdr_size; 1380 file_ptr offset; 1381 const bfd_target *result; 1382 1383 /* Detect if this a Microsoft Import Library Format element. */ 1384 /* First read the beginning of the header. */ 1385 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 1386 || bfd_bread (buffer, (bfd_size_type) 6, abfd) != 6) 1387 { 1388 if (bfd_get_error () != bfd_error_system_call) 1389 bfd_set_error (bfd_error_wrong_format); 1390 return NULL; 1391 } 1392 1393 /* Then check the magic and the version (only 0 is supported). */ 1394 if (H_GET_32 (abfd, buffer) == 0xffff0000 1395 && H_GET_16 (abfd, buffer + 4) == 0) 1396 return pe_ILF_object_p (abfd); 1397 1398 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 1399 || bfd_bread (&dos_hdr, (bfd_size_type) sizeof (dos_hdr), abfd) 1400 != sizeof (dos_hdr)) 1401 { 1402 if (bfd_get_error () != bfd_error_system_call) 1403 bfd_set_error (bfd_error_wrong_format); 1404 return NULL; 1405 } 1406 1407 /* There are really two magic numbers involved; the magic number 1408 that says this is a NT executable (PEI) and the magic number that 1409 determines the architecture. The former is DOSMAGIC, stored in 1410 the e_magic field. The latter is stored in the f_magic field. 1411 If the NT magic number isn't valid, the architecture magic number 1412 could be mimicked by some other field (specifically, the number 1413 of relocs in section 3). Since this routine can only be called 1414 correctly for a PEI file, check the e_magic number here, and, if 1415 it doesn't match, clobber the f_magic number so that we don't get 1416 a false match. */ 1417 if (H_GET_16 (abfd, dos_hdr.e_magic) != DOSMAGIC) 1418 { 1419 bfd_set_error (bfd_error_wrong_format); 1420 return NULL; 1421 } 1422 1423 offset = H_GET_32 (abfd, dos_hdr.e_lfanew); 1424 if (bfd_seek (abfd, offset, SEEK_SET) != 0 1425 || (bfd_bread (&image_hdr, (bfd_size_type) sizeof (image_hdr), abfd) 1426 != sizeof (image_hdr))) 1427 { 1428 if (bfd_get_error () != bfd_error_system_call) 1429 bfd_set_error (bfd_error_wrong_format); 1430 return NULL; 1431 } 1432 1433 if (H_GET_32 (abfd, image_hdr.nt_signature) != 0x4550) 1434 { 1435 bfd_set_error (bfd_error_wrong_format); 1436 return NULL; 1437 } 1438 1439 /* Swap file header, so that we get the location for calling 1440 real_object_p. */ 1441 bfd_coff_swap_filehdr_in (abfd, &image_hdr, &internal_f); 1442 1443 if (! bfd_coff_bad_format_hook (abfd, &internal_f) 1444 || internal_f.f_opthdr > bfd_coff_aoutsz (abfd)) 1445 { 1446 bfd_set_error (bfd_error_wrong_format); 1447 return NULL; 1448 } 1449 1450 /* Read the optional header, which has variable size. */ 1451 opt_hdr_size = internal_f.f_opthdr; 1452 1453 if (opt_hdr_size != 0) 1454 { 1455 bfd_size_type amt = opt_hdr_size; 1456 void * opthdr; 1457 1458 /* PR 17521 file: 230-131433-0.004. */ 1459 if (amt < sizeof (PEAOUTHDR)) 1460 amt = sizeof (PEAOUTHDR); 1461 1462 opthdr = bfd_zalloc (abfd, amt); 1463 if (opthdr == NULL) 1464 return NULL; 1465 if (bfd_bread (opthdr, opt_hdr_size, abfd) 1466 != (bfd_size_type) opt_hdr_size) 1467 return NULL; 1468 1469 bfd_set_error (bfd_error_no_error); 1470 bfd_coff_swap_aouthdr_in (abfd, opthdr, & internal_a); 1471 if (bfd_get_error () != bfd_error_no_error) 1472 return NULL; 1473 } 1474 1475 1476 result = coff_real_object_p (abfd, internal_f.f_nscns, &internal_f, 1477 (opt_hdr_size != 0 1478 ? &internal_a 1479 : (struct internal_aouthdr *) NULL)); 1480 1481 1482 if (result) 1483 { 1484 /* Now the whole header has been processed, see if there is a build-id */ 1485 pe_bfd_read_buildid(abfd); 1486 } 1487 1488 return result; 1489 } 1490 1491 #define coff_object_p pe_bfd_object_p 1492 #endif /* COFF_IMAGE_WITH_PE */ 1493