1 /* Support for the generic parts of PE/PEI, for BFD. 2 Copyright (C) 1995-2022 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 bool (*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 bool pe_print_private_bfd_data (bfd *, void *); 68 #define coff_bfd_print_private_bfd_data pe_print_private_bfd_data 69 70 static bool (*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 bool 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 bfd_cleanup 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_peAArch64 195 # define coff_swap_filehdr_out _bfd_XX_only_swap_filehdr_out 196 #elif defined COFF_WITH_pex64 197 # define coff_swap_filehdr_out _bfd_pex64_only_swap_filehdr_out 198 #elif defined COFF_WITH_pep 199 # define coff_swap_filehdr_out _bfd_pep_only_swap_filehdr_out 200 #else 201 # define coff_swap_filehdr_out _bfd_pe_only_swap_filehdr_out 202 #endif 203 204 static void 205 coff_swap_scnhdr_in (bfd * abfd, void * ext, void * in) 206 { 207 SCNHDR *scnhdr_ext = (SCNHDR *) ext; 208 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in; 209 210 memcpy (scnhdr_int->s_name, scnhdr_ext->s_name, sizeof (scnhdr_int->s_name)); 211 212 scnhdr_int->s_vaddr = GET_SCNHDR_VADDR (abfd, scnhdr_ext->s_vaddr); 213 scnhdr_int->s_paddr = GET_SCNHDR_PADDR (abfd, scnhdr_ext->s_paddr); 214 scnhdr_int->s_size = GET_SCNHDR_SIZE (abfd, scnhdr_ext->s_size); 215 scnhdr_int->s_scnptr = GET_SCNHDR_SCNPTR (abfd, scnhdr_ext->s_scnptr); 216 scnhdr_int->s_relptr = GET_SCNHDR_RELPTR (abfd, scnhdr_ext->s_relptr); 217 scnhdr_int->s_lnnoptr = GET_SCNHDR_LNNOPTR (abfd, scnhdr_ext->s_lnnoptr); 218 scnhdr_int->s_flags = H_GET_32 (abfd, scnhdr_ext->s_flags); 219 220 /* MS handles overflow of line numbers by carrying into the reloc 221 field (it appears). Since it's supposed to be zero for PE 222 *IMAGE* format, that's safe. This is still a bit iffy. */ 223 #ifdef COFF_IMAGE_WITH_PE 224 scnhdr_int->s_nlnno = (H_GET_16 (abfd, scnhdr_ext->s_nlnno) 225 + (H_GET_16 (abfd, scnhdr_ext->s_nreloc) << 16)); 226 scnhdr_int->s_nreloc = 0; 227 #else 228 scnhdr_int->s_nreloc = H_GET_16 (abfd, scnhdr_ext->s_nreloc); 229 scnhdr_int->s_nlnno = H_GET_16 (abfd, scnhdr_ext->s_nlnno); 230 #endif 231 232 if (scnhdr_int->s_vaddr != 0) 233 { 234 scnhdr_int->s_vaddr += pe_data (abfd)->pe_opthdr.ImageBase; 235 /* Do not cut upper 32-bits for 64-bit vma. */ 236 #if !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64) 237 scnhdr_int->s_vaddr &= 0xffffffff; 238 #endif 239 } 240 241 #ifndef COFF_NO_HACK_SCNHDR_SIZE 242 /* If this section holds uninitialized data and is from an object file 243 or from an executable image that has not initialized the field, 244 or if the image is an executable file and the physical size is padded, 245 use the virtual size (stored in s_paddr) instead. */ 246 if (scnhdr_int->s_paddr > 0 247 && (((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0 248 && (! bfd_pei_p (abfd) || scnhdr_int->s_size == 0)) 249 || (bfd_pei_p (abfd) && (scnhdr_int->s_size > scnhdr_int->s_paddr)))) 250 /* This code used to set scnhdr_int->s_paddr to 0. However, 251 coff_set_alignment_hook stores s_paddr in virt_size, which 252 only works if it correctly holds the virtual size of the 253 section. */ 254 scnhdr_int->s_size = scnhdr_int->s_paddr; 255 #endif 256 } 257 258 static bool 259 pe_mkobject (bfd * abfd) 260 { 261 pe_data_type *pe; 262 size_t amt = sizeof (pe_data_type); 263 264 abfd->tdata.pe_obj_data = (struct pe_tdata *) bfd_zalloc (abfd, amt); 265 266 if (abfd->tdata.pe_obj_data == 0) 267 return false; 268 269 pe = pe_data (abfd); 270 271 pe->coff.pe = 1; 272 273 /* in_reloc_p is architecture dependent. */ 274 pe->in_reloc_p = in_reloc_p; 275 276 /* Default DOS message string. */ 277 pe->dos_message[0] = 0x0eba1f0e; 278 pe->dos_message[1] = 0xcd09b400; 279 pe->dos_message[2] = 0x4c01b821; 280 pe->dos_message[3] = 0x685421cd; 281 pe->dos_message[4] = 0x70207369; 282 pe->dos_message[5] = 0x72676f72; 283 pe->dos_message[6] = 0x63206d61; 284 pe->dos_message[7] = 0x6f6e6e61; 285 pe->dos_message[8] = 0x65622074; 286 pe->dos_message[9] = 0x6e757220; 287 pe->dos_message[10] = 0x206e6920; 288 pe->dos_message[11] = 0x20534f44; 289 pe->dos_message[12] = 0x65646f6d; 290 pe->dos_message[13] = 0x0a0d0d2e; 291 pe->dos_message[14] = 0x24; 292 pe->dos_message[15] = 0x0; 293 294 memset (& pe->pe_opthdr, 0, sizeof pe->pe_opthdr); 295 return true; 296 } 297 298 /* Create the COFF backend specific information. */ 299 300 static void * 301 pe_mkobject_hook (bfd * abfd, 302 void * filehdr, 303 void * aouthdr ATTRIBUTE_UNUSED) 304 { 305 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 306 pe_data_type *pe; 307 308 if (! pe_mkobject (abfd)) 309 return NULL; 310 311 pe = pe_data (abfd); 312 pe->coff.sym_filepos = internal_f->f_symptr; 313 /* These members communicate important constants about the symbol 314 table to GDB's symbol-reading code. These `constants' 315 unfortunately vary among coff implementations... */ 316 pe->coff.local_n_btmask = N_BTMASK; 317 pe->coff.local_n_btshft = N_BTSHFT; 318 pe->coff.local_n_tmask = N_TMASK; 319 pe->coff.local_n_tshift = N_TSHIFT; 320 pe->coff.local_symesz = SYMESZ; 321 pe->coff.local_auxesz = AUXESZ; 322 pe->coff.local_linesz = LINESZ; 323 324 pe->coff.timestamp = internal_f->f_timdat; 325 326 obj_raw_syment_count (abfd) = 327 obj_conv_table_size (abfd) = 328 internal_f->f_nsyms; 329 330 pe->real_flags = internal_f->f_flags; 331 332 if ((internal_f->f_flags & F_DLL) != 0) 333 pe->dll = 1; 334 335 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0) 336 abfd->flags |= HAS_DEBUG; 337 338 #ifdef COFF_IMAGE_WITH_PE 339 if (aouthdr) 340 pe->pe_opthdr = ((struct internal_aouthdr *) aouthdr)->pe; 341 #endif 342 343 #ifdef ARM 344 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags)) 345 coff_data (abfd) ->flags = 0; 346 #endif 347 348 memcpy (pe->dos_message, internal_f->pe.dos_message, 349 sizeof (pe->dos_message)); 350 351 return (void *) pe; 352 } 353 354 static bool 355 pe_print_private_bfd_data (bfd *abfd, void * vfile) 356 { 357 FILE *file = (FILE *) vfile; 358 359 if (!_bfd_XX_print_private_bfd_data_common (abfd, vfile)) 360 return false; 361 362 if (pe_saved_coff_bfd_print_private_bfd_data == NULL) 363 return true; 364 365 fputc ('\n', file); 366 367 return pe_saved_coff_bfd_print_private_bfd_data (abfd, vfile); 368 } 369 370 /* Copy any private info we understand from the input bfd 371 to the output bfd. */ 372 373 static bool 374 pe_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 375 { 376 /* PR binutils/716: Copy the large address aware flag. 377 XXX: Should we be copying other flags or other fields in the pe_data() 378 structure ? */ 379 if (pe_data (obfd) != NULL 380 && pe_data (ibfd) != NULL 381 && pe_data (ibfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE) 382 pe_data (obfd)->real_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE; 383 384 if (!_bfd_XX_bfd_copy_private_bfd_data_common (ibfd, obfd)) 385 return false; 386 387 if (pe_saved_coff_bfd_copy_private_bfd_data) 388 return pe_saved_coff_bfd_copy_private_bfd_data (ibfd, obfd); 389 390 return true; 391 } 392 393 #define coff_bfd_copy_private_section_data \ 394 _bfd_XX_bfd_copy_private_section_data 395 396 #define coff_get_symbol_info _bfd_XX_get_symbol_info 397 398 #ifdef COFF_IMAGE_WITH_PE 399 400 /* Code to handle Microsoft's Image Library Format. 401 Also known as LINK6 format. 402 Documentation about this format can be found at: 403 404 http://msdn.microsoft.com/library/specs/pecoff_section8.htm */ 405 406 /* The following constants specify the sizes of the various data 407 structures that we have to create in order to build a bfd describing 408 an ILF object file. The final "+ 1" in the definitions of SIZEOF_IDATA6 409 and SIZEOF_IDATA7 below is to allow for the possibility that we might 410 need a padding byte in order to ensure 16 bit alignment for the section's 411 contents. 412 413 The value for SIZEOF_ILF_STRINGS is computed as follows: 414 415 There will be NUM_ILF_SECTIONS section symbols. Allow 9 characters 416 per symbol for their names (longest section name is .idata$x). 417 418 There will be two symbols for the imported value, one the symbol name 419 and one with _imp__ prefixed. Allowing for the terminating nul's this 420 is strlen (symbol_name) * 2 + 8 + 21 + strlen (source_dll). 421 422 The strings in the string table must start STRING__SIZE_SIZE bytes into 423 the table in order to for the string lookup code in coffgen/coffcode to 424 work. */ 425 #define NUM_ILF_RELOCS 8 426 #define NUM_ILF_SECTIONS 6 427 #define NUM_ILF_SYMS (2 + NUM_ILF_SECTIONS) 428 429 #define SIZEOF_ILF_SYMS (NUM_ILF_SYMS * sizeof (* vars.sym_cache)) 430 #define SIZEOF_ILF_SYM_TABLE (NUM_ILF_SYMS * sizeof (* vars.sym_table)) 431 #define SIZEOF_ILF_NATIVE_SYMS (NUM_ILF_SYMS * sizeof (* vars.native_syms)) 432 #define SIZEOF_ILF_SYM_PTR_TABLE (NUM_ILF_SYMS * sizeof (* vars.sym_ptr_table)) 433 #define SIZEOF_ILF_EXT_SYMS (NUM_ILF_SYMS * sizeof (* vars.esym_table)) 434 #define SIZEOF_ILF_RELOCS (NUM_ILF_RELOCS * sizeof (* vars.reltab)) 435 #define SIZEOF_ILF_INT_RELOCS (NUM_ILF_RELOCS * sizeof (* vars.int_reltab)) 436 #define SIZEOF_ILF_STRINGS (strlen (symbol_name) * 2 + 8 \ 437 + 21 + strlen (source_dll) \ 438 + NUM_ILF_SECTIONS * 9 \ 439 + STRING_SIZE_SIZE) 440 #define SIZEOF_IDATA2 (5 * 4) 441 442 /* For PEx64 idata4 & 5 have thumb size of 8 bytes. */ 443 #ifdef COFF_WITH_pex64 444 #define SIZEOF_IDATA4 (2 * 4) 445 #define SIZEOF_IDATA5 (2 * 4) 446 #else 447 #define SIZEOF_IDATA4 (1 * 4) 448 #define SIZEOF_IDATA5 (1 * 4) 449 #endif 450 451 #define SIZEOF_IDATA6 (2 + strlen (symbol_name) + 1 + 1) 452 #define SIZEOF_IDATA7 (strlen (source_dll) + 1 + 1) 453 #define SIZEOF_ILF_SECTIONS (NUM_ILF_SECTIONS * sizeof (struct coff_section_tdata)) 454 455 #define ILF_DATA_SIZE \ 456 + SIZEOF_ILF_SYMS \ 457 + SIZEOF_ILF_SYM_TABLE \ 458 + SIZEOF_ILF_NATIVE_SYMS \ 459 + SIZEOF_ILF_SYM_PTR_TABLE \ 460 + SIZEOF_ILF_EXT_SYMS \ 461 + SIZEOF_ILF_RELOCS \ 462 + SIZEOF_ILF_INT_RELOCS \ 463 + SIZEOF_ILF_STRINGS \ 464 + SIZEOF_IDATA2 \ 465 + SIZEOF_IDATA4 \ 466 + SIZEOF_IDATA5 \ 467 + SIZEOF_IDATA6 \ 468 + SIZEOF_IDATA7 \ 469 + SIZEOF_ILF_SECTIONS \ 470 + MAX_TEXT_SECTION_SIZE 471 472 /* Create an empty relocation against the given symbol. */ 473 474 static void 475 pe_ILF_make_a_symbol_reloc (pe_ILF_vars * vars, 476 bfd_vma address, 477 bfd_reloc_code_real_type reloc, 478 struct bfd_symbol ** sym, 479 unsigned int sym_index) 480 { 481 arelent * entry; 482 struct internal_reloc * internal; 483 484 entry = vars->reltab + vars->relcount; 485 internal = vars->int_reltab + vars->relcount; 486 487 entry->address = address; 488 entry->addend = 0; 489 entry->howto = bfd_reloc_type_lookup (vars->abfd, reloc); 490 entry->sym_ptr_ptr = sym; 491 492 internal->r_vaddr = address; 493 internal->r_symndx = sym_index; 494 internal->r_type = entry->howto ? entry->howto->type : 0; 495 496 vars->relcount ++; 497 498 BFD_ASSERT (vars->relcount <= NUM_ILF_RELOCS); 499 } 500 501 /* Create an empty relocation against the given section. */ 502 503 static void 504 pe_ILF_make_a_reloc (pe_ILF_vars * vars, 505 bfd_vma address, 506 bfd_reloc_code_real_type reloc, 507 asection_ptr sec) 508 { 509 pe_ILF_make_a_symbol_reloc (vars, address, reloc, sec->symbol_ptr_ptr, 510 coff_section_data (vars->abfd, sec)->i); 511 } 512 513 /* Move the queued relocs into the given section. */ 514 515 static void 516 pe_ILF_save_relocs (pe_ILF_vars * vars, 517 asection_ptr sec) 518 { 519 /* Make sure that there is somewhere to store the internal relocs. */ 520 if (coff_section_data (vars->abfd, sec) == NULL) 521 /* We should probably return an error indication here. */ 522 abort (); 523 524 coff_section_data (vars->abfd, sec)->relocs = vars->int_reltab; 525 coff_section_data (vars->abfd, sec)->keep_relocs = true; 526 527 sec->relocation = vars->reltab; 528 sec->reloc_count = vars->relcount; 529 sec->flags |= SEC_RELOC; 530 531 vars->reltab += vars->relcount; 532 vars->int_reltab += vars->relcount; 533 vars->relcount = 0; 534 535 BFD_ASSERT ((bfd_byte *) vars->int_reltab < (bfd_byte *) vars->string_table); 536 } 537 538 /* Create a global symbol and add it to the relevant tables. */ 539 540 static void 541 pe_ILF_make_a_symbol (pe_ILF_vars * vars, 542 const char * prefix, 543 const char * symbol_name, 544 asection_ptr section, 545 flagword extra_flags) 546 { 547 coff_symbol_type * sym; 548 combined_entry_type * ent; 549 SYMENT * esym; 550 unsigned short sclass; 551 552 if (extra_flags & BSF_LOCAL) 553 sclass = C_STAT; 554 else 555 sclass = C_EXT; 556 557 #ifdef THUMBPEMAGIC 558 if (vars->magic == THUMBPEMAGIC) 559 { 560 if (extra_flags & BSF_FUNCTION) 561 sclass = C_THUMBEXTFUNC; 562 else if (extra_flags & BSF_LOCAL) 563 sclass = C_THUMBSTAT; 564 else 565 sclass = C_THUMBEXT; 566 } 567 #endif 568 569 BFD_ASSERT (vars->sym_index < NUM_ILF_SYMS); 570 571 sym = vars->sym_ptr; 572 ent = vars->native_ptr; 573 esym = vars->esym_ptr; 574 575 /* Copy the symbol's name into the string table. */ 576 sprintf (vars->string_ptr, "%s%s", prefix, symbol_name); 577 578 if (section == NULL) 579 section = bfd_und_section_ptr; 580 581 /* Initialise the external symbol. */ 582 H_PUT_32 (vars->abfd, vars->string_ptr - vars->string_table, 583 esym->e.e.e_offset); 584 H_PUT_16 (vars->abfd, section->target_index, esym->e_scnum); 585 esym->e_sclass[0] = sclass; 586 587 /* The following initialisations are unnecessary - the memory is 588 zero initialised. They are just kept here as reminders. */ 589 590 /* Initialise the internal symbol structure. */ 591 ent->u.syment.n_sclass = sclass; 592 ent->u.syment.n_scnum = section->target_index; 593 ent->u.syment._n._n_n._n_offset = (uintptr_t) sym; 594 ent->is_sym = true; 595 596 sym->symbol.the_bfd = vars->abfd; 597 sym->symbol.name = vars->string_ptr; 598 sym->symbol.flags = BSF_EXPORT | BSF_GLOBAL | extra_flags; 599 sym->symbol.section = section; 600 sym->native = ent; 601 602 * vars->table_ptr = vars->sym_index; 603 * vars->sym_ptr_ptr = sym; 604 605 /* Adjust pointers for the next symbol. */ 606 vars->sym_index ++; 607 vars->sym_ptr ++; 608 vars->sym_ptr_ptr ++; 609 vars->table_ptr ++; 610 vars->native_ptr ++; 611 vars->esym_ptr ++; 612 vars->string_ptr += strlen (symbol_name) + strlen (prefix) + 1; 613 614 BFD_ASSERT (vars->string_ptr < vars->end_string_ptr); 615 } 616 617 /* Create a section. */ 618 619 static asection_ptr 620 pe_ILF_make_a_section (pe_ILF_vars * vars, 621 const char * name, 622 unsigned int size, 623 flagword extra_flags) 624 { 625 asection_ptr sec; 626 flagword flags; 627 intptr_t alignment; 628 629 sec = bfd_make_section_old_way (vars->abfd, name); 630 if (sec == NULL) 631 return NULL; 632 633 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_IN_MEMORY; 634 635 bfd_set_section_flags (sec, flags | extra_flags); 636 637 bfd_set_section_alignment (sec, 2); 638 639 /* Check that we will not run out of space. */ 640 BFD_ASSERT (vars->data + size < vars->bim->buffer + vars->bim->size); 641 642 /* Set the section size and contents. The actual 643 contents are filled in by our parent. */ 644 bfd_set_section_size (sec, (bfd_size_type) size); 645 sec->contents = vars->data; 646 sec->target_index = vars->sec_index ++; 647 648 /* Advance data pointer in the vars structure. */ 649 vars->data += size; 650 651 /* Skip the padding byte if it was not needed. 652 The logic here is that if the string length is odd, 653 then the entire string length, including the null byte, 654 is even and so the extra, padding byte, is not needed. */ 655 if (size & 1) 656 vars->data --; 657 658 /* PR 18758: See note in pe_ILF_buid_a_bfd. We must make sure that we 659 preserve host alignment requirements. The BFD_ASSERTs in this 660 functions will warn us if we run out of room, but we should 661 already have enough padding built in to ILF_DATA_SIZE. */ 662 #if GCC_VERSION >= 3000 663 alignment = __alignof__ (struct coff_section_tdata); 664 #else 665 alignment = 8; 666 #endif 667 vars->data 668 = (bfd_byte *) (((intptr_t) vars->data + alignment - 1) & -alignment); 669 670 /* Create a coff_section_tdata structure for our use. */ 671 sec->used_by_bfd = (struct coff_section_tdata *) vars->data; 672 vars->data += sizeof (struct coff_section_tdata); 673 674 BFD_ASSERT (vars->data <= vars->bim->buffer + vars->bim->size); 675 676 /* Create a symbol to refer to this section. */ 677 pe_ILF_make_a_symbol (vars, "", name, sec, BSF_LOCAL); 678 679 /* Cache the index to the symbol in the coff_section_data structure. */ 680 coff_section_data (vars->abfd, sec)->i = vars->sym_index - 1; 681 682 return sec; 683 } 684 685 /* This structure contains the code that goes into the .text section 686 in order to perform a jump into the DLL lookup table. The entries 687 in the table are index by the magic number used to represent the 688 machine type in the PE file. The contents of the data[] arrays in 689 these entries are stolen from the jtab[] arrays in ld/pe-dll.c. 690 The SIZE field says how many bytes in the DATA array are actually 691 used. The OFFSET field says where in the data array the address 692 of the .idata$5 section should be placed. */ 693 #define MAX_TEXT_SECTION_SIZE 32 694 695 typedef struct 696 { 697 unsigned short magic; 698 unsigned char data[MAX_TEXT_SECTION_SIZE]; 699 unsigned int size; 700 unsigned int offset; 701 } 702 jump_table; 703 704 static const jump_table jtab[] = 705 { 706 #ifdef I386MAGIC 707 { I386MAGIC, 708 { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 }, 709 8, 2 710 }, 711 #endif 712 713 #ifdef AMD64MAGIC 714 { AMD64MAGIC, 715 { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 }, 716 8, 2 717 }, 718 #endif 719 720 #ifdef MC68MAGIC 721 { MC68MAGIC, 722 { /* XXX fill me in */ }, 723 0, 0 724 }, 725 #endif 726 727 #ifdef MIPS_ARCH_MAGIC_WINCE 728 { MIPS_ARCH_MAGIC_WINCE, 729 { 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d, 730 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 }, 731 16, 0 732 }, 733 #endif 734 735 #ifdef SH_ARCH_MAGIC_WINCE 736 { SH_ARCH_MAGIC_WINCE, 737 { 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 738 0x09, 0x00, 0x00, 0x00, 0x00, 0x00 }, 739 12, 8 740 }, 741 #endif 742 743 #ifdef AARCH64MAGIC 744 /* We don't currently support jumping to DLLs, so if 745 someone does try emit a runtime trap. Through UDF #0. */ 746 { AARCH64MAGIC, 747 { 0x00, 0x00, 0x00, 0x00 }, 748 4, 0 749 }, 750 751 #endif 752 753 #ifdef ARMPEMAGIC 754 { ARMPEMAGIC, 755 { 0x00, 0xc0, 0x9f, 0xe5, 0x00, 0xf0, 756 0x9c, 0xe5, 0x00, 0x00, 0x00, 0x00}, 757 12, 8 758 }, 759 #endif 760 761 #ifdef THUMBPEMAGIC 762 { THUMBPEMAGIC, 763 { 0x40, 0xb4, 0x02, 0x4e, 0x36, 0x68, 0xb4, 0x46, 764 0x40, 0xbc, 0x60, 0x47, 0x00, 0x00, 0x00, 0x00 }, 765 16, 12 766 }, 767 #endif 768 769 #ifdef LOONGARCH64MAGIC 770 /* We don't currently support jumping to DLLs, so if 771 someone does try emit a runtime trap. Through BREAK 0. */ 772 { LOONGARCH64MAGIC, 773 { 0x00, 0x00, 0x2a, 0x00 }, 774 4, 0 775 }, 776 777 #endif 778 779 { 0, { 0 }, 0, 0 } 780 }; 781 782 #ifndef NUM_ENTRIES 783 #define NUM_ENTRIES(a) (sizeof (a) / sizeof (a)[0]) 784 #endif 785 786 /* Build a full BFD from the information supplied in a ILF object. */ 787 788 static bool 789 pe_ILF_build_a_bfd (bfd * abfd, 790 unsigned int magic, 791 char * symbol_name, 792 char * source_dll, 793 unsigned int ordinal, 794 unsigned int types) 795 { 796 bfd_byte * ptr; 797 pe_ILF_vars vars; 798 struct internal_filehdr internal_f; 799 unsigned int import_type; 800 unsigned int import_name_type; 801 asection_ptr id4, id5, id6 = NULL, text = NULL; 802 coff_symbol_type ** imp_sym; 803 unsigned int imp_index; 804 intptr_t alignment; 805 806 /* Decode and verify the types field of the ILF structure. */ 807 import_type = types & 0x3; 808 import_name_type = (types & 0x1c) >> 2; 809 810 switch (import_type) 811 { 812 case IMPORT_CODE: 813 case IMPORT_DATA: 814 break; 815 816 case IMPORT_CONST: 817 /* XXX code yet to be written. */ 818 /* xgettext:c-format */ 819 _bfd_error_handler (_("%pB: unhandled import type; %x"), 820 abfd, import_type); 821 return false; 822 823 default: 824 /* xgettext:c-format */ 825 _bfd_error_handler (_("%pB: unrecognized import type; %x"), 826 abfd, import_type); 827 return false; 828 } 829 830 switch (import_name_type) 831 { 832 case IMPORT_ORDINAL: 833 case IMPORT_NAME: 834 case IMPORT_NAME_NOPREFIX: 835 case IMPORT_NAME_UNDECORATE: 836 break; 837 838 default: 839 /* xgettext:c-format */ 840 _bfd_error_handler (_("%pB: unrecognized import name type; %x"), 841 abfd, import_name_type); 842 return false; 843 } 844 845 /* Initialise local variables. 846 847 Note these are kept in a structure rather than being 848 declared as statics since bfd frowns on global variables. 849 850 We are going to construct the contents of the BFD in memory, 851 so allocate all the space that we will need right now. */ 852 vars.bim 853 = (struct bfd_in_memory *) bfd_malloc ((bfd_size_type) sizeof (*vars.bim)); 854 if (vars.bim == NULL) 855 return false; 856 857 ptr = (bfd_byte *) bfd_zmalloc ((bfd_size_type) ILF_DATA_SIZE); 858 vars.bim->buffer = ptr; 859 vars.bim->size = ILF_DATA_SIZE; 860 if (ptr == NULL) 861 goto error_return; 862 863 /* Initialise the pointers to regions of the memory and the 864 other contents of the pe_ILF_vars structure as well. */ 865 vars.sym_cache = (coff_symbol_type *) ptr; 866 vars.sym_ptr = (coff_symbol_type *) ptr; 867 vars.sym_index = 0; 868 ptr += SIZEOF_ILF_SYMS; 869 870 vars.sym_table = (unsigned int *) ptr; 871 vars.table_ptr = (unsigned int *) ptr; 872 ptr += SIZEOF_ILF_SYM_TABLE; 873 874 vars.native_syms = (combined_entry_type *) ptr; 875 vars.native_ptr = (combined_entry_type *) ptr; 876 ptr += SIZEOF_ILF_NATIVE_SYMS; 877 878 vars.sym_ptr_table = (coff_symbol_type **) ptr; 879 vars.sym_ptr_ptr = (coff_symbol_type **) ptr; 880 ptr += SIZEOF_ILF_SYM_PTR_TABLE; 881 882 vars.esym_table = (SYMENT *) ptr; 883 vars.esym_ptr = (SYMENT *) ptr; 884 ptr += SIZEOF_ILF_EXT_SYMS; 885 886 vars.reltab = (arelent *) ptr; 887 vars.relcount = 0; 888 ptr += SIZEOF_ILF_RELOCS; 889 890 vars.int_reltab = (struct internal_reloc *) ptr; 891 ptr += SIZEOF_ILF_INT_RELOCS; 892 893 vars.string_table = (char *) ptr; 894 vars.string_ptr = (char *) ptr + STRING_SIZE_SIZE; 895 ptr += SIZEOF_ILF_STRINGS; 896 vars.end_string_ptr = (char *) ptr; 897 898 /* The remaining space in bim->buffer is used 899 by the pe_ILF_make_a_section() function. */ 900 901 /* PR 18758: Make sure that the data area is sufficiently aligned for 902 struct coff_section_tdata. __alignof__ is a gcc extension, hence 903 the test of GCC_VERSION. For other compilers we assume 8 byte 904 alignment. */ 905 #if GCC_VERSION >= 3000 906 alignment = __alignof__ (struct coff_section_tdata); 907 #else 908 alignment = 8; 909 #endif 910 ptr = (bfd_byte *) (((intptr_t) ptr + alignment - 1) & -alignment); 911 912 vars.data = ptr; 913 vars.abfd = abfd; 914 vars.sec_index = 0; 915 vars.magic = magic; 916 917 /* Create the initial .idata$<n> sections: 918 [.idata$2: Import Directory Table -- not needed] 919 .idata$4: Import Lookup Table 920 .idata$5: Import Address Table 921 922 Note we do not create a .idata$3 section as this is 923 created for us by the linker script. */ 924 id4 = pe_ILF_make_a_section (& vars, ".idata$4", SIZEOF_IDATA4, 0); 925 id5 = pe_ILF_make_a_section (& vars, ".idata$5", SIZEOF_IDATA5, 0); 926 if (id4 == NULL || id5 == NULL) 927 goto error_return; 928 929 /* Fill in the contents of these sections. */ 930 if (import_name_type == IMPORT_ORDINAL) 931 { 932 if (ordinal == 0) 933 /* See PR 20907 for a reproducer. */ 934 goto error_return; 935 936 #if defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64) 937 ((unsigned int *) id4->contents)[0] = ordinal; 938 ((unsigned int *) id4->contents)[1] = 0x80000000; 939 ((unsigned int *) id5->contents)[0] = ordinal; 940 ((unsigned int *) id5->contents)[1] = 0x80000000; 941 #else 942 * (unsigned int *) id4->contents = ordinal | 0x80000000; 943 * (unsigned int *) id5->contents = ordinal | 0x80000000; 944 #endif 945 } 946 else 947 { 948 char * symbol; 949 unsigned int len; 950 951 /* Create .idata$6 - the Hint Name Table. */ 952 id6 = pe_ILF_make_a_section (& vars, ".idata$6", SIZEOF_IDATA6, 0); 953 if (id6 == NULL) 954 goto error_return; 955 956 /* If necessary, trim the import symbol name. */ 957 symbol = symbol_name; 958 959 /* As used by MS compiler, '_', '@', and '?' are alternative 960 forms of USER_LABEL_PREFIX, with '?' for c++ mangled names, 961 '@' used for fastcall (in C), '_' everywhere else. Only one 962 of these is used for a symbol. We strip this leading char for 963 IMPORT_NAME_NOPREFIX and IMPORT_NAME_UNDECORATE as per the 964 PE COFF 6.0 spec (section 8.3, Import Name Type). */ 965 966 if (import_name_type != IMPORT_NAME) 967 { 968 char c = symbol[0]; 969 970 /* Check that we don't remove for targets with empty 971 USER_LABEL_PREFIX the leading underscore. */ 972 if ((c == '_' && abfd->xvec->symbol_leading_char != 0) 973 || c == '@' || c == '?') 974 symbol++; 975 } 976 977 len = strlen (symbol); 978 if (import_name_type == IMPORT_NAME_UNDECORATE) 979 { 980 /* Truncate at the first '@'. */ 981 char *at = strchr (symbol, '@'); 982 983 if (at != NULL) 984 len = at - symbol; 985 } 986 987 id6->contents[0] = ordinal & 0xff; 988 id6->contents[1] = ordinal >> 8; 989 990 memcpy ((char *) id6->contents + 2, symbol, len); 991 id6->contents[len + 2] = '\0'; 992 } 993 994 if (import_name_type != IMPORT_ORDINAL) 995 { 996 pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_RVA, id6); 997 pe_ILF_save_relocs (&vars, id4); 998 999 pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_RVA, id6); 1000 pe_ILF_save_relocs (&vars, id5); 1001 } 1002 1003 /* Create an import symbol. */ 1004 pe_ILF_make_a_symbol (& vars, "__imp_", symbol_name, id5, 0); 1005 imp_sym = vars.sym_ptr_ptr - 1; 1006 imp_index = vars.sym_index - 1; 1007 1008 /* Create extra sections depending upon the type of import we are dealing with. */ 1009 switch (import_type) 1010 { 1011 int i; 1012 1013 case IMPORT_CODE: 1014 /* CODE functions are special, in that they get a trampoline that 1015 jumps to the main import symbol. Create a .text section to hold it. 1016 First we need to look up its contents in the jump table. */ 1017 for (i = NUM_ENTRIES (jtab); i--;) 1018 { 1019 if (jtab[i].size == 0) 1020 continue; 1021 if (jtab[i].magic == magic) 1022 break; 1023 } 1024 /* If we did not find a matching entry something is wrong. */ 1025 if (i < 0) 1026 abort (); 1027 1028 /* Create the .text section. */ 1029 text = pe_ILF_make_a_section (& vars, ".text", jtab[i].size, SEC_CODE); 1030 if (text == NULL) 1031 goto error_return; 1032 1033 /* Copy in the jump code. */ 1034 memcpy (text->contents, jtab[i].data, jtab[i].size); 1035 1036 /* Create a reloc for the data in the text section. */ 1037 #ifdef MIPS_ARCH_MAGIC_WINCE 1038 if (magic == MIPS_ARCH_MAGIC_WINCE) 1039 { 1040 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 0, BFD_RELOC_HI16_S, 1041 (struct bfd_symbol **) imp_sym, 1042 imp_index); 1043 pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_LO16, text); 1044 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 4, BFD_RELOC_LO16, 1045 (struct bfd_symbol **) imp_sym, 1046 imp_index); 1047 } 1048 else 1049 #endif 1050 #ifdef AMD64MAGIC 1051 if (magic == AMD64MAGIC) 1052 { 1053 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset, 1054 BFD_RELOC_32_PCREL, (asymbol **) imp_sym, 1055 imp_index); 1056 } 1057 else 1058 #endif 1059 pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset, 1060 BFD_RELOC_32, (asymbol **) imp_sym, 1061 imp_index); 1062 1063 pe_ILF_save_relocs (& vars, text); 1064 break; 1065 1066 case IMPORT_DATA: 1067 break; 1068 1069 default: 1070 /* XXX code not yet written. */ 1071 abort (); 1072 } 1073 1074 /* Initialise the bfd. */ 1075 memset (& internal_f, 0, sizeof (internal_f)); 1076 1077 internal_f.f_magic = magic; 1078 internal_f.f_symptr = 0; 1079 internal_f.f_nsyms = 0; 1080 internal_f.f_flags = F_AR32WR | F_LNNO; /* XXX is this correct ? */ 1081 1082 if ( ! bfd_set_start_address (abfd, (bfd_vma) 0) 1083 || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f)) 1084 goto error_return; 1085 1086 if (bfd_coff_mkobject_hook (abfd, (void *) & internal_f, NULL) == NULL) 1087 goto error_return; 1088 1089 coff_data (abfd)->pe = 1; 1090 #ifdef THUMBPEMAGIC 1091 if (vars.magic == THUMBPEMAGIC) 1092 /* Stop some linker warnings about thumb code not supporting interworking. */ 1093 coff_data (abfd)->flags |= F_INTERWORK | F_INTERWORK_SET; 1094 #endif 1095 1096 /* Switch from file contents to memory contents. */ 1097 bfd_cache_close (abfd); 1098 1099 abfd->iostream = (void *) vars.bim; 1100 abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */; 1101 abfd->iovec = &_bfd_memory_iovec; 1102 abfd->where = 0; 1103 abfd->origin = 0; 1104 obj_sym_filepos (abfd) = 0; 1105 1106 /* Now create a symbol describing the imported value. */ 1107 switch (import_type) 1108 { 1109 case IMPORT_CODE: 1110 pe_ILF_make_a_symbol (& vars, "", symbol_name, text, 1111 BSF_NOT_AT_END | BSF_FUNCTION); 1112 1113 break; 1114 1115 case IMPORT_DATA: 1116 /* Nothing to do here. */ 1117 break; 1118 1119 default: 1120 /* XXX code not yet written. */ 1121 abort (); 1122 } 1123 1124 /* Create an import symbol for the DLL, without the .dll suffix. */ 1125 ptr = (bfd_byte *) strrchr (source_dll, '.'); 1126 if (ptr) 1127 * ptr = 0; 1128 pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0); 1129 if (ptr) 1130 * ptr = '.'; 1131 1132 /* Point the bfd at the symbol table. */ 1133 obj_symbols (abfd) = vars.sym_cache; 1134 abfd->symcount = vars.sym_index; 1135 1136 obj_raw_syments (abfd) = vars.native_syms; 1137 obj_raw_syment_count (abfd) = vars.sym_index; 1138 1139 obj_coff_external_syms (abfd) = (void *) vars.esym_table; 1140 obj_coff_keep_syms (abfd) = true; 1141 1142 obj_convert (abfd) = vars.sym_table; 1143 obj_conv_table_size (abfd) = vars.sym_index; 1144 1145 obj_coff_strings (abfd) = vars.string_table; 1146 obj_coff_keep_strings (abfd) = true; 1147 1148 abfd->flags |= HAS_SYMS; 1149 1150 return true; 1151 1152 error_return: 1153 free (vars.bim->buffer); 1154 free (vars.bim); 1155 return false; 1156 } 1157 1158 /* We have detected a Image Library Format archive element. 1159 Decode the element and return the appropriate target. */ 1160 1161 static bfd_cleanup 1162 pe_ILF_object_p (bfd * abfd) 1163 { 1164 bfd_byte buffer[14]; 1165 bfd_byte * ptr; 1166 char * symbol_name; 1167 char * source_dll; 1168 unsigned int machine; 1169 bfd_size_type size; 1170 unsigned int ordinal; 1171 unsigned int types; 1172 unsigned int magic; 1173 1174 /* Upon entry the first six bytes of the ILF header have 1175 already been read. Now read the rest of the header. */ 1176 if (bfd_bread (buffer, (bfd_size_type) 14, abfd) != 14) 1177 return NULL; 1178 1179 ptr = buffer; 1180 1181 machine = H_GET_16 (abfd, ptr); 1182 ptr += 2; 1183 1184 /* Check that the machine type is recognised. */ 1185 magic = 0; 1186 1187 switch (machine) 1188 { 1189 case IMAGE_FILE_MACHINE_UNKNOWN: 1190 case IMAGE_FILE_MACHINE_ALPHA: 1191 case IMAGE_FILE_MACHINE_ALPHA64: 1192 case IMAGE_FILE_MACHINE_IA64: 1193 break; 1194 1195 case IMAGE_FILE_MACHINE_I386: 1196 #ifdef I386MAGIC 1197 magic = I386MAGIC; 1198 #endif 1199 break; 1200 1201 case IMAGE_FILE_MACHINE_AMD64: 1202 #ifdef AMD64MAGIC 1203 magic = AMD64MAGIC; 1204 #endif 1205 break; 1206 1207 case IMAGE_FILE_MACHINE_R3000: 1208 case IMAGE_FILE_MACHINE_R4000: 1209 case IMAGE_FILE_MACHINE_R10000: 1210 1211 case IMAGE_FILE_MACHINE_MIPS16: 1212 case IMAGE_FILE_MACHINE_MIPSFPU: 1213 case IMAGE_FILE_MACHINE_MIPSFPU16: 1214 #ifdef MIPS_ARCH_MAGIC_WINCE 1215 magic = MIPS_ARCH_MAGIC_WINCE; 1216 #endif 1217 break; 1218 1219 case IMAGE_FILE_MACHINE_SH3: 1220 case IMAGE_FILE_MACHINE_SH4: 1221 #ifdef SH_ARCH_MAGIC_WINCE 1222 magic = SH_ARCH_MAGIC_WINCE; 1223 #endif 1224 break; 1225 1226 case IMAGE_FILE_MACHINE_ARM: 1227 #ifdef ARMPEMAGIC 1228 magic = ARMPEMAGIC; 1229 #endif 1230 break; 1231 1232 case IMAGE_FILE_MACHINE_ARM64: 1233 #ifdef AARCH64MAGIC 1234 magic = AARCH64MAGIC; 1235 #endif 1236 break; 1237 1238 case IMAGE_FILE_MACHINE_LOONGARCH64: 1239 #ifdef LOONGARCH64MAGIC 1240 magic = LOONGARCH64MAGIC; 1241 #endif 1242 break; 1243 1244 case IMAGE_FILE_MACHINE_THUMB: 1245 #ifdef THUMBPEMAGIC 1246 { 1247 extern const bfd_target TARGET_LITTLE_SYM; 1248 1249 if (abfd->xvec == & TARGET_LITTLE_SYM) 1250 magic = THUMBPEMAGIC; 1251 } 1252 #endif 1253 break; 1254 1255 case IMAGE_FILE_MACHINE_POWERPC: 1256 /* We no longer support PowerPC. */ 1257 default: 1258 _bfd_error_handler 1259 /* xgettext:c-format */ 1260 (_("%pB: unrecognised machine type (0x%x)" 1261 " in Import Library Format archive"), 1262 abfd, machine); 1263 bfd_set_error (bfd_error_malformed_archive); 1264 1265 return NULL; 1266 break; 1267 } 1268 1269 if (magic == 0) 1270 { 1271 _bfd_error_handler 1272 /* xgettext:c-format */ 1273 (_("%pB: recognised but unhandled machine type (0x%x)" 1274 " in Import Library Format archive"), 1275 abfd, machine); 1276 bfd_set_error (bfd_error_wrong_format); 1277 1278 return NULL; 1279 } 1280 1281 /* We do not bother to check the date. 1282 date = H_GET_32 (abfd, ptr); */ 1283 ptr += 4; 1284 1285 size = H_GET_32 (abfd, ptr); 1286 ptr += 4; 1287 1288 if (size == 0) 1289 { 1290 _bfd_error_handler 1291 (_("%pB: size field is zero in Import Library Format header"), abfd); 1292 bfd_set_error (bfd_error_malformed_archive); 1293 1294 return NULL; 1295 } 1296 1297 ordinal = H_GET_16 (abfd, ptr); 1298 ptr += 2; 1299 1300 types = H_GET_16 (abfd, ptr); 1301 /* ptr += 2; */ 1302 1303 /* Now read in the two strings that follow. */ 1304 ptr = (bfd_byte *) _bfd_alloc_and_read (abfd, size, size); 1305 if (ptr == NULL) 1306 return NULL; 1307 1308 symbol_name = (char *) ptr; 1309 /* See PR 20905 for an example of where the strnlen is necessary. */ 1310 source_dll = symbol_name + strnlen (symbol_name, size - 1) + 1; 1311 1312 /* Verify that the strings are null terminated. */ 1313 if (ptr[size - 1] != 0 1314 || (bfd_size_type) ((bfd_byte *) source_dll - ptr) >= size) 1315 { 1316 _bfd_error_handler 1317 (_("%pB: string not null terminated in ILF object file"), abfd); 1318 bfd_set_error (bfd_error_malformed_archive); 1319 bfd_release (abfd, ptr); 1320 return NULL; 1321 } 1322 1323 /* Now construct the bfd. */ 1324 if (! pe_ILF_build_a_bfd (abfd, magic, symbol_name, 1325 source_dll, ordinal, types)) 1326 { 1327 bfd_release (abfd, ptr); 1328 return NULL; 1329 } 1330 1331 return _bfd_no_cleanup; 1332 } 1333 1334 static void 1335 pe_bfd_read_buildid (bfd *abfd) 1336 { 1337 pe_data_type *pe = pe_data (abfd); 1338 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr; 1339 asection *section; 1340 bfd_byte *data = 0; 1341 bfd_size_type dataoff; 1342 unsigned int i; 1343 bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress; 1344 bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size; 1345 1346 if (size == 0) 1347 return; 1348 1349 addr += extra->ImageBase; 1350 1351 /* Search for the section containing the DebugDirectory. */ 1352 for (section = abfd->sections; section != NULL; section = section->next) 1353 { 1354 if ((addr >= section->vma) && (addr < (section->vma + section->size))) 1355 break; 1356 } 1357 1358 if (section == NULL) 1359 return; 1360 1361 if (!(section->flags & SEC_HAS_CONTENTS)) 1362 return; 1363 1364 dataoff = addr - section->vma; 1365 1366 /* PR 20605 and 22373: Make sure that the data is really there. 1367 Note - since we are dealing with unsigned quantities we have 1368 to be careful to check for potential overflows. */ 1369 if (dataoff >= section->size 1370 || size > section->size - dataoff) 1371 { 1372 _bfd_error_handler 1373 (_("%pB: error: debug data ends beyond end of debug directory"), 1374 abfd); 1375 return; 1376 } 1377 1378 /* Read the whole section. */ 1379 if (!bfd_malloc_and_get_section (abfd, section, &data)) 1380 { 1381 free (data); 1382 return; 1383 } 1384 1385 /* Search for a CodeView entry in the DebugDirectory */ 1386 for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++) 1387 { 1388 struct external_IMAGE_DEBUG_DIRECTORY *ext 1389 = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i]; 1390 struct internal_IMAGE_DEBUG_DIRECTORY idd; 1391 1392 _bfd_XXi_swap_debugdir_in (abfd, ext, &idd); 1393 1394 if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW) 1395 { 1396 char buffer[256 + 1]; 1397 CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer; 1398 1399 /* 1400 The debug entry doesn't have to have to be in a section, in which 1401 case AddressOfRawData is 0, so always use PointerToRawData. 1402 */ 1403 if (_bfd_XXi_slurp_codeview_record (abfd, 1404 (file_ptr) idd.PointerToRawData, 1405 idd.SizeOfData, cvinfo, NULL)) 1406 { 1407 struct bfd_build_id* build_id = bfd_alloc (abfd, 1408 sizeof (struct bfd_build_id) + cvinfo->SignatureLength); 1409 if (build_id) 1410 { 1411 build_id->size = cvinfo->SignatureLength; 1412 memcpy(build_id->data, cvinfo->Signature, 1413 cvinfo->SignatureLength); 1414 abfd->build_id = build_id; 1415 } 1416 } 1417 break; 1418 } 1419 } 1420 1421 free (data); 1422 } 1423 1424 static bfd_cleanup 1425 pe_bfd_object_p (bfd * abfd) 1426 { 1427 bfd_byte buffer[6]; 1428 struct external_DOS_hdr dos_hdr; 1429 struct external_PEI_IMAGE_hdr image_hdr; 1430 struct internal_filehdr internal_f; 1431 struct internal_aouthdr internal_a; 1432 bfd_size_type opt_hdr_size; 1433 file_ptr offset; 1434 bfd_cleanup result; 1435 1436 /* Detect if this a Microsoft Import Library Format element. */ 1437 /* First read the beginning of the header. */ 1438 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 1439 || bfd_bread (buffer, (bfd_size_type) 6, abfd) != 6) 1440 { 1441 if (bfd_get_error () != bfd_error_system_call) 1442 bfd_set_error (bfd_error_wrong_format); 1443 return NULL; 1444 } 1445 1446 /* Then check the magic and the version (only 0 is supported). */ 1447 if (H_GET_32 (abfd, buffer) == 0xffff0000 1448 && H_GET_16 (abfd, buffer + 4) == 0) 1449 return pe_ILF_object_p (abfd); 1450 1451 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 1452 || bfd_bread (&dos_hdr, (bfd_size_type) sizeof (dos_hdr), abfd) 1453 != sizeof (dos_hdr)) 1454 { 1455 if (bfd_get_error () != bfd_error_system_call) 1456 bfd_set_error (bfd_error_wrong_format); 1457 return NULL; 1458 } 1459 1460 /* There are really two magic numbers involved; the magic number 1461 that says this is a NT executable (PEI) and the magic number that 1462 determines the architecture. The former is IMAGE_DOS_SIGNATURE, stored in 1463 the e_magic field. The latter is stored in the f_magic field. 1464 If the NT magic number isn't valid, the architecture magic number 1465 could be mimicked by some other field (specifically, the number 1466 of relocs in section 3). Since this routine can only be called 1467 correctly for a PEI file, check the e_magic number here, and, if 1468 it doesn't match, clobber the f_magic number so that we don't get 1469 a false match. */ 1470 if (H_GET_16 (abfd, dos_hdr.e_magic) != IMAGE_DOS_SIGNATURE) 1471 { 1472 bfd_set_error (bfd_error_wrong_format); 1473 return NULL; 1474 } 1475 1476 offset = H_GET_32 (abfd, dos_hdr.e_lfanew); 1477 if (bfd_seek (abfd, offset, SEEK_SET) != 0 1478 || (bfd_bread (&image_hdr, (bfd_size_type) sizeof (image_hdr), abfd) 1479 != sizeof (image_hdr))) 1480 { 1481 if (bfd_get_error () != bfd_error_system_call) 1482 bfd_set_error (bfd_error_wrong_format); 1483 return NULL; 1484 } 1485 1486 if (H_GET_32 (abfd, image_hdr.nt_signature) != 0x4550) 1487 { 1488 bfd_set_error (bfd_error_wrong_format); 1489 return NULL; 1490 } 1491 1492 /* Swap file header, so that we get the location for calling 1493 real_object_p. */ 1494 bfd_coff_swap_filehdr_in (abfd, &image_hdr, &internal_f); 1495 1496 if (! bfd_coff_bad_format_hook (abfd, &internal_f) 1497 || internal_f.f_opthdr > bfd_coff_aoutsz (abfd)) 1498 { 1499 bfd_set_error (bfd_error_wrong_format); 1500 return NULL; 1501 } 1502 1503 memcpy (internal_f.pe.dos_message, dos_hdr.dos_message, 1504 sizeof (internal_f.pe.dos_message)); 1505 1506 /* Read the optional header, which has variable size. */ 1507 opt_hdr_size = internal_f.f_opthdr; 1508 1509 if (opt_hdr_size != 0) 1510 { 1511 bfd_size_type amt = opt_hdr_size; 1512 bfd_byte * opthdr; 1513 1514 /* PR 17521 file: 230-131433-0.004. */ 1515 if (amt < sizeof (PEAOUTHDR)) 1516 amt = sizeof (PEAOUTHDR); 1517 1518 opthdr = _bfd_alloc_and_read (abfd, amt, opt_hdr_size); 1519 if (opthdr == NULL) 1520 return NULL; 1521 if (amt > opt_hdr_size) 1522 memset (opthdr + opt_hdr_size, 0, amt - opt_hdr_size); 1523 1524 bfd_coff_swap_aouthdr_in (abfd, opthdr, &internal_a); 1525 1526 struct internal_extra_pe_aouthdr *a = &internal_a.pe; 1527 if ((a->SectionAlignment & -a->SectionAlignment) != a->SectionAlignment 1528 || a->SectionAlignment >= 0x80000000) 1529 { 1530 _bfd_error_handler (_("%pB: adjusting invalid SectionAlignment"), 1531 abfd); 1532 a->SectionAlignment &= -a->SectionAlignment; 1533 if (a->SectionAlignment >= 0x80000000) 1534 a->SectionAlignment = 0x40000000; 1535 } 1536 1537 if ((a->FileAlignment & -a->FileAlignment) != a->FileAlignment 1538 || a->FileAlignment > a->SectionAlignment) 1539 { 1540 _bfd_error_handler (_("%pB: adjusting invalid FileAlignment"), 1541 abfd); 1542 a->FileAlignment &= -a->FileAlignment; 1543 if (a->FileAlignment > a->SectionAlignment) 1544 a->FileAlignment = a->SectionAlignment; 1545 } 1546 1547 if (a->NumberOfRvaAndSizes > IMAGE_NUMBEROF_DIRECTORY_ENTRIES) 1548 _bfd_error_handler (_("%pB: invalid NumberOfRvaAndSizes"), abfd); 1549 } 1550 1551 result = coff_real_object_p (abfd, internal_f.f_nscns, &internal_f, 1552 (opt_hdr_size != 0 1553 ? &internal_a 1554 : (struct internal_aouthdr *) NULL)); 1555 1556 if (result) 1557 { 1558 /* Now the whole header has been processed, see if there is a build-id */ 1559 pe_bfd_read_buildid(abfd); 1560 } 1561 1562 return result; 1563 } 1564 1565 #define coff_object_p pe_bfd_object_p 1566 #endif /* COFF_IMAGE_WITH_PE */ 1567