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