1 /* Support for the generic parts of PE/PEI, for BFD. 2 Copyright (C) 1995-2018 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 /* xgettext:c-format */ 775 _bfd_error_handler (_("%pB: unhandled import type; %x"), 776 abfd, import_type); 777 return FALSE; 778 779 default: 780 /* xgettext:c-format */ 781 _bfd_error_handler (_("%pB: unrecognized import type; %x"), 782 abfd, import_type); 783 return FALSE; 784 } 785 786 switch (import_name_type) 787 { 788 case IMPORT_ORDINAL: 789 case IMPORT_NAME: 790 case IMPORT_NAME_NOPREFIX: 791 case IMPORT_NAME_UNDECORATE: 792 break; 793 794 default: 795 /* xgettext:c-format */ 796 _bfd_error_handler (_("%pB: unrecognized import name type; %x"), 797 abfd, import_name_type); 798 return FALSE; 799 } 800 801 /* Initialise local variables. 802 803 Note these are kept in a structure rather than being 804 declared as statics since bfd frowns on global variables. 805 806 We are going to construct the contents of the BFD in memory, 807 so allocate all the space that we will need right now. */ 808 vars.bim 809 = (struct bfd_in_memory *) bfd_malloc ((bfd_size_type) sizeof (*vars.bim)); 810 if (vars.bim == NULL) 811 return FALSE; 812 813 ptr = (bfd_byte *) bfd_zmalloc ((bfd_size_type) ILF_DATA_SIZE); 814 vars.bim->buffer = ptr; 815 vars.bim->size = ILF_DATA_SIZE; 816 if (ptr == NULL) 817 goto error_return; 818 819 /* Initialise the pointers to regions of the memory and the 820 other contents of the pe_ILF_vars structure as well. */ 821 vars.sym_cache = (coff_symbol_type *) ptr; 822 vars.sym_ptr = (coff_symbol_type *) ptr; 823 vars.sym_index = 0; 824 ptr += SIZEOF_ILF_SYMS; 825 826 vars.sym_table = (unsigned int *) ptr; 827 vars.table_ptr = (unsigned int *) ptr; 828 ptr += SIZEOF_ILF_SYM_TABLE; 829 830 vars.native_syms = (combined_entry_type *) ptr; 831 vars.native_ptr = (combined_entry_type *) ptr; 832 ptr += SIZEOF_ILF_NATIVE_SYMS; 833 834 vars.sym_ptr_table = (coff_symbol_type **) ptr; 835 vars.sym_ptr_ptr = (coff_symbol_type **) ptr; 836 ptr += SIZEOF_ILF_SYM_PTR_TABLE; 837 838 vars.esym_table = (SYMENT *) ptr; 839 vars.esym_ptr = (SYMENT *) ptr; 840 ptr += SIZEOF_ILF_EXT_SYMS; 841 842 vars.reltab = (arelent *) ptr; 843 vars.relcount = 0; 844 ptr += SIZEOF_ILF_RELOCS; 845 846 vars.int_reltab = (struct internal_reloc *) ptr; 847 ptr += SIZEOF_ILF_INT_RELOCS; 848 849 vars.string_table = (char *) ptr; 850 vars.string_ptr = (char *) ptr + STRING_SIZE_SIZE; 851 ptr += SIZEOF_ILF_STRINGS; 852 vars.end_string_ptr = (char *) ptr; 853 854 /* The remaining space in bim->buffer is used 855 by the pe_ILF_make_a_section() function. */ 856 # if (GCC_VERSION >= 3000) 857 /* PR 18758: Make sure that the data area is sufficiently aligned for 858 pointers on the host. __alignof__ is a gcc extension, hence the test 859 above. For other compilers we will have to assume that the alignment is 860 unimportant, or else extra code can be added here and in 861 pe_ILF_make_a_section. 862 863 Note - we cannot test 'ptr' directly as it is illegal to perform binary 864 arithmetic on pointers, but we know that the strings section is the only 865 one that might end on an unaligned boundary. */ 866 { 867 unsigned int alignment = __alignof__ (char *); 868 869 if (SIZEOF_ILF_STRINGS & (alignment - 1)) 870 ptr += alignment - (SIZEOF_ILF_STRINGS & (alignment - 1)); 871 } 872 #endif 873 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 goto error_return; 890 891 /* Fill in the contents of these sections. */ 892 if (import_name_type == IMPORT_ORDINAL) 893 { 894 if (ordinal == 0) 895 /* See PR 20907 for a reproducer. */ 896 goto error_return; 897 898 #ifdef COFF_WITH_pex64 899 ((unsigned int *) id4->contents)[0] = ordinal; 900 ((unsigned int *) id4->contents)[1] = 0x80000000; 901 ((unsigned int *) id5->contents)[0] = ordinal; 902 ((unsigned int *) id5->contents)[1] = 0x80000000; 903 #else 904 * (unsigned int *) id4->contents = ordinal | 0x80000000; 905 * (unsigned int *) id5->contents = ordinal | 0x80000000; 906 #endif 907 } 908 else 909 { 910 char * symbol; 911 unsigned int len; 912 913 /* Create .idata$6 - the Hint Name Table. */ 914 id6 = pe_ILF_make_a_section (& vars, ".idata$6", SIZEOF_IDATA6, 0); 915 if (id6 == NULL) 916 goto error_return; 917 918 /* If necessary, trim the import symbol name. */ 919 symbol = symbol_name; 920 921 /* As used by MS compiler, '_', '@', and '?' are alternative 922 forms of USER_LABEL_PREFIX, with '?' for c++ mangled names, 923 '@' used for fastcall (in C), '_' everywhere else. Only one 924 of these is used for a symbol. We strip this leading char for 925 IMPORT_NAME_NOPREFIX and IMPORT_NAME_UNDECORATE as per the 926 PE COFF 6.0 spec (section 8.3, Import Name Type). */ 927 928 if (import_name_type != IMPORT_NAME) 929 { 930 char c = symbol[0]; 931 932 /* Check that we don't remove for targets with empty 933 USER_LABEL_PREFIX the leading underscore. */ 934 if ((c == '_' && abfd->xvec->symbol_leading_char != 0) 935 || c == '@' || c == '?') 936 symbol++; 937 } 938 939 len = strlen (symbol); 940 if (import_name_type == IMPORT_NAME_UNDECORATE) 941 { 942 /* Truncate at the first '@'. */ 943 char *at = strchr (symbol, '@'); 944 945 if (at != NULL) 946 len = at - symbol; 947 } 948 949 id6->contents[0] = ordinal & 0xff; 950 id6->contents[1] = ordinal >> 8; 951 952 memcpy ((char *) id6->contents + 2, symbol, len); 953 id6->contents[len + 2] = '\0'; 954 } 955 956 if (import_name_type != IMPORT_ORDINAL) 957 { 958 pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_RVA, id6); 959 pe_ILF_save_relocs (&vars, id4); 960 961 pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_RVA, id6); 962 pe_ILF_save_relocs (&vars, id5); 963 } 964 965 /* Create an import symbol. */ 966 pe_ILF_make_a_symbol (& vars, "__imp_", symbol_name, id5, 0); 967 imp_sym = vars.sym_ptr_ptr - 1; 968 imp_index = vars.sym_index - 1; 969 970 /* Create extra sections depending upon the type of import we are dealing with. */ 971 switch (import_type) 972 { 973 int i; 974 975 case IMPORT_CODE: 976 /* CODE functions are special, in that they get a trampoline that 977 jumps to the main import symbol. Create a .text section to hold it. 978 First we need to look up its contents in the jump table. */ 979 for (i = NUM_ENTRIES (jtab); i--;) 980 { 981 if (jtab[i].size == 0) 982 continue; 983 if (jtab[i].magic == magic) 984 break; 985 } 986 /* If we did not find a matching entry something is wrong. */ 987 if (i < 0) 988 abort (); 989 990 /* Create the .text section. */ 991 text = pe_ILF_make_a_section (& vars, ".text", jtab[i].size, SEC_CODE); 992 if (text == NULL) 993 goto error_return; 994 995 /* Copy in the jump code. */ 996 memcpy (text->contents, jtab[i].data, jtab[i].size); 997 998 /* Create a reloc for the data in the text section. */ 999 #ifdef MIPS_ARCH_MAGIC_WINCE 1000 if (magic == MIPS_ARCH_MAGIC_WINCE) 1001 { 1002 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 0, BFD_RELOC_HI16_S, 1003 (struct bfd_symbol **) imp_sym, 1004 imp_index); 1005 pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_LO16, text); 1006 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 4, BFD_RELOC_LO16, 1007 (struct bfd_symbol **) imp_sym, 1008 imp_index); 1009 } 1010 else 1011 #endif 1012 #ifdef AMD64MAGIC 1013 if (magic == AMD64MAGIC) 1014 { 1015 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset, 1016 BFD_RELOC_32_PCREL, (asymbol **) imp_sym, 1017 imp_index); 1018 } 1019 else 1020 #endif 1021 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset, 1022 BFD_RELOC_32, (asymbol **) imp_sym, 1023 imp_index); 1024 1025 pe_ILF_save_relocs (& vars, text); 1026 break; 1027 1028 case IMPORT_DATA: 1029 break; 1030 1031 default: 1032 /* XXX code not yet written. */ 1033 abort (); 1034 } 1035 1036 /* Initialise the bfd. */ 1037 memset (& internal_f, 0, sizeof (internal_f)); 1038 1039 internal_f.f_magic = magic; 1040 internal_f.f_symptr = 0; 1041 internal_f.f_nsyms = 0; 1042 internal_f.f_flags = F_AR32WR | F_LNNO; /* XXX is this correct ? */ 1043 1044 if ( ! bfd_set_start_address (abfd, (bfd_vma) 0) 1045 || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f)) 1046 goto error_return; 1047 1048 if (bfd_coff_mkobject_hook (abfd, (void *) & internal_f, NULL) == NULL) 1049 goto error_return; 1050 1051 coff_data (abfd)->pe = 1; 1052 #ifdef THUMBPEMAGIC 1053 if (vars.magic == THUMBPEMAGIC) 1054 /* Stop some linker warnings about thumb code not supporting interworking. */ 1055 coff_data (abfd)->flags |= F_INTERWORK | F_INTERWORK_SET; 1056 #endif 1057 1058 /* Switch from file contents to memory contents. */ 1059 bfd_cache_close (abfd); 1060 1061 abfd->iostream = (void *) vars.bim; 1062 abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */; 1063 abfd->iovec = &_bfd_memory_iovec; 1064 abfd->where = 0; 1065 abfd->origin = 0; 1066 obj_sym_filepos (abfd) = 0; 1067 1068 /* Now create a symbol describing the imported value. */ 1069 switch (import_type) 1070 { 1071 case IMPORT_CODE: 1072 pe_ILF_make_a_symbol (& vars, "", symbol_name, text, 1073 BSF_NOT_AT_END | BSF_FUNCTION); 1074 1075 break; 1076 1077 case IMPORT_DATA: 1078 /* Nothing to do here. */ 1079 break; 1080 1081 default: 1082 /* XXX code not yet written. */ 1083 abort (); 1084 } 1085 1086 /* Create an import symbol for the DLL, without the .dll suffix. */ 1087 ptr = (bfd_byte *) strrchr (source_dll, '.'); 1088 if (ptr) 1089 * ptr = 0; 1090 pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0); 1091 if (ptr) 1092 * ptr = '.'; 1093 1094 /* Point the bfd at the symbol table. */ 1095 obj_symbols (abfd) = vars.sym_cache; 1096 bfd_get_symcount (abfd) = vars.sym_index; 1097 1098 obj_raw_syments (abfd) = vars.native_syms; 1099 obj_raw_syment_count (abfd) = vars.sym_index; 1100 1101 obj_coff_external_syms (abfd) = (void *) vars.esym_table; 1102 obj_coff_keep_syms (abfd) = TRUE; 1103 1104 obj_convert (abfd) = vars.sym_table; 1105 obj_conv_table_size (abfd) = vars.sym_index; 1106 1107 obj_coff_strings (abfd) = vars.string_table; 1108 obj_coff_keep_strings (abfd) = TRUE; 1109 1110 abfd->flags |= HAS_SYMS; 1111 1112 return TRUE; 1113 1114 error_return: 1115 if (vars.bim->buffer != NULL) 1116 free (vars.bim->buffer); 1117 free (vars.bim); 1118 return FALSE; 1119 } 1120 1121 /* We have detected a Image Library Format archive element. 1122 Decode the element and return the appropriate target. */ 1123 1124 static const bfd_target * 1125 pe_ILF_object_p (bfd * abfd) 1126 { 1127 bfd_byte buffer[14]; 1128 bfd_byte * ptr; 1129 char * symbol_name; 1130 char * source_dll; 1131 unsigned int machine; 1132 bfd_size_type size; 1133 unsigned int ordinal; 1134 unsigned int types; 1135 unsigned int magic; 1136 1137 /* Upon entry the first six bytes of the ILF header have 1138 already been read. Now read the rest of the header. */ 1139 if (bfd_bread (buffer, (bfd_size_type) 14, abfd) != 14) 1140 return NULL; 1141 1142 ptr = buffer; 1143 1144 machine = H_GET_16 (abfd, ptr); 1145 ptr += 2; 1146 1147 /* Check that the machine type is recognised. */ 1148 magic = 0; 1149 1150 switch (machine) 1151 { 1152 case IMAGE_FILE_MACHINE_UNKNOWN: 1153 case IMAGE_FILE_MACHINE_ALPHA: 1154 case IMAGE_FILE_MACHINE_ALPHA64: 1155 case IMAGE_FILE_MACHINE_IA64: 1156 break; 1157 1158 case IMAGE_FILE_MACHINE_I386: 1159 #ifdef I386MAGIC 1160 magic = I386MAGIC; 1161 #endif 1162 break; 1163 1164 case IMAGE_FILE_MACHINE_AMD64: 1165 #ifdef AMD64MAGIC 1166 magic = AMD64MAGIC; 1167 #endif 1168 break; 1169 1170 case IMAGE_FILE_MACHINE_R3000: 1171 case IMAGE_FILE_MACHINE_R4000: 1172 case IMAGE_FILE_MACHINE_R10000: 1173 1174 case IMAGE_FILE_MACHINE_MIPS16: 1175 case IMAGE_FILE_MACHINE_MIPSFPU: 1176 case IMAGE_FILE_MACHINE_MIPSFPU16: 1177 #ifdef MIPS_ARCH_MAGIC_WINCE 1178 magic = MIPS_ARCH_MAGIC_WINCE; 1179 #endif 1180 break; 1181 1182 case IMAGE_FILE_MACHINE_SH3: 1183 case IMAGE_FILE_MACHINE_SH4: 1184 #ifdef SH_ARCH_MAGIC_WINCE 1185 magic = SH_ARCH_MAGIC_WINCE; 1186 #endif 1187 break; 1188 1189 case IMAGE_FILE_MACHINE_ARM: 1190 #ifdef ARMPEMAGIC 1191 magic = ARMPEMAGIC; 1192 #endif 1193 break; 1194 1195 case IMAGE_FILE_MACHINE_THUMB: 1196 #ifdef THUMBPEMAGIC 1197 { 1198 extern const bfd_target TARGET_LITTLE_SYM; 1199 1200 if (abfd->xvec == & TARGET_LITTLE_SYM) 1201 magic = THUMBPEMAGIC; 1202 } 1203 #endif 1204 break; 1205 1206 case IMAGE_FILE_MACHINE_POWERPC: 1207 /* We no longer support PowerPC. */ 1208 default: 1209 _bfd_error_handler 1210 /* xgettext:c-format */ 1211 (_("%pB: unrecognised machine type (0x%x)" 1212 " in Import Library Format archive"), 1213 abfd, machine); 1214 bfd_set_error (bfd_error_malformed_archive); 1215 1216 return NULL; 1217 break; 1218 } 1219 1220 if (magic == 0) 1221 { 1222 _bfd_error_handler 1223 /* xgettext:c-format */ 1224 (_("%pB: 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 (_("%pB: 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 /* See PR 20905 for an example of where the strnlen is necessary. */ 1267 source_dll = symbol_name + strnlen (symbol_name, size - 1) + 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 (_("%pB: 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 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 return; 1317 1318 if (!(section->flags & SEC_HAS_CONTENTS)) 1319 return; 1320 1321 dataoff = addr - section->vma; 1322 1323 /* PR 20605 and 22373: Make sure that the data is really there. 1324 Note - since we are dealing with unsigned quantities we have 1325 to be careful to check for potential overflows. */ 1326 if (dataoff >= section->size 1327 || size > section->size - dataoff) 1328 { 1329 _bfd_error_handler 1330 (_("%pB: error: debug data ends beyond end of debug directory"), 1331 abfd); 1332 return; 1333 } 1334 1335 /* Read the whole section. */ 1336 if (!bfd_malloc_and_get_section (abfd, section, &data)) 1337 { 1338 if (data != NULL) 1339 free (data); 1340 return; 1341 } 1342 1343 /* Search for a CodeView entry in the DebugDirectory */ 1344 for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++) 1345 { 1346 struct external_IMAGE_DEBUG_DIRECTORY *ext 1347 = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i]; 1348 struct internal_IMAGE_DEBUG_DIRECTORY idd; 1349 1350 _bfd_XXi_swap_debugdir_in (abfd, ext, &idd); 1351 1352 if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW) 1353 { 1354 char buffer[256 + 1]; 1355 CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer; 1356 1357 /* 1358 The debug entry doesn't have to have to be in a section, in which 1359 case AddressOfRawData is 0, so always use PointerToRawData. 1360 */ 1361 if (_bfd_XXi_slurp_codeview_record (abfd, 1362 (file_ptr) idd.PointerToRawData, 1363 idd.SizeOfData, cvinfo)) 1364 { 1365 struct bfd_build_id* build_id = bfd_alloc (abfd, 1366 sizeof (struct bfd_build_id) + cvinfo->SignatureLength); 1367 if (build_id) 1368 { 1369 build_id->size = cvinfo->SignatureLength; 1370 memcpy(build_id->data, cvinfo->Signature, 1371 cvinfo->SignatureLength); 1372 abfd->build_id = build_id; 1373 } 1374 } 1375 break; 1376 } 1377 } 1378 } 1379 1380 static const bfd_target * 1381 pe_bfd_object_p (bfd * abfd) 1382 { 1383 bfd_byte buffer[6]; 1384 struct external_DOS_hdr dos_hdr; 1385 struct external_PEI_IMAGE_hdr image_hdr; 1386 struct internal_filehdr internal_f; 1387 struct internal_aouthdr internal_a; 1388 file_ptr opt_hdr_size; 1389 file_ptr offset; 1390 const bfd_target *result; 1391 1392 /* Detect if this a Microsoft Import Library Format element. */ 1393 /* First read the beginning of the header. */ 1394 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 1395 || bfd_bread (buffer, (bfd_size_type) 6, abfd) != 6) 1396 { 1397 if (bfd_get_error () != bfd_error_system_call) 1398 bfd_set_error (bfd_error_wrong_format); 1399 return NULL; 1400 } 1401 1402 /* Then check the magic and the version (only 0 is supported). */ 1403 if (H_GET_32 (abfd, buffer) == 0xffff0000 1404 && H_GET_16 (abfd, buffer + 4) == 0) 1405 return pe_ILF_object_p (abfd); 1406 1407 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 1408 || bfd_bread (&dos_hdr, (bfd_size_type) sizeof (dos_hdr), abfd) 1409 != sizeof (dos_hdr)) 1410 { 1411 if (bfd_get_error () != bfd_error_system_call) 1412 bfd_set_error (bfd_error_wrong_format); 1413 return NULL; 1414 } 1415 1416 /* There are really two magic numbers involved; the magic number 1417 that says this is a NT executable (PEI) and the magic number that 1418 determines the architecture. The former is IMAGE_DOS_SIGNATURE, stored in 1419 the e_magic field. The latter is stored in the f_magic field. 1420 If the NT magic number isn't valid, the architecture magic number 1421 could be mimicked by some other field (specifically, the number 1422 of relocs in section 3). Since this routine can only be called 1423 correctly for a PEI file, check the e_magic number here, and, if 1424 it doesn't match, clobber the f_magic number so that we don't get 1425 a false match. */ 1426 if (H_GET_16 (abfd, dos_hdr.e_magic) != IMAGE_DOS_SIGNATURE) 1427 { 1428 bfd_set_error (bfd_error_wrong_format); 1429 return NULL; 1430 } 1431 1432 offset = H_GET_32 (abfd, dos_hdr.e_lfanew); 1433 if (bfd_seek (abfd, offset, SEEK_SET) != 0 1434 || (bfd_bread (&image_hdr, (bfd_size_type) sizeof (image_hdr), abfd) 1435 != sizeof (image_hdr))) 1436 { 1437 if (bfd_get_error () != bfd_error_system_call) 1438 bfd_set_error (bfd_error_wrong_format); 1439 return NULL; 1440 } 1441 1442 if (H_GET_32 (abfd, image_hdr.nt_signature) != 0x4550) 1443 { 1444 bfd_set_error (bfd_error_wrong_format); 1445 return NULL; 1446 } 1447 1448 /* Swap file header, so that we get the location for calling 1449 real_object_p. */ 1450 bfd_coff_swap_filehdr_in (abfd, &image_hdr, &internal_f); 1451 1452 if (! bfd_coff_bad_format_hook (abfd, &internal_f) 1453 || internal_f.f_opthdr > bfd_coff_aoutsz (abfd)) 1454 { 1455 bfd_set_error (bfd_error_wrong_format); 1456 return NULL; 1457 } 1458 1459 /* Read the optional header, which has variable size. */ 1460 opt_hdr_size = internal_f.f_opthdr; 1461 1462 if (opt_hdr_size != 0) 1463 { 1464 bfd_size_type amt = opt_hdr_size; 1465 void * opthdr; 1466 1467 /* PR 17521 file: 230-131433-0.004. */ 1468 if (amt < sizeof (PEAOUTHDR)) 1469 amt = sizeof (PEAOUTHDR); 1470 1471 opthdr = bfd_zalloc (abfd, amt); 1472 if (opthdr == NULL) 1473 return NULL; 1474 if (bfd_bread (opthdr, opt_hdr_size, abfd) 1475 != (bfd_size_type) opt_hdr_size) 1476 return NULL; 1477 1478 bfd_set_error (bfd_error_no_error); 1479 bfd_coff_swap_aouthdr_in (abfd, opthdr, & internal_a); 1480 if (bfd_get_error () != bfd_error_no_error) 1481 return NULL; 1482 } 1483 1484 1485 result = coff_real_object_p (abfd, internal_f.f_nscns, &internal_f, 1486 (opt_hdr_size != 0 1487 ? &internal_a 1488 : (struct internal_aouthdr *) NULL)); 1489 1490 1491 if (result) 1492 { 1493 /* Now the whole header has been processed, see if there is a build-id */ 1494 pe_bfd_read_buildid(abfd); 1495 } 1496 1497 return result; 1498 } 1499 1500 #define coff_object_p pe_bfd_object_p 1501 #endif /* COFF_IMAGE_WITH_PE */ 1502