1 /* Support for the generic parts of PE/PEI; the common executable parts. 2 Copyright (C) 1995-2020 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 <sac@cygnus.com>. 24 25 PE/PEI rearrangement (and code added): Donn Terry 26 Softway Systems, Inc. */ 27 28 /* Hey look, some documentation [and in a place you expect to find it]! 29 30 The main reference for the pei format is "Microsoft Portable Executable 31 and Common Object File Format Specification 4.1". Get it if you need to 32 do some serious hacking on this code. 33 34 Another reference: 35 "Peering Inside the PE: A Tour of the Win32 Portable Executable 36 File Format", MSJ 1994, Volume 9. 37 38 The PE/PEI format is also used by .NET. ECMA-335 describes this: 39 40 "Standard ECMA-335 Common Language Infrastructure (CLI)", 6th Edition, June 2012. 41 42 This is also available at 43 https://www.ecma-international.org/publications/files/ECMA-ST/ECMA-335.pdf. 44 45 The *sole* difference between the pe format and the pei format is that the 46 latter has an MSDOS 2.0 .exe header on the front that prints the message 47 "This app must be run under Windows." (or some such). 48 (FIXME: Whether that statement is *really* true or not is unknown. 49 Are there more subtle differences between pe and pei formats? 50 For now assume there aren't. If you find one, then for God sakes 51 document it here!) 52 53 The Microsoft docs use the word "image" instead of "executable" because 54 the former can also refer to a DLL (shared library). Confusion can arise 55 because the `i' in `pei' also refers to "image". The `pe' format can 56 also create images (i.e. executables), it's just that to run on a win32 57 system you need to use the pei format. 58 59 FIXME: Please add more docs here so the next poor fool that has to hack 60 on this code has a chance of getting something accomplished without 61 wasting too much time. */ 62 63 /* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64 64 depending on whether we're compiling for straight PE or PE+. */ 65 #define COFF_WITH_XX 66 67 #include "sysdep.h" 68 #include "bfd.h" 69 #include "libbfd.h" 70 #include "coff/internal.h" 71 #include "bfdver.h" 72 #include "libiberty.h" 73 #ifdef HAVE_WCHAR_H 74 #include <wchar.h> 75 #endif 76 #ifdef HAVE_WCTYPE_H 77 #include <wctype.h> 78 #endif 79 80 /* NOTE: it's strange to be including an architecture specific header 81 in what's supposed to be general (to PE/PEI) code. However, that's 82 where the definitions are, and they don't vary per architecture 83 within PE/PEI, so we get them from there. FIXME: The lack of 84 variance is an assumption which may prove to be incorrect if new 85 PE/PEI targets are created. */ 86 #if defined COFF_WITH_pex64 87 # include "coff/x86_64.h" 88 #elif defined COFF_WITH_pep 89 # include "coff/ia64.h" 90 #else 91 # include "coff/i386.h" 92 #endif 93 94 #include "coff/pe.h" 95 #include "libcoff.h" 96 #include "libpei.h" 97 #include "safe-ctype.h" 98 99 #if defined COFF_WITH_pep || defined COFF_WITH_pex64 100 # undef AOUTSZ 101 # define AOUTSZ PEPAOUTSZ 102 # define PEAOUTHDR PEPAOUTHDR 103 #endif 104 105 #define HighBitSet(val) ((val) & 0x80000000) 106 #define SetHighBit(val) ((val) | 0x80000000) 107 #define WithoutHighBit(val) ((val) & 0x7fffffff) 108 109 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests 110 worked when the code was in peicode.h, but no longer work now that 111 the code is in peigen.c. PowerPC NT is said to be dead. If 112 anybody wants to revive the code, you will have to figure out how 113 to handle those issues. */ 114 115 void 116 _bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1) 117 { 118 SYMENT *ext = (SYMENT *) ext1; 119 struct internal_syment *in = (struct internal_syment *) in1; 120 121 if (ext->e.e_name[0] == 0) 122 { 123 in->_n._n_n._n_zeroes = 0; 124 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset); 125 } 126 else 127 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN); 128 129 in->n_value = H_GET_32 (abfd, ext->e_value); 130 in->n_scnum = (short) H_GET_16 (abfd, ext->e_scnum); 131 132 if (sizeof (ext->e_type) == 2) 133 in->n_type = H_GET_16 (abfd, ext->e_type); 134 else 135 in->n_type = H_GET_32 (abfd, ext->e_type); 136 137 in->n_sclass = H_GET_8 (abfd, ext->e_sclass); 138 in->n_numaux = H_GET_8 (abfd, ext->e_numaux); 139 140 #ifndef STRICT_PE_FORMAT 141 /* This is for Gnu-created DLLs. */ 142 143 /* The section symbols for the .idata$ sections have class 0x68 144 (C_SECTION), which MS documentation indicates is a section 145 symbol. Unfortunately, the value field in the symbol is simply a 146 copy of the .idata section's flags rather than something useful. 147 When these symbols are encountered, change the value to 0 so that 148 they will be handled somewhat correctly in the bfd code. */ 149 if (in->n_sclass == C_SECTION) 150 { 151 char namebuf[SYMNMLEN + 1]; 152 const char *name = NULL; 153 154 in->n_value = 0x0; 155 156 /* Create synthetic empty sections as needed. DJ */ 157 if (in->n_scnum == 0) 158 { 159 asection *sec; 160 161 name = _bfd_coff_internal_syment_name (abfd, in, namebuf); 162 if (name == NULL) 163 { 164 _bfd_error_handler (_("%pB: unable to find name for empty section"), 165 abfd); 166 bfd_set_error (bfd_error_invalid_target); 167 return; 168 } 169 170 sec = bfd_get_section_by_name (abfd, name); 171 if (sec != NULL) 172 in->n_scnum = sec->target_index; 173 } 174 175 if (in->n_scnum == 0) 176 { 177 int unused_section_number = 0; 178 asection *sec; 179 flagword flags; 180 181 for (sec = abfd->sections; sec; sec = sec->next) 182 if (unused_section_number <= sec->target_index) 183 unused_section_number = sec->target_index + 1; 184 185 if (name == namebuf) 186 { 187 name = (const char *) bfd_alloc (abfd, strlen (namebuf) + 1); 188 if (name == NULL) 189 { 190 _bfd_error_handler (_("%pB: out of memory creating name for empty section"), 191 abfd); 192 return; 193 } 194 strcpy ((char *) name, namebuf); 195 } 196 197 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD; 198 sec = bfd_make_section_anyway_with_flags (abfd, name, flags); 199 if (sec == NULL) 200 { 201 _bfd_error_handler (_("%pB: unable to create fake empty section"), 202 abfd); 203 return; 204 } 205 206 sec->vma = 0; 207 sec->lma = 0; 208 sec->size = 0; 209 sec->filepos = 0; 210 sec->rel_filepos = 0; 211 sec->reloc_count = 0; 212 sec->line_filepos = 0; 213 sec->lineno_count = 0; 214 sec->userdata = NULL; 215 sec->next = NULL; 216 sec->alignment_power = 2; 217 218 sec->target_index = unused_section_number; 219 220 in->n_scnum = unused_section_number; 221 } 222 in->n_sclass = C_STAT; 223 } 224 #endif 225 226 #ifdef coff_swap_sym_in_hook 227 /* This won't work in peigen.c, but since it's for PPC PE, it's not 228 worth fixing. */ 229 coff_swap_sym_in_hook (abfd, ext1, in1); 230 #endif 231 } 232 233 static bfd_boolean 234 abs_finder (bfd * abfd ATTRIBUTE_UNUSED, asection * sec, void * data) 235 { 236 bfd_vma abs_val = * (bfd_vma *) data; 237 238 return (sec->vma <= abs_val) && ((sec->vma + (1ULL << 32)) > abs_val); 239 } 240 241 unsigned int 242 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp) 243 { 244 struct internal_syment *in = (struct internal_syment *) inp; 245 SYMENT *ext = (SYMENT *) extp; 246 247 if (in->_n._n_name[0] == 0) 248 { 249 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes); 250 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset); 251 } 252 else 253 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN); 254 255 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a 256 symbol. This is a problem on 64-bit targets where we can generate 257 absolute symbols with values >= 1^32. We try to work around this 258 problem by finding a section whose base address is sufficient to 259 reduce the absolute value to < 1^32, and then transforming the 260 symbol into a section relative symbol. This of course is a hack. */ 261 if (sizeof (in->n_value) > 4 262 /* The strange computation of the shift amount is here in order to 263 avoid a compile time warning about the comparison always being 264 false. It does not matter if this test fails to work as expected 265 as the worst that can happen is that some absolute symbols are 266 needlessly converted into section relative symbols. */ 267 && in->n_value > ((1ULL << (sizeof (in->n_value) > 4 ? 32 : 31)) - 1) 268 && in->n_scnum == N_ABS) 269 { 270 asection * sec; 271 272 sec = bfd_sections_find_if (abfd, abs_finder, & in->n_value); 273 if (sec) 274 { 275 in->n_value -= sec->vma; 276 in->n_scnum = sec->target_index; 277 } 278 /* else: FIXME: The value is outside the range of any section. This 279 happens for __image_base__ and __ImageBase and maybe some other 280 symbols as well. We should find a way to handle these values. */ 281 } 282 283 H_PUT_32 (abfd, in->n_value, ext->e_value); 284 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum); 285 286 if (sizeof (ext->e_type) == 2) 287 H_PUT_16 (abfd, in->n_type, ext->e_type); 288 else 289 H_PUT_32 (abfd, in->n_type, ext->e_type); 290 291 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass); 292 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux); 293 294 return SYMESZ; 295 } 296 297 void 298 _bfd_XXi_swap_aux_in (bfd * abfd, 299 void * ext1, 300 int type, 301 int in_class, 302 int indx ATTRIBUTE_UNUSED, 303 int numaux ATTRIBUTE_UNUSED, 304 void * in1) 305 { 306 AUXENT *ext = (AUXENT *) ext1; 307 union internal_auxent *in = (union internal_auxent *) in1; 308 309 /* PR 17521: Make sure that all fields in the aux structure 310 are initialised. */ 311 memset (in, 0, sizeof * in); 312 switch (in_class) 313 { 314 case C_FILE: 315 if (ext->x_file.x_fname[0] == 0) 316 { 317 in->x_file.x_n.x_zeroes = 0; 318 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset); 319 } 320 else 321 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN); 322 return; 323 324 case C_STAT: 325 case C_LEAFSTAT: 326 case C_HIDDEN: 327 if (type == T_NULL) 328 { 329 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext); 330 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext); 331 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext); 332 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum); 333 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated); 334 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat); 335 return; 336 } 337 break; 338 } 339 340 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx); 341 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx); 342 343 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type) 344 || ISTAG (in_class)) 345 { 346 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext); 347 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext); 348 } 349 else 350 { 351 in->x_sym.x_fcnary.x_ary.x_dimen[0] = 352 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]); 353 in->x_sym.x_fcnary.x_ary.x_dimen[1] = 354 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]); 355 in->x_sym.x_fcnary.x_ary.x_dimen[2] = 356 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]); 357 in->x_sym.x_fcnary.x_ary.x_dimen[3] = 358 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]); 359 } 360 361 if (ISFCN (type)) 362 { 363 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize); 364 } 365 else 366 { 367 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext); 368 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext); 369 } 370 } 371 372 unsigned int 373 _bfd_XXi_swap_aux_out (bfd * abfd, 374 void * inp, 375 int type, 376 int in_class, 377 int indx ATTRIBUTE_UNUSED, 378 int numaux ATTRIBUTE_UNUSED, 379 void * extp) 380 { 381 union internal_auxent *in = (union internal_auxent *) inp; 382 AUXENT *ext = (AUXENT *) extp; 383 384 memset (ext, 0, AUXESZ); 385 386 switch (in_class) 387 { 388 case C_FILE: 389 if (in->x_file.x_fname[0] == 0) 390 { 391 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes); 392 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset); 393 } 394 else 395 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN); 396 397 return AUXESZ; 398 399 case C_STAT: 400 case C_LEAFSTAT: 401 case C_HIDDEN: 402 if (type == T_NULL) 403 { 404 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext); 405 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext); 406 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext); 407 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum); 408 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated); 409 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat); 410 return AUXESZ; 411 } 412 break; 413 } 414 415 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx); 416 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx); 417 418 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type) 419 || ISTAG (in_class)) 420 { 421 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext); 422 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext); 423 } 424 else 425 { 426 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0], 427 ext->x_sym.x_fcnary.x_ary.x_dimen[0]); 428 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1], 429 ext->x_sym.x_fcnary.x_ary.x_dimen[1]); 430 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2], 431 ext->x_sym.x_fcnary.x_ary.x_dimen[2]); 432 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3], 433 ext->x_sym.x_fcnary.x_ary.x_dimen[3]); 434 } 435 436 if (ISFCN (type)) 437 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize); 438 else 439 { 440 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext); 441 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext); 442 } 443 444 return AUXESZ; 445 } 446 447 void 448 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1) 449 { 450 LINENO *ext = (LINENO *) ext1; 451 struct internal_lineno *in = (struct internal_lineno *) in1; 452 453 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx); 454 in->l_lnno = GET_LINENO_LNNO (abfd, ext); 455 } 456 457 unsigned int 458 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp) 459 { 460 struct internal_lineno *in = (struct internal_lineno *) inp; 461 struct external_lineno *ext = (struct external_lineno *) outp; 462 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx); 463 464 PUT_LINENO_LNNO (abfd, in->l_lnno, ext); 465 return LINESZ; 466 } 467 468 void 469 _bfd_XXi_swap_aouthdr_in (bfd * abfd, 470 void * aouthdr_ext1, 471 void * aouthdr_int1) 472 { 473 PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1; 474 AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1; 475 struct internal_aouthdr *aouthdr_int 476 = (struct internal_aouthdr *) aouthdr_int1; 477 struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe; 478 479 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic); 480 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp); 481 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize); 482 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize); 483 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize); 484 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry); 485 aouthdr_int->text_start = 486 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start); 487 488 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 489 /* PE32+ does not have data_start member! */ 490 aouthdr_int->data_start = 491 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start); 492 a->BaseOfData = aouthdr_int->data_start; 493 #endif 494 495 a->Magic = aouthdr_int->magic; 496 a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp); 497 a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1); 498 a->SizeOfCode = aouthdr_int->tsize ; 499 a->SizeOfInitializedData = aouthdr_int->dsize ; 500 a->SizeOfUninitializedData = aouthdr_int->bsize ; 501 a->AddressOfEntryPoint = aouthdr_int->entry; 502 a->BaseOfCode = aouthdr_int->text_start; 503 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase); 504 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment); 505 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment); 506 a->MajorOperatingSystemVersion = 507 H_GET_16 (abfd, src->MajorOperatingSystemVersion); 508 a->MinorOperatingSystemVersion = 509 H_GET_16 (abfd, src->MinorOperatingSystemVersion); 510 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion); 511 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion); 512 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion); 513 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion); 514 a->Reserved1 = H_GET_32 (abfd, src->Reserved1); 515 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage); 516 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders); 517 a->CheckSum = H_GET_32 (abfd, src->CheckSum); 518 a->Subsystem = H_GET_16 (abfd, src->Subsystem); 519 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics); 520 a->SizeOfStackReserve = 521 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve); 522 a->SizeOfStackCommit = 523 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit); 524 a->SizeOfHeapReserve = 525 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve); 526 a->SizeOfHeapCommit = 527 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit); 528 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags); 529 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes); 530 531 { 532 unsigned idx; 533 534 /* PR 17512: Corrupt PE binaries can cause seg-faults. */ 535 if (a->NumberOfRvaAndSizes > IMAGE_NUMBEROF_DIRECTORY_ENTRIES) 536 { 537 /* xgettext:c-format */ 538 _bfd_error_handler 539 (_("%pB: aout header specifies an invalid number of" 540 " data-directory entries: %u"), abfd, a->NumberOfRvaAndSizes); 541 bfd_set_error (bfd_error_bad_value); 542 543 /* Paranoia: If the number is corrupt, then assume that the 544 actual entries themselves might be corrupt as well. */ 545 a->NumberOfRvaAndSizes = 0; 546 } 547 548 for (idx = 0; idx < a->NumberOfRvaAndSizes; idx++) 549 { 550 /* If data directory is empty, rva also should be 0. */ 551 int size = 552 H_GET_32 (abfd, src->DataDirectory[idx][1]); 553 554 a->DataDirectory[idx].Size = size; 555 556 if (size) 557 a->DataDirectory[idx].VirtualAddress = 558 H_GET_32 (abfd, src->DataDirectory[idx][0]); 559 else 560 a->DataDirectory[idx].VirtualAddress = 0; 561 } 562 563 while (idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES) 564 { 565 a->DataDirectory[idx].Size = 0; 566 a->DataDirectory[idx].VirtualAddress = 0; 567 idx ++; 568 } 569 } 570 571 if (aouthdr_int->entry) 572 { 573 aouthdr_int->entry += a->ImageBase; 574 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 575 aouthdr_int->entry &= 0xffffffff; 576 #endif 577 } 578 579 if (aouthdr_int->tsize) 580 { 581 aouthdr_int->text_start += a->ImageBase; 582 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 583 aouthdr_int->text_start &= 0xffffffff; 584 #endif 585 } 586 587 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 588 /* PE32+ does not have data_start member! */ 589 if (aouthdr_int->dsize) 590 { 591 aouthdr_int->data_start += a->ImageBase; 592 aouthdr_int->data_start &= 0xffffffff; 593 } 594 #endif 595 596 #ifdef POWERPC_LE_PE 597 /* These three fields are normally set up by ppc_relocate_section. 598 In the case of reading a file in, we can pick them up from the 599 DataDirectory. */ 600 first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress; 601 thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size; 602 import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size; 603 #endif 604 } 605 606 /* A support function for below. */ 607 608 static void 609 add_data_entry (bfd * abfd, 610 struct internal_extra_pe_aouthdr *aout, 611 int idx, 612 char *name, 613 bfd_vma base) 614 { 615 asection *sec = bfd_get_section_by_name (abfd, name); 616 617 /* Add import directory information if it exists. */ 618 if ((sec != NULL) 619 && (coff_section_data (abfd, sec) != NULL) 620 && (pei_section_data (abfd, sec) != NULL)) 621 { 622 /* If data directory is empty, rva also should be 0. */ 623 int size = pei_section_data (abfd, sec)->virt_size; 624 aout->DataDirectory[idx].Size = size; 625 626 if (size) 627 { 628 aout->DataDirectory[idx].VirtualAddress = 629 (sec->vma - base) & 0xffffffff; 630 sec->flags |= SEC_DATA; 631 } 632 } 633 } 634 635 unsigned int 636 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out) 637 { 638 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in; 639 pe_data_type *pe = pe_data (abfd); 640 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr; 641 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out; 642 bfd_vma sa, fa, ib; 643 IMAGE_DATA_DIRECTORY idata2, idata5, tls; 644 645 sa = extra->SectionAlignment; 646 fa = extra->FileAlignment; 647 ib = extra->ImageBase; 648 649 idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE]; 650 idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE]; 651 tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE]; 652 653 if (aouthdr_in->tsize) 654 { 655 aouthdr_in->text_start -= ib; 656 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 657 aouthdr_in->text_start &= 0xffffffff; 658 #endif 659 } 660 661 if (aouthdr_in->dsize) 662 { 663 aouthdr_in->data_start -= ib; 664 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 665 aouthdr_in->data_start &= 0xffffffff; 666 #endif 667 } 668 669 if (aouthdr_in->entry) 670 { 671 aouthdr_in->entry -= ib; 672 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 673 aouthdr_in->entry &= 0xffffffff; 674 #endif 675 } 676 677 #define FA(x) (((x) + fa -1 ) & (- fa)) 678 #define SA(x) (((x) + sa -1 ) & (- sa)) 679 680 /* We like to have the sizes aligned. */ 681 aouthdr_in->bsize = FA (aouthdr_in->bsize); 682 683 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES; 684 685 add_data_entry (abfd, extra, PE_EXPORT_TABLE, ".edata", ib); 686 add_data_entry (abfd, extra, PE_RESOURCE_TABLE, ".rsrc", ib); 687 add_data_entry (abfd, extra, PE_EXCEPTION_TABLE, ".pdata", ib); 688 689 /* In theory we do not need to call add_data_entry for .idata$2 or 690 .idata$5. It will be done in bfd_coff_final_link where all the 691 required information is available. If however, we are not going 692 to perform a final link, eg because we have been invoked by objcopy 693 or strip, then we need to make sure that these Data Directory 694 entries are initialised properly. 695 696 So - we copy the input values into the output values, and then, if 697 a final link is going to be performed, it can overwrite them. */ 698 extra->DataDirectory[PE_IMPORT_TABLE] = idata2; 699 extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5; 700 extra->DataDirectory[PE_TLS_TABLE] = tls; 701 702 if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0) 703 /* Until other .idata fixes are made (pending patch), the entry for 704 .idata is needed for backwards compatibility. FIXME. */ 705 add_data_entry (abfd, extra, PE_IMPORT_TABLE, ".idata", ib); 706 707 /* For some reason, the virtual size (which is what's set by 708 add_data_entry) for .reloc is not the same as the size recorded 709 in this slot by MSVC; it doesn't seem to cause problems (so far), 710 but since it's the best we've got, use it. It does do the right 711 thing for .pdata. */ 712 if (pe->has_reloc_section) 713 add_data_entry (abfd, extra, PE_BASE_RELOCATION_TABLE, ".reloc", ib); 714 715 { 716 asection *sec; 717 bfd_vma hsize = 0; 718 bfd_vma dsize = 0; 719 bfd_vma isize = 0; 720 bfd_vma tsize = 0; 721 722 for (sec = abfd->sections; sec; sec = sec->next) 723 { 724 int rounded = FA (sec->size); 725 726 if (rounded == 0) 727 continue; 728 729 /* The first non-zero section filepos is the header size. 730 Sections without contents will have a filepos of 0. */ 731 if (hsize == 0) 732 hsize = sec->filepos; 733 if (sec->flags & SEC_DATA) 734 dsize += rounded; 735 if (sec->flags & SEC_CODE) 736 tsize += rounded; 737 /* The image size is the total VIRTUAL size (which is what is 738 in the virt_size field). Files have been seen (from MSVC 739 5.0 link.exe) where the file size of the .data segment is 740 quite small compared to the virtual size. Without this 741 fix, strip munges the file. 742 743 FIXME: We need to handle holes between sections, which may 744 happpen when we covert from another format. We just use 745 the virtual address and virtual size of the last section 746 for the image size. */ 747 if (coff_section_data (abfd, sec) != NULL 748 && pei_section_data (abfd, sec) != NULL) 749 isize = (sec->vma - extra->ImageBase 750 + SA (FA (pei_section_data (abfd, sec)->virt_size))); 751 } 752 753 aouthdr_in->dsize = dsize; 754 aouthdr_in->tsize = tsize; 755 extra->SizeOfHeaders = hsize; 756 extra->SizeOfImage = isize; 757 } 758 759 H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic); 760 761 /* e.g. 219510000 is linker version 2.19 */ 762 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000)) 763 764 /* This piece of magic sets the "linker version" field to 765 LINKER_VERSION. */ 766 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256), 767 aouthdr_out->standard.vstamp); 768 769 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize); 770 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize); 771 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize); 772 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry); 773 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start, 774 aouthdr_out->standard.text_start); 775 776 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 777 /* PE32+ does not have data_start member! */ 778 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start, 779 aouthdr_out->standard.data_start); 780 #endif 781 782 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase); 783 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment); 784 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment); 785 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion, 786 aouthdr_out->MajorOperatingSystemVersion); 787 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion, 788 aouthdr_out->MinorOperatingSystemVersion); 789 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion); 790 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion); 791 H_PUT_16 (abfd, extra->MajorSubsystemVersion, 792 aouthdr_out->MajorSubsystemVersion); 793 H_PUT_16 (abfd, extra->MinorSubsystemVersion, 794 aouthdr_out->MinorSubsystemVersion); 795 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1); 796 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage); 797 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders); 798 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum); 799 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem); 800 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics); 801 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve, 802 aouthdr_out->SizeOfStackReserve); 803 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit, 804 aouthdr_out->SizeOfStackCommit); 805 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve, 806 aouthdr_out->SizeOfHeapReserve); 807 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit, 808 aouthdr_out->SizeOfHeapCommit); 809 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags); 810 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes, 811 aouthdr_out->NumberOfRvaAndSizes); 812 { 813 int idx; 814 815 for (idx = 0; idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; idx++) 816 { 817 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress, 818 aouthdr_out->DataDirectory[idx][0]); 819 H_PUT_32 (abfd, extra->DataDirectory[idx].Size, 820 aouthdr_out->DataDirectory[idx][1]); 821 } 822 } 823 824 return AOUTSZ; 825 } 826 827 unsigned int 828 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out) 829 { 830 int idx; 831 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in; 832 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out; 833 834 if (pe_data (abfd)->has_reloc_section 835 || pe_data (abfd)->dont_strip_reloc) 836 filehdr_in->f_flags &= ~F_RELFLG; 837 838 if (pe_data (abfd)->dll) 839 filehdr_in->f_flags |= F_DLL; 840 841 filehdr_in->pe.e_magic = IMAGE_DOS_SIGNATURE; 842 filehdr_in->pe.e_cblp = 0x90; 843 filehdr_in->pe.e_cp = 0x3; 844 filehdr_in->pe.e_crlc = 0x0; 845 filehdr_in->pe.e_cparhdr = 0x4; 846 filehdr_in->pe.e_minalloc = 0x0; 847 filehdr_in->pe.e_maxalloc = 0xffff; 848 filehdr_in->pe.e_ss = 0x0; 849 filehdr_in->pe.e_sp = 0xb8; 850 filehdr_in->pe.e_csum = 0x0; 851 filehdr_in->pe.e_ip = 0x0; 852 filehdr_in->pe.e_cs = 0x0; 853 filehdr_in->pe.e_lfarlc = 0x40; 854 filehdr_in->pe.e_ovno = 0x0; 855 856 for (idx = 0; idx < 4; idx++) 857 filehdr_in->pe.e_res[idx] = 0x0; 858 859 filehdr_in->pe.e_oemid = 0x0; 860 filehdr_in->pe.e_oeminfo = 0x0; 861 862 for (idx = 0; idx < 10; idx++) 863 filehdr_in->pe.e_res2[idx] = 0x0; 864 865 filehdr_in->pe.e_lfanew = 0x80; 866 867 /* This next collection of data are mostly just characters. It 868 appears to be constant within the headers put on NT exes. */ 869 memcpy (filehdr_in->pe.dos_message, pe_data (abfd)->dos_message, 870 sizeof (filehdr_in->pe.dos_message)); 871 872 filehdr_in->pe.nt_signature = IMAGE_NT_SIGNATURE; 873 874 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic); 875 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns); 876 877 /* Use a real timestamp by default, unless the no-insert-timestamp 878 option was chosen. */ 879 if ((pe_data (abfd)->insert_timestamp)) 880 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat); 881 else 882 H_PUT_32 (abfd, 0, filehdr_out->f_timdat); 883 884 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, 885 filehdr_out->f_symptr); 886 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms); 887 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr); 888 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags); 889 890 /* Put in extra dos header stuff. This data remains essentially 891 constant, it just has to be tacked on to the beginning of all exes 892 for NT. */ 893 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic); 894 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp); 895 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp); 896 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc); 897 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr); 898 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc); 899 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc); 900 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss); 901 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp); 902 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum); 903 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip); 904 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs); 905 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc); 906 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno); 907 908 for (idx = 0; idx < 4; idx++) 909 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]); 910 911 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid); 912 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo); 913 914 for (idx = 0; idx < 10; idx++) 915 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]); 916 917 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew); 918 919 for (idx = 0; idx < 16; idx++) 920 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx], 921 filehdr_out->dos_message[idx]); 922 923 /* Also put in the NT signature. */ 924 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature); 925 926 return FILHSZ; 927 } 928 929 unsigned int 930 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out) 931 { 932 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in; 933 FILHDR *filehdr_out = (FILHDR *) out; 934 935 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic); 936 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns); 937 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat); 938 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr); 939 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms); 940 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr); 941 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags); 942 943 return FILHSZ; 944 } 945 946 unsigned int 947 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out) 948 { 949 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in; 950 SCNHDR *scnhdr_ext = (SCNHDR *) out; 951 unsigned int ret = SCNHSZ; 952 bfd_vma ps; 953 bfd_vma ss; 954 955 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name)); 956 957 PUT_SCNHDR_VADDR (abfd, 958 ((scnhdr_int->s_vaddr 959 - pe_data (abfd)->pe_opthdr.ImageBase) 960 & 0xffffffff), 961 scnhdr_ext->s_vaddr); 962 963 /* NT wants the size data to be rounded up to the next 964 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss, 965 sometimes). */ 966 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0) 967 { 968 if (bfd_pei_p (abfd)) 969 { 970 ps = scnhdr_int->s_size; 971 ss = 0; 972 } 973 else 974 { 975 ps = 0; 976 ss = scnhdr_int->s_size; 977 } 978 } 979 else 980 { 981 if (bfd_pei_p (abfd)) 982 ps = scnhdr_int->s_paddr; 983 else 984 ps = 0; 985 986 ss = scnhdr_int->s_size; 987 } 988 989 PUT_SCNHDR_SIZE (abfd, ss, 990 scnhdr_ext->s_size); 991 992 /* s_paddr in PE is really the virtual size. */ 993 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr); 994 995 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr, 996 scnhdr_ext->s_scnptr); 997 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr, 998 scnhdr_ext->s_relptr); 999 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr, 1000 scnhdr_ext->s_lnnoptr); 1001 1002 { 1003 /* Extra flags must be set when dealing with PE. All sections should also 1004 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the 1005 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data 1006 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set 1007 (this is especially important when dealing with the .idata section since 1008 the addresses for routines from .dlls must be overwritten). If .reloc 1009 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE 1010 (0x02000000). Also, the resource data should also be read and 1011 writable. */ 1012 1013 /* FIXME: Alignment is also encoded in this field, at least on PPC and 1014 ARM-WINCE. Although - how do we get the original alignment field 1015 back ? */ 1016 1017 typedef struct 1018 { 1019 char section_name[SCNNMLEN]; 1020 unsigned long must_have; 1021 } 1022 pe_required_section_flags; 1023 1024 pe_required_section_flags known_sections [] = 1025 { 1026 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES }, 1027 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 1028 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 1029 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA }, 1030 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 1031 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA }, 1032 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA }, 1033 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE }, 1034 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 1035 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE }, 1036 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 1037 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA }, 1038 }; 1039 1040 pe_required_section_flags * p; 1041 1042 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now 1043 we know exactly what this specific section wants so we remove it 1044 and then allow the must_have field to add it back in if necessary. 1045 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the 1046 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared 1047 by ld --enable-auto-import (if auto-import is actually needed), 1048 by ld --omagic, or by obcopy --writable-text. */ 1049 1050 for (p = known_sections; 1051 p < known_sections + ARRAY_SIZE (known_sections); 1052 p++) 1053 if (memcmp (scnhdr_int->s_name, p->section_name, SCNNMLEN) == 0) 1054 { 1055 if (memcmp (scnhdr_int->s_name, ".text", sizeof ".text") 1056 || (bfd_get_file_flags (abfd) & WP_TEXT)) 1057 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE; 1058 scnhdr_int->s_flags |= p->must_have; 1059 break; 1060 } 1061 1062 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags); 1063 } 1064 1065 if (coff_data (abfd)->link_info 1066 && ! bfd_link_relocatable (coff_data (abfd)->link_info) 1067 && ! bfd_link_pic (coff_data (abfd)->link_info) 1068 && memcmp (scnhdr_int->s_name, ".text", sizeof ".text") == 0) 1069 { 1070 /* By inference from looking at MS output, the 32 bit field 1071 which is the combination of the number_of_relocs and 1072 number_of_linenos is used for the line number count in 1073 executables. A 16-bit field won't do for cc1. The MS 1074 document says that the number of relocs is zero for 1075 executables, but the 17-th bit has been observed to be there. 1076 Overflow is not an issue: a 4G-line program will overflow a 1077 bunch of other fields long before this! */ 1078 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno); 1079 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc); 1080 } 1081 else 1082 { 1083 if (scnhdr_int->s_nlnno <= 0xffff) 1084 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno); 1085 else 1086 { 1087 /* xgettext:c-format */ 1088 _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"), 1089 abfd, scnhdr_int->s_nlnno); 1090 bfd_set_error (bfd_error_file_truncated); 1091 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno); 1092 ret = 0; 1093 } 1094 1095 /* Although we could encode 0xffff relocs here, we do not, to be 1096 consistent with other parts of bfd. Also it lets us warn, as 1097 we should never see 0xffff here w/o having the overflow flag 1098 set. */ 1099 if (scnhdr_int->s_nreloc < 0xffff) 1100 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc); 1101 else 1102 { 1103 /* PE can deal with large #s of relocs, but not here. */ 1104 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc); 1105 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL; 1106 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags); 1107 } 1108 } 1109 return ret; 1110 } 1111 1112 void 1113 _bfd_XXi_swap_debugdir_in (bfd * abfd, void * ext1, void * in1) 1114 { 1115 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) ext1; 1116 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) in1; 1117 1118 in->Characteristics = H_GET_32(abfd, ext->Characteristics); 1119 in->TimeDateStamp = H_GET_32(abfd, ext->TimeDateStamp); 1120 in->MajorVersion = H_GET_16(abfd, ext->MajorVersion); 1121 in->MinorVersion = H_GET_16(abfd, ext->MinorVersion); 1122 in->Type = H_GET_32(abfd, ext->Type); 1123 in->SizeOfData = H_GET_32(abfd, ext->SizeOfData); 1124 in->AddressOfRawData = H_GET_32(abfd, ext->AddressOfRawData); 1125 in->PointerToRawData = H_GET_32(abfd, ext->PointerToRawData); 1126 } 1127 1128 unsigned int 1129 _bfd_XXi_swap_debugdir_out (bfd * abfd, void * inp, void * extp) 1130 { 1131 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) extp; 1132 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) inp; 1133 1134 H_PUT_32(abfd, in->Characteristics, ext->Characteristics); 1135 H_PUT_32(abfd, in->TimeDateStamp, ext->TimeDateStamp); 1136 H_PUT_16(abfd, in->MajorVersion, ext->MajorVersion); 1137 H_PUT_16(abfd, in->MinorVersion, ext->MinorVersion); 1138 H_PUT_32(abfd, in->Type, ext->Type); 1139 H_PUT_32(abfd, in->SizeOfData, ext->SizeOfData); 1140 H_PUT_32(abfd, in->AddressOfRawData, ext->AddressOfRawData); 1141 H_PUT_32(abfd, in->PointerToRawData, ext->PointerToRawData); 1142 1143 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY); 1144 } 1145 1146 CODEVIEW_INFO * 1147 _bfd_XXi_slurp_codeview_record (bfd * abfd, file_ptr where, unsigned long length, CODEVIEW_INFO *cvinfo) 1148 { 1149 char buffer[256+1]; 1150 1151 if (bfd_seek (abfd, where, SEEK_SET) != 0) 1152 return NULL; 1153 1154 if (bfd_bread (buffer, 256, abfd) < 4) 1155 return NULL; 1156 1157 /* Ensure null termination of filename. */ 1158 buffer[256] = '\0'; 1159 1160 cvinfo->CVSignature = H_GET_32 (abfd, buffer); 1161 cvinfo->Age = 0; 1162 1163 if ((cvinfo->CVSignature == CVINFO_PDB70_CVSIGNATURE) 1164 && (length > sizeof (CV_INFO_PDB70))) 1165 { 1166 CV_INFO_PDB70 *cvinfo70 = (CV_INFO_PDB70 *)(buffer); 1167 1168 cvinfo->Age = H_GET_32(abfd, cvinfo70->Age); 1169 1170 /* A GUID consists of 4,2,2 byte values in little-endian order, followed 1171 by 8 single bytes. Byte swap them so we can conveniently treat the GUID 1172 as 16 bytes in big-endian order. */ 1173 bfd_putb32 (bfd_getl32 (cvinfo70->Signature), cvinfo->Signature); 1174 bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[4])), &(cvinfo->Signature[4])); 1175 bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[6])), &(cvinfo->Signature[6])); 1176 memcpy (&(cvinfo->Signature[8]), &(cvinfo70->Signature[8]), 8); 1177 1178 cvinfo->SignatureLength = CV_INFO_SIGNATURE_LENGTH; 1179 // cvinfo->PdbFileName = cvinfo70->PdbFileName; 1180 1181 return cvinfo; 1182 } 1183 else if ((cvinfo->CVSignature == CVINFO_PDB20_CVSIGNATURE) 1184 && (length > sizeof (CV_INFO_PDB20))) 1185 { 1186 CV_INFO_PDB20 *cvinfo20 = (CV_INFO_PDB20 *)(buffer); 1187 cvinfo->Age = H_GET_32(abfd, cvinfo20->Age); 1188 memcpy (cvinfo->Signature, cvinfo20->Signature, 4); 1189 cvinfo->SignatureLength = 4; 1190 // cvinfo->PdbFileName = cvinfo20->PdbFileName; 1191 1192 return cvinfo; 1193 } 1194 1195 return NULL; 1196 } 1197 1198 unsigned int 1199 _bfd_XXi_write_codeview_record (bfd * abfd, file_ptr where, CODEVIEW_INFO *cvinfo) 1200 { 1201 const bfd_size_type size = sizeof (CV_INFO_PDB70) + 1; 1202 bfd_size_type written; 1203 CV_INFO_PDB70 *cvinfo70; 1204 char * buffer; 1205 1206 if (bfd_seek (abfd, where, SEEK_SET) != 0) 1207 return 0; 1208 1209 buffer = bfd_malloc (size); 1210 if (buffer == NULL) 1211 return 0; 1212 1213 cvinfo70 = (CV_INFO_PDB70 *) buffer; 1214 H_PUT_32 (abfd, CVINFO_PDB70_CVSIGNATURE, cvinfo70->CvSignature); 1215 1216 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values 1217 in little-endian order, followed by 8 single bytes. */ 1218 bfd_putl32 (bfd_getb32 (cvinfo->Signature), cvinfo70->Signature); 1219 bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[4])), &(cvinfo70->Signature[4])); 1220 bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[6])), &(cvinfo70->Signature[6])); 1221 memcpy (&(cvinfo70->Signature[8]), &(cvinfo->Signature[8]), 8); 1222 1223 H_PUT_32 (abfd, cvinfo->Age, cvinfo70->Age); 1224 cvinfo70->PdbFileName[0] = '\0'; 1225 1226 written = bfd_bwrite (buffer, size, abfd); 1227 1228 free (buffer); 1229 1230 return written == size ? size : 0; 1231 } 1232 1233 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] = 1234 { 1235 N_("Export Directory [.edata (or where ever we found it)]"), 1236 N_("Import Directory [parts of .idata]"), 1237 N_("Resource Directory [.rsrc]"), 1238 N_("Exception Directory [.pdata]"), 1239 N_("Security Directory"), 1240 N_("Base Relocation Directory [.reloc]"), 1241 N_("Debug Directory"), 1242 N_("Description Directory"), 1243 N_("Special Directory"), 1244 N_("Thread Storage Directory [.tls]"), 1245 N_("Load Configuration Directory"), 1246 N_("Bound Import Directory"), 1247 N_("Import Address Table Directory"), 1248 N_("Delay Import Directory"), 1249 N_("CLR Runtime Header"), 1250 N_("Reserved") 1251 }; 1252 1253 #ifdef POWERPC_LE_PE 1254 /* The code for the PPC really falls in the "architecture dependent" 1255 category. However, it's not clear that anyone will ever care, so 1256 we're ignoring the issue for now; if/when PPC matters, some of this 1257 may need to go into peicode.h, or arguments passed to enable the 1258 PPC- specific code. */ 1259 #endif 1260 1261 static bfd_boolean 1262 pe_print_idata (bfd * abfd, void * vfile) 1263 { 1264 FILE *file = (FILE *) vfile; 1265 bfd_byte *data; 1266 asection *section; 1267 bfd_signed_vma adj; 1268 1269 #ifdef POWERPC_LE_PE 1270 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata"); 1271 #endif 1272 1273 bfd_size_type datasize = 0; 1274 bfd_size_type dataoff; 1275 bfd_size_type i; 1276 int onaline = 20; 1277 1278 pe_data_type *pe = pe_data (abfd); 1279 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr; 1280 1281 bfd_vma addr; 1282 1283 addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress; 1284 1285 if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0) 1286 { 1287 /* Maybe the extra header isn't there. Look for the section. */ 1288 section = bfd_get_section_by_name (abfd, ".idata"); 1289 if (section == NULL) 1290 return TRUE; 1291 1292 addr = section->vma; 1293 datasize = section->size; 1294 if (datasize == 0) 1295 return TRUE; 1296 } 1297 else 1298 { 1299 addr += extra->ImageBase; 1300 for (section = abfd->sections; section != NULL; section = section->next) 1301 { 1302 datasize = section->size; 1303 if (addr >= section->vma && addr < section->vma + datasize) 1304 break; 1305 } 1306 1307 if (section == NULL) 1308 { 1309 fprintf (file, 1310 _("\nThere is an import table, but the section containing it could not be found\n")); 1311 return TRUE; 1312 } 1313 else if (!(section->flags & SEC_HAS_CONTENTS)) 1314 { 1315 fprintf (file, 1316 _("\nThere is an import table in %s, but that section has no contents\n"), 1317 section->name); 1318 return TRUE; 1319 } 1320 } 1321 1322 /* xgettext:c-format */ 1323 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"), 1324 section->name, (unsigned long) addr); 1325 1326 dataoff = addr - section->vma; 1327 1328 #ifdef POWERPC_LE_PE 1329 if (rel_section != 0 && rel_section->size != 0) 1330 { 1331 /* The toc address can be found by taking the starting address, 1332 which on the PPC locates a function descriptor. The 1333 descriptor consists of the function code starting address 1334 followed by the address of the toc. The starting address we 1335 get from the bfd, and the descriptor is supposed to be in the 1336 .reldata section. */ 1337 1338 bfd_vma loadable_toc_address; 1339 bfd_vma toc_address; 1340 bfd_vma start_address; 1341 bfd_byte *data; 1342 bfd_vma offset; 1343 1344 if (!bfd_malloc_and_get_section (abfd, rel_section, &data)) 1345 { 1346 if (data != NULL) 1347 free (data); 1348 return FALSE; 1349 } 1350 1351 offset = abfd->start_address - rel_section->vma; 1352 1353 if (offset >= rel_section->size || offset + 8 > rel_section->size) 1354 { 1355 if (data != NULL) 1356 free (data); 1357 return FALSE; 1358 } 1359 1360 start_address = bfd_get_32 (abfd, data + offset); 1361 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4); 1362 toc_address = loadable_toc_address - 32768; 1363 1364 fprintf (file, 1365 _("\nFunction descriptor located at the start address: %04lx\n"), 1366 (unsigned long int) (abfd->start_address)); 1367 fprintf (file, 1368 /* xgettext:c-format */ 1369 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"), 1370 start_address, loadable_toc_address, toc_address); 1371 if (data != NULL) 1372 free (data); 1373 } 1374 else 1375 { 1376 fprintf (file, 1377 _("\nNo reldata section! Function descriptor not decoded.\n")); 1378 } 1379 #endif 1380 1381 fprintf (file, 1382 _("\nThe Import Tables (interpreted %s section contents)\n"), 1383 section->name); 1384 fprintf (file, 1385 _("\ 1386 vma: Hint Time Forward DLL First\n\ 1387 Table Stamp Chain Name Thunk\n")); 1388 1389 /* Read the whole section. Some of the fields might be before dataoff. */ 1390 if (!bfd_malloc_and_get_section (abfd, section, &data)) 1391 { 1392 if (data != NULL) 1393 free (data); 1394 return FALSE; 1395 } 1396 1397 adj = section->vma - extra->ImageBase; 1398 1399 /* Print all image import descriptors. */ 1400 for (i = dataoff; i + onaline <= datasize; i += onaline) 1401 { 1402 bfd_vma hint_addr; 1403 bfd_vma time_stamp; 1404 bfd_vma forward_chain; 1405 bfd_vma dll_name; 1406 bfd_vma first_thunk; 1407 int idx = 0; 1408 bfd_size_type j; 1409 char *dll; 1410 1411 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */ 1412 fprintf (file, " %08lx\t", (unsigned long) (i + adj)); 1413 hint_addr = bfd_get_32 (abfd, data + i); 1414 time_stamp = bfd_get_32 (abfd, data + i + 4); 1415 forward_chain = bfd_get_32 (abfd, data + i + 8); 1416 dll_name = bfd_get_32 (abfd, data + i + 12); 1417 first_thunk = bfd_get_32 (abfd, data + i + 16); 1418 1419 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n", 1420 (unsigned long) hint_addr, 1421 (unsigned long) time_stamp, 1422 (unsigned long) forward_chain, 1423 (unsigned long) dll_name, 1424 (unsigned long) first_thunk); 1425 1426 if (hint_addr == 0 && first_thunk == 0) 1427 break; 1428 1429 if (dll_name - adj >= section->size) 1430 break; 1431 1432 dll = (char *) data + dll_name - adj; 1433 /* PR 17512 file: 078-12277-0.004. */ 1434 bfd_size_type maxlen = (char *)(data + datasize) - dll - 1; 1435 fprintf (file, _("\n\tDLL Name: %.*s\n"), (int) maxlen, dll); 1436 1437 /* PR 21546: When the Hint Address is zero, 1438 we try the First Thunk instead. */ 1439 if (hint_addr == 0) 1440 hint_addr = first_thunk; 1441 1442 if (hint_addr != 0 && hint_addr - adj < datasize) 1443 { 1444 bfd_byte *ft_data; 1445 asection *ft_section; 1446 bfd_vma ft_addr; 1447 bfd_size_type ft_datasize; 1448 int ft_idx; 1449 int ft_allocated; 1450 1451 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n")); 1452 1453 idx = hint_addr - adj; 1454 1455 ft_addr = first_thunk + extra->ImageBase; 1456 ft_idx = first_thunk - adj; 1457 ft_data = data + ft_idx; 1458 ft_datasize = datasize - ft_idx; 1459 ft_allocated = 0; 1460 1461 if (first_thunk != hint_addr) 1462 { 1463 /* Find the section which contains the first thunk. */ 1464 for (ft_section = abfd->sections; 1465 ft_section != NULL; 1466 ft_section = ft_section->next) 1467 { 1468 if (ft_addr >= ft_section->vma 1469 && ft_addr < ft_section->vma + ft_section->size) 1470 break; 1471 } 1472 1473 if (ft_section == NULL) 1474 { 1475 fprintf (file, 1476 _("\nThere is a first thunk, but the section containing it could not be found\n")); 1477 continue; 1478 } 1479 1480 /* Now check to see if this section is the same as our current 1481 section. If it is not then we will have to load its data in. */ 1482 if (ft_section != section) 1483 { 1484 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase); 1485 ft_datasize = ft_section->size - ft_idx; 1486 ft_data = (bfd_byte *) bfd_malloc (ft_datasize); 1487 if (ft_data == NULL) 1488 continue; 1489 1490 /* Read ft_datasize bytes starting at offset ft_idx. */ 1491 if (!bfd_get_section_contents (abfd, ft_section, ft_data, 1492 (bfd_vma) ft_idx, ft_datasize)) 1493 { 1494 free (ft_data); 1495 continue; 1496 } 1497 ft_allocated = 1; 1498 } 1499 } 1500 1501 /* Print HintName vector entries. */ 1502 #ifdef COFF_WITH_pex64 1503 for (j = 0; idx + j + 8 <= datasize; j += 8) 1504 { 1505 bfd_size_type amt; 1506 unsigned long member = bfd_get_32 (abfd, data + idx + j); 1507 unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4); 1508 1509 if (!member && !member_high) 1510 break; 1511 1512 amt = member - adj; 1513 1514 if (HighBitSet (member_high)) 1515 fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>", 1516 member_high, member, 1517 WithoutHighBit (member_high), member); 1518 /* PR binutils/17512: Handle corrupt PE data. */ 1519 else if (amt >= datasize || amt + 2 >= datasize) 1520 fprintf (file, _("\t<corrupt: 0x%04lx>"), member); 1521 else 1522 { 1523 int ordinal; 1524 char *member_name; 1525 1526 ordinal = bfd_get_16 (abfd, data + amt); 1527 member_name = (char *) data + amt + 2; 1528 fprintf (file, "\t%04lx\t %4d %.*s",member, ordinal, 1529 (int) (datasize - (amt + 2)), member_name); 1530 } 1531 1532 /* If the time stamp is not zero, the import address 1533 table holds actual addresses. */ 1534 if (time_stamp != 0 1535 && first_thunk != 0 1536 && first_thunk != hint_addr 1537 && j + 4 <= ft_datasize) 1538 fprintf (file, "\t%04lx", 1539 (unsigned long) bfd_get_32 (abfd, ft_data + j)); 1540 fprintf (file, "\n"); 1541 } 1542 #else 1543 for (j = 0; idx + j + 4 <= datasize; j += 4) 1544 { 1545 bfd_size_type amt; 1546 unsigned long member = bfd_get_32 (abfd, data + idx + j); 1547 1548 /* Print single IMAGE_IMPORT_BY_NAME vector. */ 1549 if (member == 0) 1550 break; 1551 1552 amt = member - adj; 1553 1554 if (HighBitSet (member)) 1555 fprintf (file, "\t%04lx\t %4lu <none>", 1556 member, WithoutHighBit (member)); 1557 /* PR binutils/17512: Handle corrupt PE data. */ 1558 else if (amt >= datasize || amt + 2 >= datasize) 1559 fprintf (file, _("\t<corrupt: 0x%04lx>"), member); 1560 else 1561 { 1562 int ordinal; 1563 char *member_name; 1564 1565 ordinal = bfd_get_16 (abfd, data + amt); 1566 member_name = (char *) data + amt + 2; 1567 fprintf (file, "\t%04lx\t %4d %.*s", 1568 member, ordinal, 1569 (int) (datasize - (amt + 2)), member_name); 1570 } 1571 1572 /* If the time stamp is not zero, the import address 1573 table holds actual addresses. */ 1574 if (time_stamp != 0 1575 && first_thunk != 0 1576 && first_thunk != hint_addr 1577 && j + 4 <= ft_datasize) 1578 fprintf (file, "\t%04lx", 1579 (unsigned long) bfd_get_32 (abfd, ft_data + j)); 1580 1581 fprintf (file, "\n"); 1582 } 1583 #endif 1584 if (ft_allocated) 1585 free (ft_data); 1586 } 1587 1588 fprintf (file, "\n"); 1589 } 1590 1591 free (data); 1592 1593 return TRUE; 1594 } 1595 1596 static bfd_boolean 1597 pe_print_edata (bfd * abfd, void * vfile) 1598 { 1599 FILE *file = (FILE *) vfile; 1600 bfd_byte *data; 1601 asection *section; 1602 bfd_size_type datasize = 0; 1603 bfd_size_type dataoff; 1604 bfd_size_type i; 1605 bfd_vma adj; 1606 struct EDT_type 1607 { 1608 long export_flags; /* Reserved - should be zero. */ 1609 long time_stamp; 1610 short major_ver; 1611 short minor_ver; 1612 bfd_vma name; /* RVA - relative to image base. */ 1613 long base; /* Ordinal base. */ 1614 unsigned long num_functions;/* Number in the export address table. */ 1615 unsigned long num_names; /* Number in the name pointer table. */ 1616 bfd_vma eat_addr; /* RVA to the export address table. */ 1617 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */ 1618 bfd_vma ot_addr; /* RVA to the Ordinal Table. */ 1619 } edt; 1620 1621 pe_data_type *pe = pe_data (abfd); 1622 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr; 1623 1624 bfd_vma addr; 1625 1626 addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress; 1627 1628 if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0) 1629 { 1630 /* Maybe the extra header isn't there. Look for the section. */ 1631 section = bfd_get_section_by_name (abfd, ".edata"); 1632 if (section == NULL) 1633 return TRUE; 1634 1635 addr = section->vma; 1636 dataoff = 0; 1637 datasize = section->size; 1638 if (datasize == 0) 1639 return TRUE; 1640 } 1641 else 1642 { 1643 addr += extra->ImageBase; 1644 1645 for (section = abfd->sections; section != NULL; section = section->next) 1646 if (addr >= section->vma && addr < section->vma + section->size) 1647 break; 1648 1649 if (section == NULL) 1650 { 1651 fprintf (file, 1652 _("\nThere is an export table, but the section containing it could not be found\n")); 1653 return TRUE; 1654 } 1655 else if (!(section->flags & SEC_HAS_CONTENTS)) 1656 { 1657 fprintf (file, 1658 _("\nThere is an export table in %s, but that section has no contents\n"), 1659 section->name); 1660 return TRUE; 1661 } 1662 1663 dataoff = addr - section->vma; 1664 datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size; 1665 if (dataoff > section->size 1666 || datasize > section->size - dataoff) 1667 { 1668 fprintf (file, 1669 _("\nThere is an export table in %s, but it does not fit into that section\n"), 1670 section->name); 1671 return TRUE; 1672 } 1673 } 1674 1675 /* PR 17512: Handle corrupt PE binaries. */ 1676 if (datasize < 40) 1677 { 1678 fprintf (file, 1679 /* xgettext:c-format */ 1680 _("\nThere is an export table in %s, but it is too small (%d)\n"), 1681 section->name, (int) datasize); 1682 return TRUE; 1683 } 1684 1685 /* xgettext:c-format */ 1686 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"), 1687 section->name, (unsigned long) addr); 1688 1689 data = (bfd_byte *) bfd_malloc (datasize); 1690 if (data == NULL) 1691 return FALSE; 1692 1693 if (! bfd_get_section_contents (abfd, section, data, 1694 (file_ptr) dataoff, datasize)) 1695 return FALSE; 1696 1697 /* Go get Export Directory Table. */ 1698 edt.export_flags = bfd_get_32 (abfd, data + 0); 1699 edt.time_stamp = bfd_get_32 (abfd, data + 4); 1700 edt.major_ver = bfd_get_16 (abfd, data + 8); 1701 edt.minor_ver = bfd_get_16 (abfd, data + 10); 1702 edt.name = bfd_get_32 (abfd, data + 12); 1703 edt.base = bfd_get_32 (abfd, data + 16); 1704 edt.num_functions = bfd_get_32 (abfd, data + 20); 1705 edt.num_names = bfd_get_32 (abfd, data + 24); 1706 edt.eat_addr = bfd_get_32 (abfd, data + 28); 1707 edt.npt_addr = bfd_get_32 (abfd, data + 32); 1708 edt.ot_addr = bfd_get_32 (abfd, data + 36); 1709 1710 adj = section->vma - extra->ImageBase + dataoff; 1711 1712 /* Dump the EDT first. */ 1713 fprintf (file, 1714 _("\nThe Export Tables (interpreted %s section contents)\n\n"), 1715 section->name); 1716 1717 fprintf (file, 1718 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags); 1719 1720 fprintf (file, 1721 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp); 1722 1723 fprintf (file, 1724 /* xgettext:c-format */ 1725 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver); 1726 1727 fprintf (file, 1728 _("Name \t\t\t\t")); 1729 bfd_fprintf_vma (abfd, file, edt.name); 1730 1731 if ((edt.name >= adj) && (edt.name < adj + datasize)) 1732 fprintf (file, " %.*s\n", 1733 (int) (datasize - (edt.name - adj)), 1734 data + edt.name - adj); 1735 else 1736 fprintf (file, "(outside .edata section)\n"); 1737 1738 fprintf (file, 1739 _("Ordinal Base \t\t\t%ld\n"), edt.base); 1740 1741 fprintf (file, 1742 _("Number in:\n")); 1743 1744 fprintf (file, 1745 _("\tExport Address Table \t\t%08lx\n"), 1746 edt.num_functions); 1747 1748 fprintf (file, 1749 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names); 1750 1751 fprintf (file, 1752 _("Table Addresses\n")); 1753 1754 fprintf (file, 1755 _("\tExport Address Table \t\t")); 1756 bfd_fprintf_vma (abfd, file, edt.eat_addr); 1757 fprintf (file, "\n"); 1758 1759 fprintf (file, 1760 _("\tName Pointer Table \t\t")); 1761 bfd_fprintf_vma (abfd, file, edt.npt_addr); 1762 fprintf (file, "\n"); 1763 1764 fprintf (file, 1765 _("\tOrdinal Table \t\t\t")); 1766 bfd_fprintf_vma (abfd, file, edt.ot_addr); 1767 fprintf (file, "\n"); 1768 1769 /* The next table to find is the Export Address Table. It's basically 1770 a list of pointers that either locate a function in this dll, or 1771 forward the call to another dll. Something like: 1772 typedef union 1773 { 1774 long export_rva; 1775 long forwarder_rva; 1776 } export_address_table_entry; */ 1777 1778 fprintf (file, 1779 _("\nExport Address Table -- Ordinal Base %ld\n"), 1780 edt.base); 1781 1782 /* PR 17512: Handle corrupt PE binaries. */ 1783 /* PR 17512 file: 140-165018-0.004. */ 1784 if (edt.eat_addr - adj >= datasize 1785 /* PR 17512: file: 092b1829 */ 1786 || (edt.num_functions + 1) * 4 < edt.num_functions 1787 || edt.eat_addr - adj + (edt.num_functions + 1) * 4 > datasize) 1788 fprintf (file, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"), 1789 (long) edt.eat_addr, 1790 (long) edt.num_functions); 1791 else for (i = 0; i < edt.num_functions; ++i) 1792 { 1793 bfd_vma eat_member = bfd_get_32 (abfd, 1794 data + edt.eat_addr + (i * 4) - adj); 1795 if (eat_member == 0) 1796 continue; 1797 1798 if (eat_member - adj <= datasize) 1799 { 1800 /* This rva is to a name (forwarding function) in our section. */ 1801 /* Should locate a function descriptor. */ 1802 fprintf (file, 1803 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n", 1804 (long) i, 1805 (long) (i + edt.base), 1806 (unsigned long) eat_member, 1807 _("Forwarder RVA"), 1808 (int)(datasize - (eat_member - adj)), 1809 data + eat_member - adj); 1810 } 1811 else 1812 { 1813 /* Should locate a function descriptor in the reldata section. */ 1814 fprintf (file, 1815 "\t[%4ld] +base[%4ld] %04lx %s\n", 1816 (long) i, 1817 (long) (i + edt.base), 1818 (unsigned long) eat_member, 1819 _("Export RVA")); 1820 } 1821 } 1822 1823 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */ 1824 /* Dump them in parallel for clarity. */ 1825 fprintf (file, 1826 _("\n[Ordinal/Name Pointer] Table\n")); 1827 1828 /* PR 17512: Handle corrupt PE binaries. */ 1829 if (edt.npt_addr + (edt.num_names * 4) - adj >= datasize 1830 /* PR 17512: file: bb68816e. */ 1831 || edt.num_names * 4 < edt.num_names 1832 || (data + edt.npt_addr - adj) < data) 1833 /* xgettext:c-format */ 1834 fprintf (file, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"), 1835 (long) edt.npt_addr, 1836 (long) edt.num_names); 1837 /* PR 17512: file: 140-147171-0.004. */ 1838 else if (edt.ot_addr + (edt.num_names * 2) - adj >= datasize 1839 || data + edt.ot_addr - adj < data) 1840 /* xgettext:c-format */ 1841 fprintf (file, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"), 1842 (long) edt.ot_addr, 1843 (long) edt.num_names); 1844 else for (i = 0; i < edt.num_names; ++i) 1845 { 1846 bfd_vma name_ptr; 1847 bfd_vma ord; 1848 1849 ord = bfd_get_16 (abfd, data + edt.ot_addr + (i * 2) - adj); 1850 name_ptr = bfd_get_32 (abfd, data + edt.npt_addr + (i * 4) - adj); 1851 1852 if ((name_ptr - adj) >= datasize) 1853 { 1854 /* xgettext:c-format */ 1855 fprintf (file, _("\t[%4ld] <corrupt offset: %lx>\n"), 1856 (long) ord, (long) name_ptr); 1857 } 1858 else 1859 { 1860 char * name = (char *) data + name_ptr - adj; 1861 1862 fprintf (file, "\t[%4ld] %.*s\n", (long) ord, 1863 (int)((char *)(data + datasize) - name), name); 1864 } 1865 } 1866 1867 free (data); 1868 1869 return TRUE; 1870 } 1871 1872 /* This really is architecture dependent. On IA-64, a .pdata entry 1873 consists of three dwords containing relative virtual addresses that 1874 specify the start and end address of the code range the entry 1875 covers and the address of the corresponding unwind info data. 1876 1877 On ARM and SH-4, a compressed PDATA structure is used : 1878 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use 1879 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY. 1880 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx . 1881 1882 This is the version for uncompressed data. */ 1883 1884 static bfd_boolean 1885 pe_print_pdata (bfd * abfd, void * vfile) 1886 { 1887 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 1888 # define PDATA_ROW_SIZE (3 * 8) 1889 #else 1890 # define PDATA_ROW_SIZE (5 * 4) 1891 #endif 1892 FILE *file = (FILE *) vfile; 1893 bfd_byte *data = 0; 1894 asection *section = bfd_get_section_by_name (abfd, ".pdata"); 1895 bfd_size_type datasize = 0; 1896 bfd_size_type i; 1897 bfd_size_type start, stop; 1898 int onaline = PDATA_ROW_SIZE; 1899 1900 if (section == NULL 1901 || coff_section_data (abfd, section) == NULL 1902 || pei_section_data (abfd, section) == NULL) 1903 return TRUE; 1904 1905 stop = pei_section_data (abfd, section)->virt_size; 1906 if ((stop % onaline) != 0) 1907 fprintf (file, 1908 /* xgettext:c-format */ 1909 _("warning, .pdata section size (%ld) is not a multiple of %d\n"), 1910 (long) stop, onaline); 1911 1912 fprintf (file, 1913 _("\nThe Function Table (interpreted .pdata section contents)\n")); 1914 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 1915 fprintf (file, 1916 _(" vma:\t\t\tBegin Address End Address Unwind Info\n")); 1917 #else 1918 fprintf (file, _("\ 1919 vma:\t\tBegin End EH EH PrologEnd Exception\n\ 1920 \t\tAddress Address Handler Data Address Mask\n")); 1921 #endif 1922 1923 datasize = section->size; 1924 if (datasize == 0) 1925 return TRUE; 1926 1927 /* PR 17512: file: 002-193900-0.004. */ 1928 if (datasize < stop) 1929 { 1930 /* xgettext:c-format */ 1931 fprintf (file, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"), 1932 (long) stop, (long) datasize); 1933 return FALSE; 1934 } 1935 1936 if (! bfd_malloc_and_get_section (abfd, section, &data)) 1937 { 1938 if (data != NULL) 1939 free (data); 1940 return FALSE; 1941 } 1942 1943 start = 0; 1944 1945 for (i = start; i < stop; i += onaline) 1946 { 1947 bfd_vma begin_addr; 1948 bfd_vma end_addr; 1949 bfd_vma eh_handler; 1950 bfd_vma eh_data; 1951 bfd_vma prolog_end_addr; 1952 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) 1953 int em_data; 1954 #endif 1955 1956 if (i + PDATA_ROW_SIZE > stop) 1957 break; 1958 1959 begin_addr = GET_PDATA_ENTRY (abfd, data + i ); 1960 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4); 1961 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8); 1962 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12); 1963 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16); 1964 1965 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0 1966 && eh_data == 0 && prolog_end_addr == 0) 1967 /* We are probably into the padding of the section now. */ 1968 break; 1969 1970 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) 1971 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3); 1972 #endif 1973 eh_handler &= ~(bfd_vma) 0x3; 1974 prolog_end_addr &= ~(bfd_vma) 0x3; 1975 1976 fputc (' ', file); 1977 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file); 1978 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file); 1979 bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file); 1980 bfd_fprintf_vma (abfd, file, eh_handler); 1981 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) 1982 fputc (' ', file); 1983 bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file); 1984 bfd_fprintf_vma (abfd, file, prolog_end_addr); 1985 fprintf (file, " %x", em_data); 1986 #endif 1987 1988 #ifdef POWERPC_LE_PE 1989 if (eh_handler == 0 && eh_data != 0) 1990 { 1991 /* Special bits here, although the meaning may be a little 1992 mysterious. The only one I know for sure is 0x03 1993 Code Significance 1994 0x00 None 1995 0x01 Register Save Millicode 1996 0x02 Register Restore Millicode 1997 0x03 Glue Code Sequence. */ 1998 switch (eh_data) 1999 { 2000 case 0x01: 2001 fprintf (file, _(" Register save millicode")); 2002 break; 2003 case 0x02: 2004 fprintf (file, _(" Register restore millicode")); 2005 break; 2006 case 0x03: 2007 fprintf (file, _(" Glue code sequence")); 2008 break; 2009 default: 2010 break; 2011 } 2012 } 2013 #endif 2014 fprintf (file, "\n"); 2015 } 2016 2017 free (data); 2018 2019 return TRUE; 2020 #undef PDATA_ROW_SIZE 2021 } 2022 2023 typedef struct sym_cache 2024 { 2025 int symcount; 2026 asymbol ** syms; 2027 } sym_cache; 2028 2029 static asymbol ** 2030 slurp_symtab (bfd *abfd, sym_cache *psc) 2031 { 2032 asymbol ** sy = NULL; 2033 long storage; 2034 2035 if (!(bfd_get_file_flags (abfd) & HAS_SYMS)) 2036 { 2037 psc->symcount = 0; 2038 return NULL; 2039 } 2040 2041 storage = bfd_get_symtab_upper_bound (abfd); 2042 if (storage < 0) 2043 return NULL; 2044 if (storage) 2045 { 2046 sy = (asymbol **) bfd_malloc (storage); 2047 if (sy == NULL) 2048 return NULL; 2049 } 2050 2051 psc->symcount = bfd_canonicalize_symtab (abfd, sy); 2052 if (psc->symcount < 0) 2053 return NULL; 2054 return sy; 2055 } 2056 2057 static const char * 2058 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc) 2059 { 2060 int i; 2061 2062 if (psc->syms == 0) 2063 psc->syms = slurp_symtab (abfd, psc); 2064 2065 for (i = 0; i < psc->symcount; i++) 2066 { 2067 if (psc->syms[i]->section->vma + psc->syms[i]->value == func) 2068 return psc->syms[i]->name; 2069 } 2070 2071 return NULL; 2072 } 2073 2074 static void 2075 cleanup_syms (sym_cache *psc) 2076 { 2077 psc->symcount = 0; 2078 free (psc->syms); 2079 psc->syms = NULL; 2080 } 2081 2082 /* This is the version for "compressed" pdata. */ 2083 2084 bfd_boolean 2085 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile) 2086 { 2087 # define PDATA_ROW_SIZE (2 * 4) 2088 FILE *file = (FILE *) vfile; 2089 bfd_byte *data = NULL; 2090 asection *section = bfd_get_section_by_name (abfd, ".pdata"); 2091 bfd_size_type datasize = 0; 2092 bfd_size_type i; 2093 bfd_size_type start, stop; 2094 int onaline = PDATA_ROW_SIZE; 2095 struct sym_cache cache = {0, 0} ; 2096 2097 if (section == NULL 2098 || coff_section_data (abfd, section) == NULL 2099 || pei_section_data (abfd, section) == NULL) 2100 return TRUE; 2101 2102 stop = pei_section_data (abfd, section)->virt_size; 2103 if ((stop % onaline) != 0) 2104 fprintf (file, 2105 /* xgettext:c-format */ 2106 _("warning, .pdata section size (%ld) is not a multiple of %d\n"), 2107 (long) stop, onaline); 2108 2109 fprintf (file, 2110 _("\nThe Function Table (interpreted .pdata section contents)\n")); 2111 2112 fprintf (file, _("\ 2113 vma:\t\tBegin Prolog Function Flags Exception EH\n\ 2114 \t\tAddress Length Length 32b exc Handler Data\n")); 2115 2116 datasize = section->size; 2117 if (datasize == 0) 2118 return TRUE; 2119 2120 if (! bfd_malloc_and_get_section (abfd, section, &data)) 2121 { 2122 if (data != NULL) 2123 free (data); 2124 return FALSE; 2125 } 2126 2127 start = 0; 2128 2129 for (i = start; i < stop; i += onaline) 2130 { 2131 bfd_vma begin_addr; 2132 bfd_vma other_data; 2133 bfd_vma prolog_length, function_length; 2134 int flag32bit, exception_flag; 2135 asection *tsection; 2136 2137 if (i + PDATA_ROW_SIZE > stop) 2138 break; 2139 2140 begin_addr = GET_PDATA_ENTRY (abfd, data + i ); 2141 other_data = GET_PDATA_ENTRY (abfd, data + i + 4); 2142 2143 if (begin_addr == 0 && other_data == 0) 2144 /* We are probably into the padding of the section now. */ 2145 break; 2146 2147 prolog_length = (other_data & 0x000000FF); 2148 function_length = (other_data & 0x3FFFFF00) >> 8; 2149 flag32bit = (int)((other_data & 0x40000000) >> 30); 2150 exception_flag = (int)((other_data & 0x80000000) >> 31); 2151 2152 fputc (' ', file); 2153 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file); 2154 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file); 2155 bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file); 2156 bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file); 2157 fprintf (file, "%2d %2d ", flag32bit, exception_flag); 2158 2159 /* Get the exception handler's address and the data passed from the 2160 .text section. This is really the data that belongs with the .pdata 2161 but got "compressed" out for the ARM and SH4 architectures. */ 2162 tsection = bfd_get_section_by_name (abfd, ".text"); 2163 if (tsection && coff_section_data (abfd, tsection) 2164 && pei_section_data (abfd, tsection)) 2165 { 2166 bfd_vma eh_off = (begin_addr - 8) - tsection->vma; 2167 bfd_byte *tdata; 2168 2169 tdata = (bfd_byte *) bfd_malloc (8); 2170 if (tdata) 2171 { 2172 if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8)) 2173 { 2174 bfd_vma eh, eh_data; 2175 2176 eh = bfd_get_32 (abfd, tdata); 2177 eh_data = bfd_get_32 (abfd, tdata + 4); 2178 fprintf (file, "%08x ", (unsigned int) eh); 2179 fprintf (file, "%08x", (unsigned int) eh_data); 2180 if (eh != 0) 2181 { 2182 const char *s = my_symbol_for_address (abfd, eh, &cache); 2183 2184 if (s) 2185 fprintf (file, " (%s) ", s); 2186 } 2187 } 2188 free (tdata); 2189 } 2190 } 2191 2192 fprintf (file, "\n"); 2193 } 2194 2195 free (data); 2196 2197 cleanup_syms (& cache); 2198 2199 return TRUE; 2200 #undef PDATA_ROW_SIZE 2201 } 2202 2203 2204 #define IMAGE_REL_BASED_HIGHADJ 4 2205 static const char * const tbl[] = 2206 { 2207 "ABSOLUTE", 2208 "HIGH", 2209 "LOW", 2210 "HIGHLOW", 2211 "HIGHADJ", 2212 "MIPS_JMPADDR", 2213 "SECTION", 2214 "REL32", 2215 "RESERVED1", 2216 "MIPS_JMPADDR16", 2217 "DIR64", 2218 "HIGH3ADJ", 2219 "UNKNOWN", /* MUST be last. */ 2220 }; 2221 2222 static bfd_boolean 2223 pe_print_reloc (bfd * abfd, void * vfile) 2224 { 2225 FILE *file = (FILE *) vfile; 2226 bfd_byte *data = 0; 2227 asection *section = bfd_get_section_by_name (abfd, ".reloc"); 2228 bfd_byte *p, *end; 2229 2230 if (section == NULL || section->size == 0 || !(section->flags & SEC_HAS_CONTENTS)) 2231 return TRUE; 2232 2233 fprintf (file, 2234 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n")); 2235 2236 if (! bfd_malloc_and_get_section (abfd, section, &data)) 2237 { 2238 if (data != NULL) 2239 free (data); 2240 return FALSE; 2241 } 2242 2243 p = data; 2244 end = data + section->size; 2245 while (p + 8 <= end) 2246 { 2247 int j; 2248 bfd_vma virtual_address; 2249 unsigned long number, size; 2250 bfd_byte *chunk_end; 2251 2252 /* The .reloc section is a sequence of blocks, with a header consisting 2253 of two 32 bit quantities, followed by a number of 16 bit entries. */ 2254 virtual_address = bfd_get_32 (abfd, p); 2255 size = bfd_get_32 (abfd, p + 4); 2256 p += 8; 2257 number = (size - 8) / 2; 2258 2259 if (size == 0) 2260 break; 2261 2262 fprintf (file, 2263 /* xgettext:c-format */ 2264 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"), 2265 (unsigned long) virtual_address, size, size, number); 2266 2267 chunk_end = p - 8 + size; 2268 if (chunk_end > end) 2269 chunk_end = end; 2270 j = 0; 2271 while (p + 2 <= chunk_end) 2272 { 2273 unsigned short e = bfd_get_16 (abfd, p); 2274 unsigned int t = (e & 0xF000) >> 12; 2275 int off = e & 0x0FFF; 2276 2277 if (t >= sizeof (tbl) / sizeof (tbl[0])) 2278 t = (sizeof (tbl) / sizeof (tbl[0])) - 1; 2279 2280 fprintf (file, 2281 /* xgettext:c-format */ 2282 _("\treloc %4d offset %4x [%4lx] %s"), 2283 j, off, (unsigned long) (off + virtual_address), tbl[t]); 2284 2285 p += 2; 2286 j++; 2287 2288 /* HIGHADJ takes an argument, - the next record *is* the 2289 low 16 bits of addend. */ 2290 if (t == IMAGE_REL_BASED_HIGHADJ && p + 2 <= chunk_end) 2291 { 2292 fprintf (file, " (%4x)", (unsigned int) bfd_get_16 (abfd, p)); 2293 p += 2; 2294 j++; 2295 } 2296 2297 fprintf (file, "\n"); 2298 } 2299 } 2300 2301 free (data); 2302 2303 return TRUE; 2304 } 2305 2306 /* A data structure describing the regions of a .rsrc section. 2307 Some fields are filled in as the section is parsed. */ 2308 2309 typedef struct rsrc_regions 2310 { 2311 bfd_byte * section_start; 2312 bfd_byte * section_end; 2313 bfd_byte * strings_start; 2314 bfd_byte * resource_start; 2315 } rsrc_regions; 2316 2317 static bfd_byte * 2318 rsrc_print_resource_directory (FILE * , bfd *, unsigned int, bfd_byte *, 2319 rsrc_regions *, bfd_vma); 2320 2321 /* Print the resource entry at DATA, with the text indented by INDENT. 2322 Recusively calls rsrc_print_resource_directory to print the contents 2323 of directory entries. 2324 Returns the address of the end of the data associated with the entry 2325 or section_end + 1 upon failure. */ 2326 2327 static bfd_byte * 2328 rsrc_print_resource_entries (FILE * file, 2329 bfd * abfd, 2330 unsigned int indent, 2331 bfd_boolean is_name, 2332 bfd_byte * data, 2333 rsrc_regions * regions, 2334 bfd_vma rva_bias) 2335 { 2336 unsigned long entry, addr, size; 2337 bfd_byte * leaf; 2338 2339 if (data + 8 >= regions->section_end) 2340 return regions->section_end + 1; 2341 2342 /* xgettext:c-format */ 2343 fprintf (file, _("%03x %*.s Entry: "), (int)(data - regions->section_start), indent, " "); 2344 2345 entry = (unsigned long) bfd_get_32 (abfd, data); 2346 if (is_name) 2347 { 2348 bfd_byte * name; 2349 2350 /* Note - the documentation says that this field is an RVA value 2351 but windres appears to produce a section relative offset with 2352 the top bit set. Support both styles for now. */ 2353 if (HighBitSet (entry)) 2354 name = regions->section_start + WithoutHighBit (entry); 2355 else 2356 name = regions->section_start + entry - rva_bias; 2357 2358 if (name + 2 < regions->section_end && name > regions->section_start) 2359 { 2360 unsigned int len; 2361 2362 if (regions->strings_start == NULL) 2363 regions->strings_start = name; 2364 2365 len = bfd_get_16 (abfd, name); 2366 2367 fprintf (file, _("name: [val: %08lx len %d]: "), entry, len); 2368 2369 if (name + 2 + len * 2 < regions->section_end) 2370 { 2371 /* This strange loop is to cope with multibyte characters. */ 2372 while (len --) 2373 { 2374 char c; 2375 2376 name += 2; 2377 c = * name; 2378 /* Avoid printing control characters. */ 2379 if (c > 0 && c < 32) 2380 fprintf (file, "^%c", c + 64); 2381 else 2382 fprintf (file, "%.1s", name); 2383 } 2384 } 2385 else 2386 { 2387 fprintf (file, _("<corrupt string length: %#x>\n"), len); 2388 /* PR binutils/17512: Do not try to continue decoding a 2389 corrupted resource section. It is likely to end up with 2390 reams of extraneous output. FIXME: We could probably 2391 continue if we disable the printing of strings... */ 2392 return regions->section_end + 1; 2393 } 2394 } 2395 else 2396 { 2397 fprintf (file, _("<corrupt string offset: %#lx>\n"), entry); 2398 return regions->section_end + 1; 2399 } 2400 } 2401 else 2402 fprintf (file, _("ID: %#08lx"), entry); 2403 2404 entry = (long) bfd_get_32 (abfd, data + 4); 2405 fprintf (file, _(", Value: %#08lx\n"), entry); 2406 2407 if (HighBitSet (entry)) 2408 { 2409 data = regions->section_start + WithoutHighBit (entry); 2410 if (data <= regions->section_start || data > regions->section_end) 2411 return regions->section_end + 1; 2412 2413 /* FIXME: PR binutils/17512: A corrupt file could contain a loop 2414 in the resource table. We need some way to detect this. */ 2415 return rsrc_print_resource_directory (file, abfd, indent + 1, data, 2416 regions, rva_bias); 2417 } 2418 2419 leaf = regions->section_start + entry; 2420 2421 if (leaf + 16 >= regions->section_end 2422 /* PR 17512: file: 055dff7e. */ 2423 || leaf < regions->section_start) 2424 return regions->section_end + 1; 2425 2426 /* xgettext:c-format */ 2427 fprintf (file, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"), 2428 (int) (entry), indent, " ", 2429 addr = (long) bfd_get_32 (abfd, leaf), 2430 size = (long) bfd_get_32 (abfd, leaf + 4), 2431 (int) bfd_get_32 (abfd, leaf + 8)); 2432 2433 /* Check that the reserved entry is 0. */ 2434 if (bfd_get_32 (abfd, leaf + 12) != 0 2435 /* And that the data address/size is valid too. */ 2436 || (regions->section_start + (addr - rva_bias) + size > regions->section_end)) 2437 return regions->section_end + 1; 2438 2439 if (regions->resource_start == NULL) 2440 regions->resource_start = regions->section_start + (addr - rva_bias); 2441 2442 return regions->section_start + (addr - rva_bias) + size; 2443 } 2444 2445 #define max(a,b) ((a) > (b) ? (a) : (b)) 2446 #define min(a,b) ((a) < (b) ? (a) : (b)) 2447 2448 static bfd_byte * 2449 rsrc_print_resource_directory (FILE * file, 2450 bfd * abfd, 2451 unsigned int indent, 2452 bfd_byte * data, 2453 rsrc_regions * regions, 2454 bfd_vma rva_bias) 2455 { 2456 unsigned int num_names, num_ids; 2457 bfd_byte * highest_data = data; 2458 2459 if (data + 16 >= regions->section_end) 2460 return regions->section_end + 1; 2461 2462 fprintf (file, "%03x %*.s ", (int)(data - regions->section_start), indent, " "); 2463 switch (indent) 2464 { 2465 case 0: fprintf (file, "Type"); break; 2466 case 2: fprintf (file, "Name"); break; 2467 case 4: fprintf (file, "Language"); break; 2468 default: 2469 fprintf (file, _("<unknown directory type: %d>\n"), indent); 2470 /* FIXME: For now we end the printing here. If in the 2471 future more directory types are added to the RSRC spec 2472 then we will need to change this. */ 2473 return regions->section_end + 1; 2474 } 2475 2476 /* xgettext:c-format */ 2477 fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"), 2478 (int) bfd_get_32 (abfd, data), 2479 (long) bfd_get_32 (abfd, data + 4), 2480 (int) bfd_get_16 (abfd, data + 8), 2481 (int) bfd_get_16 (abfd, data + 10), 2482 num_names = (int) bfd_get_16 (abfd, data + 12), 2483 num_ids = (int) bfd_get_16 (abfd, data + 14)); 2484 data += 16; 2485 2486 while (num_names --) 2487 { 2488 bfd_byte * entry_end; 2489 2490 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE, 2491 data, regions, rva_bias); 2492 data += 8; 2493 highest_data = max (highest_data, entry_end); 2494 if (entry_end >= regions->section_end) 2495 return entry_end; 2496 } 2497 2498 while (num_ids --) 2499 { 2500 bfd_byte * entry_end; 2501 2502 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE, 2503 data, regions, rva_bias); 2504 data += 8; 2505 highest_data = max (highest_data, entry_end); 2506 if (entry_end >= regions->section_end) 2507 return entry_end; 2508 } 2509 2510 return max (highest_data, data); 2511 } 2512 2513 /* Display the contents of a .rsrc section. We do not try to 2514 reproduce the resources, windres does that. Instead we dump 2515 the tables in a human readable format. */ 2516 2517 static bfd_boolean 2518 rsrc_print_section (bfd * abfd, void * vfile) 2519 { 2520 bfd_vma rva_bias; 2521 pe_data_type * pe; 2522 FILE * file = (FILE *) vfile; 2523 bfd_size_type datasize; 2524 asection * section; 2525 bfd_byte * data; 2526 rsrc_regions regions; 2527 2528 pe = pe_data (abfd); 2529 if (pe == NULL) 2530 return TRUE; 2531 2532 section = bfd_get_section_by_name (abfd, ".rsrc"); 2533 if (section == NULL) 2534 return TRUE; 2535 if (!(section->flags & SEC_HAS_CONTENTS)) 2536 return TRUE; 2537 2538 datasize = section->size; 2539 if (datasize == 0) 2540 return TRUE; 2541 2542 rva_bias = section->vma - pe->pe_opthdr.ImageBase; 2543 2544 if (! bfd_malloc_and_get_section (abfd, section, & data)) 2545 { 2546 if (data != NULL) 2547 free (data); 2548 return FALSE; 2549 } 2550 2551 regions.section_start = data; 2552 regions.section_end = data + datasize; 2553 regions.strings_start = NULL; 2554 regions.resource_start = NULL; 2555 2556 fflush (file); 2557 fprintf (file, "\nThe .rsrc Resource Directory section:\n"); 2558 2559 while (data < regions.section_end) 2560 { 2561 bfd_byte * p = data; 2562 2563 data = rsrc_print_resource_directory (file, abfd, 0, data, & regions, rva_bias); 2564 2565 if (data == regions.section_end + 1) 2566 fprintf (file, _("Corrupt .rsrc section detected!\n")); 2567 else 2568 { 2569 /* Align data before continuing. */ 2570 int align = (1 << section->alignment_power) - 1; 2571 2572 data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align); 2573 rva_bias += data - p; 2574 2575 /* For reasons that are unclear .rsrc sections are sometimes created 2576 aligned to a 1^3 boundary even when their alignment is set at 2577 1^2. Catch that case here before we issue a spurious warning 2578 message. */ 2579 if (data == (regions.section_end - 4)) 2580 data = regions.section_end; 2581 else if (data < regions.section_end) 2582 { 2583 /* If the extra data is all zeros then do not complain. 2584 This is just padding so that the section meets the 2585 page size requirements. */ 2586 while (++ data < regions.section_end) 2587 if (*data != 0) 2588 break; 2589 if (data < regions.section_end) 2590 fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n")); 2591 } 2592 } 2593 } 2594 2595 if (regions.strings_start != NULL) 2596 fprintf (file, _(" String table starts at offset: %#03x\n"), 2597 (int) (regions.strings_start - regions.section_start)); 2598 if (regions.resource_start != NULL) 2599 fprintf (file, _(" Resources start at offset: %#03x\n"), 2600 (int) (regions.resource_start - regions.section_start)); 2601 2602 free (regions.section_start); 2603 return TRUE; 2604 } 2605 2606 #define IMAGE_NUMBEROF_DEBUG_TYPES 12 2607 2608 static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] = 2609 { 2610 "Unknown", 2611 "COFF", 2612 "CodeView", 2613 "FPO", 2614 "Misc", 2615 "Exception", 2616 "Fixup", 2617 "OMAP-to-SRC", 2618 "OMAP-from-SRC", 2619 "Borland", 2620 "Reserved", 2621 "CLSID", 2622 }; 2623 2624 static bfd_boolean 2625 pe_print_debugdata (bfd * abfd, void * vfile) 2626 { 2627 FILE *file = (FILE *) vfile; 2628 pe_data_type *pe = pe_data (abfd); 2629 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr; 2630 asection *section; 2631 bfd_byte *data = 0; 2632 bfd_size_type dataoff; 2633 unsigned int i; 2634 2635 bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress; 2636 bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size; 2637 2638 if (size == 0) 2639 return TRUE; 2640 2641 addr += extra->ImageBase; 2642 for (section = abfd->sections; section != NULL; section = section->next) 2643 { 2644 if ((addr >= section->vma) && (addr < (section->vma + section->size))) 2645 break; 2646 } 2647 2648 if (section == NULL) 2649 { 2650 fprintf (file, 2651 _("\nThere is a debug directory, but the section containing it could not be found\n")); 2652 return TRUE; 2653 } 2654 else if (!(section->flags & SEC_HAS_CONTENTS)) 2655 { 2656 fprintf (file, 2657 _("\nThere is a debug directory in %s, but that section has no contents\n"), 2658 section->name); 2659 return TRUE; 2660 } 2661 else if (section->size < size) 2662 { 2663 fprintf (file, 2664 _("\nError: section %s contains the debug data starting address but it is too small\n"), 2665 section->name); 2666 return FALSE; 2667 } 2668 2669 fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"), 2670 section->name, (unsigned long) addr); 2671 2672 dataoff = addr - section->vma; 2673 2674 if (size > (section->size - dataoff)) 2675 { 2676 fprintf (file, _("The debug data size field in the data directory is too big for the section")); 2677 return FALSE; 2678 } 2679 2680 fprintf (file, 2681 _("Type Size Rva Offset\n")); 2682 2683 /* Read the whole section. */ 2684 if (!bfd_malloc_and_get_section (abfd, section, &data)) 2685 { 2686 if (data != NULL) 2687 free (data); 2688 return FALSE; 2689 } 2690 2691 for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++) 2692 { 2693 const char *type_name; 2694 struct external_IMAGE_DEBUG_DIRECTORY *ext 2695 = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i]; 2696 struct internal_IMAGE_DEBUG_DIRECTORY idd; 2697 2698 _bfd_XXi_swap_debugdir_in (abfd, ext, &idd); 2699 2700 if ((idd.Type) >= IMAGE_NUMBEROF_DEBUG_TYPES) 2701 type_name = debug_type_names[0]; 2702 else 2703 type_name = debug_type_names[idd.Type]; 2704 2705 fprintf (file, " %2ld %14s %08lx %08lx %08lx\n", 2706 idd.Type, type_name, idd.SizeOfData, 2707 idd.AddressOfRawData, idd.PointerToRawData); 2708 2709 if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW) 2710 { 2711 char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1]; 2712 /* PR 17512: file: 065-29434-0.001:0.1 2713 We need to use a 32-bit aligned buffer 2714 to safely read in a codeview record. */ 2715 char buffer[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO); 2716 2717 CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer; 2718 2719 /* The debug entry doesn't have to have to be in a section, 2720 in which case AddressOfRawData is 0, so always use PointerToRawData. */ 2721 if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData, 2722 idd.SizeOfData, cvinfo)) 2723 continue; 2724 2725 for (i = 0; i < cvinfo->SignatureLength; i++) 2726 sprintf (&signature[i*2], "%02x", cvinfo->Signature[i] & 0xff); 2727 2728 /* xgettext:c-format */ 2729 fprintf (file, _("(format %c%c%c%c signature %s age %ld)\n"), 2730 buffer[0], buffer[1], buffer[2], buffer[3], 2731 signature, cvinfo->Age); 2732 } 2733 } 2734 2735 if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0) 2736 fprintf (file, 2737 _("The debug directory size is not a multiple of the debug directory entry size\n")); 2738 2739 return TRUE; 2740 } 2741 2742 /* Print out the program headers. */ 2743 2744 bfd_boolean 2745 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile) 2746 { 2747 FILE *file = (FILE *) vfile; 2748 int j; 2749 pe_data_type *pe = pe_data (abfd); 2750 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr; 2751 const char *subsystem_name = NULL; 2752 const char *name; 2753 2754 /* The MS dumpbin program reportedly ands with 0xff0f before 2755 printing the characteristics field. Not sure why. No reason to 2756 emulate it here. */ 2757 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags); 2758 #undef PF 2759 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); } 2760 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped"); 2761 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable"); 2762 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped"); 2763 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped"); 2764 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware"); 2765 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian"); 2766 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words"); 2767 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed"); 2768 PF (IMAGE_FILE_SYSTEM, "system file"); 2769 PF (IMAGE_FILE_DLL, "DLL"); 2770 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian"); 2771 #undef PF 2772 2773 /* ctime implies '\n'. */ 2774 { 2775 time_t t = pe->coff.timestamp; 2776 fprintf (file, "\nTime/Date\t\t%s", ctime (&t)); 2777 } 2778 2779 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC 2780 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b 2781 #endif 2782 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC 2783 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b 2784 #endif 2785 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC 2786 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107 2787 #endif 2788 2789 switch (i->Magic) 2790 { 2791 case IMAGE_NT_OPTIONAL_HDR_MAGIC: 2792 name = "PE32"; 2793 break; 2794 case IMAGE_NT_OPTIONAL_HDR64_MAGIC: 2795 name = "PE32+"; 2796 break; 2797 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC: 2798 name = "ROM"; 2799 break; 2800 default: 2801 name = NULL; 2802 break; 2803 } 2804 fprintf (file, "Magic\t\t\t%04x", i->Magic); 2805 if (name) 2806 fprintf (file, "\t(%s)",name); 2807 fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion); 2808 fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion); 2809 fprintf (file, "SizeOfCode\t\t"); 2810 bfd_fprintf_vma (abfd, file, i->SizeOfCode); 2811 fprintf (file, "\nSizeOfInitializedData\t"); 2812 bfd_fprintf_vma (abfd, file, i->SizeOfInitializedData); 2813 fprintf (file, "\nSizeOfUninitializedData\t"); 2814 bfd_fprintf_vma (abfd, file, i->SizeOfUninitializedData); 2815 fprintf (file, "\nAddressOfEntryPoint\t"); 2816 bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint); 2817 fprintf (file, "\nBaseOfCode\t\t"); 2818 bfd_fprintf_vma (abfd, file, i->BaseOfCode); 2819 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 2820 /* PE32+ does not have BaseOfData member! */ 2821 fprintf (file, "\nBaseOfData\t\t"); 2822 bfd_fprintf_vma (abfd, file, i->BaseOfData); 2823 #endif 2824 2825 fprintf (file, "\nImageBase\t\t"); 2826 bfd_fprintf_vma (abfd, file, i->ImageBase); 2827 fprintf (file, "\nSectionAlignment\t%08x\n", i->SectionAlignment); 2828 fprintf (file, "FileAlignment\t\t%08x\n", i->FileAlignment); 2829 fprintf (file, "MajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion); 2830 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion); 2831 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion); 2832 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion); 2833 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion); 2834 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion); 2835 fprintf (file, "Win32Version\t\t%08x\n", i->Reserved1); 2836 fprintf (file, "SizeOfImage\t\t%08x\n", i->SizeOfImage); 2837 fprintf (file, "SizeOfHeaders\t\t%08x\n", i->SizeOfHeaders); 2838 fprintf (file, "CheckSum\t\t%08x\n", i->CheckSum); 2839 2840 switch (i->Subsystem) 2841 { 2842 case IMAGE_SUBSYSTEM_UNKNOWN: 2843 subsystem_name = "unspecified"; 2844 break; 2845 case IMAGE_SUBSYSTEM_NATIVE: 2846 subsystem_name = "NT native"; 2847 break; 2848 case IMAGE_SUBSYSTEM_WINDOWS_GUI: 2849 subsystem_name = "Windows GUI"; 2850 break; 2851 case IMAGE_SUBSYSTEM_WINDOWS_CUI: 2852 subsystem_name = "Windows CUI"; 2853 break; 2854 case IMAGE_SUBSYSTEM_POSIX_CUI: 2855 subsystem_name = "POSIX CUI"; 2856 break; 2857 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI: 2858 subsystem_name = "Wince CUI"; 2859 break; 2860 // These are from UEFI Platform Initialization Specification 1.1. 2861 case IMAGE_SUBSYSTEM_EFI_APPLICATION: 2862 subsystem_name = "EFI application"; 2863 break; 2864 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER: 2865 subsystem_name = "EFI boot service driver"; 2866 break; 2867 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER: 2868 subsystem_name = "EFI runtime driver"; 2869 break; 2870 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER: 2871 subsystem_name = "SAL runtime driver"; 2872 break; 2873 // This is from revision 8.0 of the MS PE/COFF spec 2874 case IMAGE_SUBSYSTEM_XBOX: 2875 subsystem_name = "XBOX"; 2876 break; 2877 // Added default case for clarity - subsystem_name is NULL anyway. 2878 default: 2879 subsystem_name = NULL; 2880 } 2881 2882 fprintf (file, "Subsystem\t\t%08x", i->Subsystem); 2883 if (subsystem_name) 2884 fprintf (file, "\t(%s)", subsystem_name); 2885 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics); 2886 fprintf (file, "SizeOfStackReserve\t"); 2887 bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve); 2888 fprintf (file, "\nSizeOfStackCommit\t"); 2889 bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit); 2890 fprintf (file, "\nSizeOfHeapReserve\t"); 2891 bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve); 2892 fprintf (file, "\nSizeOfHeapCommit\t"); 2893 bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit); 2894 fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags); 2895 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", 2896 (unsigned long) i->NumberOfRvaAndSizes); 2897 2898 fprintf (file, "\nThe Data Directory\n"); 2899 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++) 2900 { 2901 fprintf (file, "Entry %1x ", j); 2902 bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress); 2903 fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size); 2904 fprintf (file, "%s\n", dir_names[j]); 2905 } 2906 2907 pe_print_idata (abfd, vfile); 2908 pe_print_edata (abfd, vfile); 2909 if (bfd_coff_have_print_pdata (abfd)) 2910 bfd_coff_print_pdata (abfd, vfile); 2911 else 2912 pe_print_pdata (abfd, vfile); 2913 pe_print_reloc (abfd, vfile); 2914 pe_print_debugdata (abfd, file); 2915 2916 rsrc_print_section (abfd, vfile); 2917 2918 return TRUE; 2919 } 2920 2921 static bfd_boolean 2922 is_vma_in_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj) 2923 { 2924 bfd_vma addr = * (bfd_vma *) obj; 2925 return (addr >= sect->vma) && (addr < (sect->vma + sect->size)); 2926 } 2927 2928 static asection * 2929 find_section_by_vma (bfd *abfd, bfd_vma addr) 2930 { 2931 return bfd_sections_find_if (abfd, is_vma_in_section, (void *) & addr); 2932 } 2933 2934 /* Copy any private info we understand from the input bfd 2935 to the output bfd. */ 2936 2937 bfd_boolean 2938 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd) 2939 { 2940 pe_data_type *ipe, *ope; 2941 2942 /* One day we may try to grok other private data. */ 2943 if (ibfd->xvec->flavour != bfd_target_coff_flavour 2944 || obfd->xvec->flavour != bfd_target_coff_flavour) 2945 return TRUE; 2946 2947 ipe = pe_data (ibfd); 2948 ope = pe_data (obfd); 2949 2950 /* pe_opthdr is copied in copy_object. */ 2951 ope->dll = ipe->dll; 2952 2953 /* Don't copy input subsystem if output is different from input. */ 2954 if (obfd->xvec != ibfd->xvec) 2955 ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN; 2956 2957 /* For strip: if we removed .reloc, we'll make a real mess of things 2958 if we don't remove this entry as well. */ 2959 if (! pe_data (obfd)->has_reloc_section) 2960 { 2961 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0; 2962 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0; 2963 } 2964 2965 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED. 2966 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED 2967 won't be added. */ 2968 if (! pe_data (ibfd)->has_reloc_section 2969 && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED)) 2970 pe_data (obfd)->dont_strip_reloc = 1; 2971 2972 memcpy (ope->dos_message, ipe->dos_message, sizeof (ope->dos_message)); 2973 2974 /* The file offsets contained in the debug directory need rewriting. */ 2975 if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size != 0) 2976 { 2977 bfd_vma addr = ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].VirtualAddress 2978 + ope->pe_opthdr.ImageBase; 2979 asection *section = find_section_by_vma (obfd, addr); 2980 bfd_byte *data; 2981 2982 if (section && bfd_malloc_and_get_section (obfd, section, &data)) 2983 { 2984 unsigned int i; 2985 struct external_IMAGE_DEBUG_DIRECTORY *dd = 2986 (struct external_IMAGE_DEBUG_DIRECTORY *)(data + (addr - section->vma)); 2987 2988 /* PR 17512: file: 0f15796a. */ 2989 if ((unsigned long) ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size 2990 > section->size - (addr - section->vma)) 2991 { 2992 /* xgettext:c-format */ 2993 _bfd_error_handler 2994 (_("%pB: Data Directory size (%lx) " 2995 "exceeds space left in section (%" PRIx64 ")"), 2996 obfd, ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size, 2997 (uint64_t) (section->size - (addr - section->vma))); 2998 free (data); 2999 return FALSE; 3000 } 3001 3002 for (i = 0; i < ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size 3003 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++) 3004 { 3005 asection *ddsection; 3006 struct external_IMAGE_DEBUG_DIRECTORY *edd = &(dd[i]); 3007 struct internal_IMAGE_DEBUG_DIRECTORY idd; 3008 3009 _bfd_XXi_swap_debugdir_in (obfd, edd, &idd); 3010 3011 if (idd.AddressOfRawData == 0) 3012 continue; /* RVA 0 means only offset is valid, not handled yet. */ 3013 3014 ddsection = find_section_by_vma (obfd, idd.AddressOfRawData + ope->pe_opthdr.ImageBase); 3015 if (!ddsection) 3016 continue; /* Not in a section! */ 3017 3018 idd.PointerToRawData = ddsection->filepos + (idd.AddressOfRawData 3019 + ope->pe_opthdr.ImageBase) - ddsection->vma; 3020 3021 _bfd_XXi_swap_debugdir_out (obfd, &idd, edd); 3022 } 3023 3024 if (!bfd_set_section_contents (obfd, section, data, 0, section->size)) 3025 { 3026 _bfd_error_handler (_("failed to update file offsets in debug directory")); 3027 free (data); 3028 return FALSE; 3029 } 3030 free (data); 3031 } 3032 else if (section) 3033 { 3034 _bfd_error_handler (_("%pB: failed to read debug data section"), obfd); 3035 return FALSE; 3036 } 3037 } 3038 3039 return TRUE; 3040 } 3041 3042 /* Copy private section data. */ 3043 3044 bfd_boolean 3045 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd, 3046 asection *isec, 3047 bfd *obfd, 3048 asection *osec) 3049 { 3050 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour 3051 || bfd_get_flavour (obfd) != bfd_target_coff_flavour) 3052 return TRUE; 3053 3054 if (coff_section_data (ibfd, isec) != NULL 3055 && pei_section_data (ibfd, isec) != NULL) 3056 { 3057 if (coff_section_data (obfd, osec) == NULL) 3058 { 3059 bfd_size_type amt = sizeof (struct coff_section_tdata); 3060 osec->used_by_bfd = bfd_zalloc (obfd, amt); 3061 if (osec->used_by_bfd == NULL) 3062 return FALSE; 3063 } 3064 3065 if (pei_section_data (obfd, osec) == NULL) 3066 { 3067 bfd_size_type amt = sizeof (struct pei_section_tdata); 3068 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt); 3069 if (coff_section_data (obfd, osec)->tdata == NULL) 3070 return FALSE; 3071 } 3072 3073 pei_section_data (obfd, osec)->virt_size = 3074 pei_section_data (ibfd, isec)->virt_size; 3075 pei_section_data (obfd, osec)->pe_flags = 3076 pei_section_data (ibfd, isec)->pe_flags; 3077 } 3078 3079 return TRUE; 3080 } 3081 3082 void 3083 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret) 3084 { 3085 coff_get_symbol_info (abfd, symbol, ret); 3086 } 3087 3088 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64) 3089 static int 3090 sort_x64_pdata (const void *l, const void *r) 3091 { 3092 const char *lp = (const char *) l; 3093 const char *rp = (const char *) r; 3094 bfd_vma vl, vr; 3095 vl = bfd_getl32 (lp); vr = bfd_getl32 (rp); 3096 if (vl != vr) 3097 return (vl < vr ? -1 : 1); 3098 /* We compare just begin address. */ 3099 return 0; 3100 } 3101 #endif 3102 3103 /* Functions to process a .rsrc section. */ 3104 3105 static unsigned int sizeof_leaves; 3106 static unsigned int sizeof_strings; 3107 static unsigned int sizeof_tables_and_entries; 3108 3109 static bfd_byte * 3110 rsrc_count_directory (bfd *, bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma); 3111 3112 static bfd_byte * 3113 rsrc_count_entries (bfd * abfd, 3114 bfd_boolean is_name, 3115 bfd_byte * datastart, 3116 bfd_byte * data, 3117 bfd_byte * dataend, 3118 bfd_vma rva_bias) 3119 { 3120 unsigned long entry, addr, size; 3121 3122 if (data + 8 >= dataend) 3123 return dataend + 1; 3124 3125 if (is_name) 3126 { 3127 bfd_byte * name; 3128 3129 entry = (long) bfd_get_32 (abfd, data); 3130 3131 if (HighBitSet (entry)) 3132 name = datastart + WithoutHighBit (entry); 3133 else 3134 name = datastart + entry - rva_bias; 3135 3136 if (name + 2 >= dataend || name < datastart) 3137 return dataend + 1; 3138 3139 unsigned int len = bfd_get_16 (abfd, name); 3140 if (len == 0 || len > 256) 3141 return dataend + 1; 3142 } 3143 3144 entry = (long) bfd_get_32 (abfd, data + 4); 3145 3146 if (HighBitSet (entry)) 3147 { 3148 data = datastart + WithoutHighBit (entry); 3149 3150 if (data <= datastart || data >= dataend) 3151 return dataend + 1; 3152 3153 return rsrc_count_directory (abfd, datastart, data, dataend, rva_bias); 3154 } 3155 3156 if (datastart + entry + 16 >= dataend) 3157 return dataend + 1; 3158 3159 addr = (long) bfd_get_32 (abfd, datastart + entry); 3160 size = (long) bfd_get_32 (abfd, datastart + entry + 4); 3161 3162 return datastart + addr - rva_bias + size; 3163 } 3164 3165 static bfd_byte * 3166 rsrc_count_directory (bfd * abfd, 3167 bfd_byte * datastart, 3168 bfd_byte * data, 3169 bfd_byte * dataend, 3170 bfd_vma rva_bias) 3171 { 3172 unsigned int num_entries, num_ids; 3173 bfd_byte * highest_data = data; 3174 3175 if (data + 16 >= dataend) 3176 return dataend + 1; 3177 3178 num_entries = (int) bfd_get_16 (abfd, data + 12); 3179 num_ids = (int) bfd_get_16 (abfd, data + 14); 3180 3181 num_entries += num_ids; 3182 3183 data += 16; 3184 3185 while (num_entries --) 3186 { 3187 bfd_byte * entry_end; 3188 3189 entry_end = rsrc_count_entries (abfd, num_entries >= num_ids, 3190 datastart, data, dataend, rva_bias); 3191 data += 8; 3192 highest_data = max (highest_data, entry_end); 3193 if (entry_end >= dataend) 3194 break; 3195 } 3196 3197 return max (highest_data, data); 3198 } 3199 3200 typedef struct rsrc_dir_chain 3201 { 3202 unsigned int num_entries; 3203 struct rsrc_entry * first_entry; 3204 struct rsrc_entry * last_entry; 3205 } rsrc_dir_chain; 3206 3207 typedef struct rsrc_directory 3208 { 3209 unsigned int characteristics; 3210 unsigned int time; 3211 unsigned int major; 3212 unsigned int minor; 3213 3214 rsrc_dir_chain names; 3215 rsrc_dir_chain ids; 3216 3217 struct rsrc_entry * entry; 3218 } rsrc_directory; 3219 3220 typedef struct rsrc_string 3221 { 3222 unsigned int len; 3223 bfd_byte * string; 3224 } rsrc_string; 3225 3226 typedef struct rsrc_leaf 3227 { 3228 unsigned int size; 3229 unsigned int codepage; 3230 bfd_byte * data; 3231 } rsrc_leaf; 3232 3233 typedef struct rsrc_entry 3234 { 3235 bfd_boolean is_name; 3236 union 3237 { 3238 unsigned int id; 3239 struct rsrc_string name; 3240 } name_id; 3241 3242 bfd_boolean is_dir; 3243 union 3244 { 3245 struct rsrc_directory * directory; 3246 struct rsrc_leaf * leaf; 3247 } value; 3248 3249 struct rsrc_entry * next_entry; 3250 struct rsrc_directory * parent; 3251 } rsrc_entry; 3252 3253 static bfd_byte * 3254 rsrc_parse_directory (bfd *, rsrc_directory *, bfd_byte *, 3255 bfd_byte *, bfd_byte *, bfd_vma, rsrc_entry *); 3256 3257 static bfd_byte * 3258 rsrc_parse_entry (bfd * abfd, 3259 bfd_boolean is_name, 3260 rsrc_entry * entry, 3261 bfd_byte * datastart, 3262 bfd_byte * data, 3263 bfd_byte * dataend, 3264 bfd_vma rva_bias, 3265 rsrc_directory * parent) 3266 { 3267 unsigned long val, addr, size; 3268 3269 val = bfd_get_32 (abfd, data); 3270 3271 entry->parent = parent; 3272 entry->is_name = is_name; 3273 3274 if (is_name) 3275 { 3276 bfd_byte * address; 3277 3278 if (HighBitSet (val)) 3279 { 3280 val = WithoutHighBit (val); 3281 3282 address = datastart + val; 3283 } 3284 else 3285 { 3286 address = datastart + val - rva_bias; 3287 } 3288 3289 if (address + 3 > dataend) 3290 return dataend; 3291 3292 entry->name_id.name.len = bfd_get_16 (abfd, address); 3293 entry->name_id.name.string = address + 2; 3294 } 3295 else 3296 entry->name_id.id = val; 3297 3298 val = bfd_get_32 (abfd, data + 4); 3299 3300 if (HighBitSet (val)) 3301 { 3302 entry->is_dir = TRUE; 3303 entry->value.directory = bfd_malloc (sizeof * entry->value.directory); 3304 if (entry->value.directory == NULL) 3305 return dataend; 3306 3307 return rsrc_parse_directory (abfd, entry->value.directory, 3308 datastart, 3309 datastart + WithoutHighBit (val), 3310 dataend, rva_bias, entry); 3311 } 3312 3313 entry->is_dir = FALSE; 3314 entry->value.leaf = bfd_malloc (sizeof * entry->value.leaf); 3315 if (entry->value.leaf == NULL) 3316 return dataend; 3317 3318 data = datastart + val; 3319 if (data < datastart || data >= dataend) 3320 return dataend; 3321 3322 addr = bfd_get_32 (abfd, data); 3323 size = entry->value.leaf->size = bfd_get_32 (abfd, data + 4); 3324 entry->value.leaf->codepage = bfd_get_32 (abfd, data + 8); 3325 /* FIXME: We assume that the reserved field (data + 12) is OK. */ 3326 3327 entry->value.leaf->data = bfd_malloc (size); 3328 if (entry->value.leaf->data == NULL) 3329 return dataend; 3330 3331 memcpy (entry->value.leaf->data, datastart + addr - rva_bias, size); 3332 return datastart + (addr - rva_bias) + size; 3333 } 3334 3335 static bfd_byte * 3336 rsrc_parse_entries (bfd * abfd, 3337 rsrc_dir_chain * chain, 3338 bfd_boolean is_name, 3339 bfd_byte * highest_data, 3340 bfd_byte * datastart, 3341 bfd_byte * data, 3342 bfd_byte * dataend, 3343 bfd_vma rva_bias, 3344 rsrc_directory * parent) 3345 { 3346 unsigned int i; 3347 rsrc_entry * entry; 3348 3349 if (chain->num_entries == 0) 3350 { 3351 chain->first_entry = chain->last_entry = NULL; 3352 return highest_data; 3353 } 3354 3355 entry = bfd_malloc (sizeof * entry); 3356 if (entry == NULL) 3357 return dataend; 3358 3359 chain->first_entry = entry; 3360 3361 for (i = chain->num_entries; i--;) 3362 { 3363 bfd_byte * entry_end; 3364 3365 entry_end = rsrc_parse_entry (abfd, is_name, entry, datastart, 3366 data, dataend, rva_bias, parent); 3367 data += 8; 3368 highest_data = max (entry_end, highest_data); 3369 if (entry_end > dataend) 3370 return dataend; 3371 3372 if (i) 3373 { 3374 entry->next_entry = bfd_malloc (sizeof * entry); 3375 entry = entry->next_entry; 3376 if (entry == NULL) 3377 return dataend; 3378 } 3379 else 3380 entry->next_entry = NULL; 3381 } 3382 3383 chain->last_entry = entry; 3384 3385 return highest_data; 3386 } 3387 3388 static bfd_byte * 3389 rsrc_parse_directory (bfd * abfd, 3390 rsrc_directory * table, 3391 bfd_byte * datastart, 3392 bfd_byte * data, 3393 bfd_byte * dataend, 3394 bfd_vma rva_bias, 3395 rsrc_entry * entry) 3396 { 3397 bfd_byte * highest_data = data; 3398 3399 if (table == NULL) 3400 return dataend; 3401 3402 table->characteristics = bfd_get_32 (abfd, data); 3403 table->time = bfd_get_32 (abfd, data + 4); 3404 table->major = bfd_get_16 (abfd, data + 8); 3405 table->minor = bfd_get_16 (abfd, data + 10); 3406 table->names.num_entries = bfd_get_16 (abfd, data + 12); 3407 table->ids.num_entries = bfd_get_16 (abfd, data + 14); 3408 table->entry = entry; 3409 3410 data += 16; 3411 3412 highest_data = rsrc_parse_entries (abfd, & table->names, TRUE, data, 3413 datastart, data, dataend, rva_bias, table); 3414 data += table->names.num_entries * 8; 3415 3416 highest_data = rsrc_parse_entries (abfd, & table->ids, FALSE, highest_data, 3417 datastart, data, dataend, rva_bias, table); 3418 data += table->ids.num_entries * 8; 3419 3420 return max (highest_data, data); 3421 } 3422 3423 typedef struct rsrc_write_data 3424 { 3425 bfd * abfd; 3426 bfd_byte * datastart; 3427 bfd_byte * next_table; 3428 bfd_byte * next_leaf; 3429 bfd_byte * next_string; 3430 bfd_byte * next_data; 3431 bfd_vma rva_bias; 3432 } rsrc_write_data; 3433 3434 static void 3435 rsrc_write_string (rsrc_write_data * data, 3436 rsrc_string * string) 3437 { 3438 bfd_put_16 (data->abfd, string->len, data->next_string); 3439 memcpy (data->next_string + 2, string->string, string->len * 2); 3440 data->next_string += (string->len + 1) * 2; 3441 } 3442 3443 static inline unsigned int 3444 rsrc_compute_rva (rsrc_write_data * data, 3445 bfd_byte * addr) 3446 { 3447 return (addr - data->datastart) + data->rva_bias; 3448 } 3449 3450 static void 3451 rsrc_write_leaf (rsrc_write_data * data, 3452 rsrc_leaf * leaf) 3453 { 3454 bfd_put_32 (data->abfd, rsrc_compute_rva (data, data->next_data), 3455 data->next_leaf); 3456 bfd_put_32 (data->abfd, leaf->size, data->next_leaf + 4); 3457 bfd_put_32 (data->abfd, leaf->codepage, data->next_leaf + 8); 3458 bfd_put_32 (data->abfd, 0 /*reserved*/, data->next_leaf + 12); 3459 data->next_leaf += 16; 3460 3461 memcpy (data->next_data, leaf->data, leaf->size); 3462 /* An undocumented feature of Windows resources is that each unit 3463 of raw data is 8-byte aligned... */ 3464 data->next_data += ((leaf->size + 7) & ~7); 3465 } 3466 3467 static void rsrc_write_directory (rsrc_write_data *, rsrc_directory *); 3468 3469 static void 3470 rsrc_write_entry (rsrc_write_data * data, 3471 bfd_byte * where, 3472 rsrc_entry * entry) 3473 { 3474 if (entry->is_name) 3475 { 3476 bfd_put_32 (data->abfd, 3477 SetHighBit (data->next_string - data->datastart), 3478 where); 3479 rsrc_write_string (data, & entry->name_id.name); 3480 } 3481 else 3482 bfd_put_32 (data->abfd, entry->name_id.id, where); 3483 3484 if (entry->is_dir) 3485 { 3486 bfd_put_32 (data->abfd, 3487 SetHighBit (data->next_table - data->datastart), 3488 where + 4); 3489 rsrc_write_directory (data, entry->value.directory); 3490 } 3491 else 3492 { 3493 bfd_put_32 (data->abfd, data->next_leaf - data->datastart, where + 4); 3494 rsrc_write_leaf (data, entry->value.leaf); 3495 } 3496 } 3497 3498 static void 3499 rsrc_compute_region_sizes (rsrc_directory * dir) 3500 { 3501 struct rsrc_entry * entry; 3502 3503 if (dir == NULL) 3504 return; 3505 3506 sizeof_tables_and_entries += 16; 3507 3508 for (entry = dir->names.first_entry; entry != NULL; entry = entry->next_entry) 3509 { 3510 sizeof_tables_and_entries += 8; 3511 3512 sizeof_strings += (entry->name_id.name.len + 1) * 2; 3513 3514 if (entry->is_dir) 3515 rsrc_compute_region_sizes (entry->value.directory); 3516 else 3517 sizeof_leaves += 16; 3518 } 3519 3520 for (entry = dir->ids.first_entry; entry != NULL; entry = entry->next_entry) 3521 { 3522 sizeof_tables_and_entries += 8; 3523 3524 if (entry->is_dir) 3525 rsrc_compute_region_sizes (entry->value.directory); 3526 else 3527 sizeof_leaves += 16; 3528 } 3529 } 3530 3531 static void 3532 rsrc_write_directory (rsrc_write_data * data, 3533 rsrc_directory * dir) 3534 { 3535 rsrc_entry * entry; 3536 unsigned int i; 3537 bfd_byte * next_entry; 3538 bfd_byte * nt; 3539 3540 bfd_put_32 (data->abfd, dir->characteristics, data->next_table); 3541 bfd_put_32 (data->abfd, 0 /*dir->time*/, data->next_table + 4); 3542 bfd_put_16 (data->abfd, dir->major, data->next_table + 8); 3543 bfd_put_16 (data->abfd, dir->minor, data->next_table + 10); 3544 bfd_put_16 (data->abfd, dir->names.num_entries, data->next_table + 12); 3545 bfd_put_16 (data->abfd, dir->ids.num_entries, data->next_table + 14); 3546 3547 /* Compute where the entries and the next table will be placed. */ 3548 next_entry = data->next_table + 16; 3549 data->next_table = next_entry + (dir->names.num_entries * 8) 3550 + (dir->ids.num_entries * 8); 3551 nt = data->next_table; 3552 3553 /* Write the entries. */ 3554 for (i = dir->names.num_entries, entry = dir->names.first_entry; 3555 i > 0 && entry != NULL; 3556 i--, entry = entry->next_entry) 3557 { 3558 BFD_ASSERT (entry->is_name); 3559 rsrc_write_entry (data, next_entry, entry); 3560 next_entry += 8; 3561 } 3562 BFD_ASSERT (i == 0); 3563 BFD_ASSERT (entry == NULL); 3564 3565 for (i = dir->ids.num_entries, entry = dir->ids.first_entry; 3566 i > 0 && entry != NULL; 3567 i--, entry = entry->next_entry) 3568 { 3569 BFD_ASSERT (! entry->is_name); 3570 rsrc_write_entry (data, next_entry, entry); 3571 next_entry += 8; 3572 } 3573 BFD_ASSERT (i == 0); 3574 BFD_ASSERT (entry == NULL); 3575 BFD_ASSERT (nt == next_entry); 3576 } 3577 3578 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__ 3579 /* Return the length (number of units) of the first character in S, 3580 putting its 'ucs4_t' representation in *PUC. */ 3581 3582 static unsigned int 3583 #if defined HAVE_WCTYPE_H 3584 u16_mbtouc (wint_t * puc, const unsigned short * s, unsigned int n) 3585 #else 3586 u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n) 3587 #endif 3588 { 3589 unsigned short c = * s; 3590 3591 if (c < 0xd800 || c >= 0xe000) 3592 { 3593 *puc = c; 3594 return 1; 3595 } 3596 3597 if (c < 0xdc00) 3598 { 3599 if (n >= 2) 3600 { 3601 if (s[1] >= 0xdc00 && s[1] < 0xe000) 3602 { 3603 *puc = 0x10000 + ((c - 0xd800) << 10) + (s[1] - 0xdc00); 3604 return 2; 3605 } 3606 } 3607 else 3608 { 3609 /* Incomplete multibyte character. */ 3610 *puc = 0xfffd; 3611 return n; 3612 } 3613 } 3614 3615 /* Invalid multibyte character. */ 3616 *puc = 0xfffd; 3617 return 1; 3618 } 3619 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */ 3620 3621 /* Perform a comparison of two entries. */ 3622 static signed int 3623 rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b) 3624 { 3625 signed int res; 3626 bfd_byte * astring; 3627 unsigned int alen; 3628 bfd_byte * bstring; 3629 unsigned int blen; 3630 3631 if (! is_name) 3632 return a->name_id.id - b->name_id.id; 3633 3634 /* We have to perform a case insenstive, unicode string comparison... */ 3635 astring = a->name_id.name.string; 3636 alen = a->name_id.name.len; 3637 bstring = b->name_id.name.string; 3638 blen = b->name_id.name.len; 3639 3640 #if defined __CYGWIN__ || defined __MINGW32__ 3641 /* Under Windows hosts (both Cygwin and Mingw types), 3642 unicode == UTF-16 == wchar_t. The case insensitive string comparison 3643 function however goes by different names in the two environments... */ 3644 3645 #undef rscpcmp 3646 #ifdef __CYGWIN__ 3647 #define rscpcmp wcsncasecmp 3648 #endif 3649 #ifdef __MINGW32__ 3650 #define rscpcmp wcsnicmp 3651 #endif 3652 3653 res = rscpcmp ((const wchar_t *) astring, (const wchar_t *) bstring, 3654 min (alen, blen)); 3655 3656 #elif defined HAVE_WCHAR_H 3657 { 3658 unsigned int i; 3659 3660 res = 0; 3661 for (i = min (alen, blen); i--; astring += 2, bstring += 2) 3662 { 3663 #if defined HAVE_WCTYPE_H 3664 wint_t awc; 3665 wint_t bwc; 3666 #else 3667 wchar_t awc; 3668 wchar_t bwc; 3669 #endif 3670 3671 /* Convert UTF-16 unicode characters into wchar_t characters 3672 so that we can then perform a case insensitive comparison. */ 3673 unsigned int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2); 3674 unsigned int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2); 3675 3676 if (Alen != Blen) 3677 return Alen - Blen; 3678 3679 #ifdef HAVE_WCTYPE_H 3680 awc = towlower (awc); 3681 bwc = towlower (bwc); 3682 3683 res = awc - bwc; 3684 #else 3685 res = wcsncasecmp (& awc, & bwc, 1); 3686 #endif 3687 if (res) 3688 break; 3689 } 3690 } 3691 #else 3692 /* Do the best we can - a case sensitive, untranslated comparison. */ 3693 res = memcmp (astring, bstring, min (alen, blen) * 2); 3694 #endif 3695 3696 if (res == 0) 3697 res = alen - blen; 3698 3699 return res; 3700 } 3701 3702 static void 3703 rsrc_print_name (char * buffer, rsrc_string string) 3704 { 3705 unsigned int i; 3706 bfd_byte * name = string.string; 3707 3708 for (i = string.len; i--; name += 2) 3709 sprintf (buffer + strlen (buffer), "%.1s", name); 3710 } 3711 3712 static const char * 3713 rsrc_resource_name (rsrc_entry * entry, rsrc_directory * dir) 3714 { 3715 static char buffer [256]; 3716 bfd_boolean is_string = FALSE; 3717 3718 buffer[0] = 0; 3719 3720 if (dir != NULL && dir->entry != NULL && dir->entry->parent != NULL 3721 && dir->entry->parent->entry != NULL) 3722 { 3723 strcpy (buffer, "type: "); 3724 if (dir->entry->parent->entry->is_name) 3725 rsrc_print_name (buffer + strlen (buffer), 3726 dir->entry->parent->entry->name_id.name); 3727 else 3728 { 3729 unsigned int id = dir->entry->parent->entry->name_id.id; 3730 3731 sprintf (buffer + strlen (buffer), "%x", id); 3732 switch (id) 3733 { 3734 case 1: strcat (buffer, " (CURSOR)"); break; 3735 case 2: strcat (buffer, " (BITMAP)"); break; 3736 case 3: strcat (buffer, " (ICON)"); break; 3737 case 4: strcat (buffer, " (MENU)"); break; 3738 case 5: strcat (buffer, " (DIALOG)"); break; 3739 case 6: strcat (buffer, " (STRING)"); is_string = TRUE; break; 3740 case 7: strcat (buffer, " (FONTDIR)"); break; 3741 case 8: strcat (buffer, " (FONT)"); break; 3742 case 9: strcat (buffer, " (ACCELERATOR)"); break; 3743 case 10: strcat (buffer, " (RCDATA)"); break; 3744 case 11: strcat (buffer, " (MESSAGETABLE)"); break; 3745 case 12: strcat (buffer, " (GROUP_CURSOR)"); break; 3746 case 14: strcat (buffer, " (GROUP_ICON)"); break; 3747 case 16: strcat (buffer, " (VERSION)"); break; 3748 case 17: strcat (buffer, " (DLGINCLUDE)"); break; 3749 case 19: strcat (buffer, " (PLUGPLAY)"); break; 3750 case 20: strcat (buffer, " (VXD)"); break; 3751 case 21: strcat (buffer, " (ANICURSOR)"); break; 3752 case 22: strcat (buffer, " (ANIICON)"); break; 3753 case 23: strcat (buffer, " (HTML)"); break; 3754 case 24: strcat (buffer, " (MANIFEST)"); break; 3755 case 240: strcat (buffer, " (DLGINIT)"); break; 3756 case 241: strcat (buffer, " (TOOLBAR)"); break; 3757 } 3758 } 3759 } 3760 3761 if (dir != NULL && dir->entry != NULL) 3762 { 3763 strcat (buffer, " name: "); 3764 if (dir->entry->is_name) 3765 rsrc_print_name (buffer + strlen (buffer), dir->entry->name_id.name); 3766 else 3767 { 3768 unsigned int id = dir->entry->name_id.id; 3769 3770 sprintf (buffer + strlen (buffer), "%x", id); 3771 3772 if (is_string) 3773 sprintf (buffer + strlen (buffer), " (resource id range: %d - %d)", 3774 (id - 1) << 4, (id << 4) - 1); 3775 } 3776 } 3777 3778 if (entry != NULL) 3779 { 3780 strcat (buffer, " lang: "); 3781 3782 if (entry->is_name) 3783 rsrc_print_name (buffer + strlen (buffer), entry->name_id.name); 3784 else 3785 sprintf (buffer + strlen (buffer), "%x", entry->name_id.id); 3786 } 3787 3788 return buffer; 3789 } 3790 3791 /* *sigh* Windows resource strings are special. Only the top 28-bits of 3792 their ID is stored in the NAME entry. The bottom four bits are used as 3793 an index into unicode string table that makes up the data of the leaf. 3794 So identical type-name-lang string resources may not actually be 3795 identical at all. 3796 3797 This function is called when we have detected two string resources with 3798 match top-28-bit IDs. We have to scan the string tables inside the leaves 3799 and discover if there are any real collisions. If there are then we report 3800 them and return FALSE. Otherwise we copy any strings from B into A and 3801 then return TRUE. */ 3802 3803 static bfd_boolean 3804 rsrc_merge_string_entries (rsrc_entry * a ATTRIBUTE_UNUSED, 3805 rsrc_entry * b ATTRIBUTE_UNUSED) 3806 { 3807 unsigned int copy_needed = 0; 3808 unsigned int i; 3809 bfd_byte * astring; 3810 bfd_byte * bstring; 3811 bfd_byte * new_data; 3812 bfd_byte * nstring; 3813 3814 /* Step one: Find out what we have to do. */ 3815 BFD_ASSERT (! a->is_dir); 3816 astring = a->value.leaf->data; 3817 3818 BFD_ASSERT (! b->is_dir); 3819 bstring = b->value.leaf->data; 3820 3821 for (i = 0; i < 16; i++) 3822 { 3823 unsigned int alen = astring[0] + (astring[1] << 8); 3824 unsigned int blen = bstring[0] + (bstring[1] << 8); 3825 3826 if (alen == 0) 3827 { 3828 copy_needed += blen * 2; 3829 } 3830 else if (blen == 0) 3831 ; 3832 else if (alen != blen) 3833 /* FIXME: Should we continue the loop in order to report other duplicates ? */ 3834 break; 3835 /* alen == blen != 0. We might have two identical strings. If so we 3836 can ignore the second one. There is no need for wchar_t vs UTF-16 3837 theatrics here - we are only interested in (case sensitive) equality. */ 3838 else if (memcmp (astring + 2, bstring + 2, alen * 2) != 0) 3839 break; 3840 3841 astring += (alen + 1) * 2; 3842 bstring += (blen + 1) * 2; 3843 } 3844 3845 if (i != 16) 3846 { 3847 if (a->parent != NULL 3848 && a->parent->entry != NULL 3849 && !a->parent->entry->is_name) 3850 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"), 3851 ((a->parent->entry->name_id.id - 1) << 4) + i); 3852 return FALSE; 3853 } 3854 3855 if (copy_needed == 0) 3856 return TRUE; 3857 3858 /* If we reach here then A and B must both have non-colliding strings. 3859 (We never get string resources with fully empty string tables). 3860 We need to allocate an extra COPY_NEEDED bytes in A and then bring 3861 in B's strings. */ 3862 new_data = bfd_malloc (a->value.leaf->size + copy_needed); 3863 if (new_data == NULL) 3864 return FALSE; 3865 3866 nstring = new_data; 3867 astring = a->value.leaf->data; 3868 bstring = b->value.leaf->data; 3869 3870 for (i = 0; i < 16; i++) 3871 { 3872 unsigned int alen = astring[0] + (astring[1] << 8); 3873 unsigned int blen = bstring[0] + (bstring[1] << 8); 3874 3875 if (alen != 0) 3876 { 3877 memcpy (nstring, astring, (alen + 1) * 2); 3878 nstring += (alen + 1) * 2; 3879 } 3880 else if (blen != 0) 3881 { 3882 memcpy (nstring, bstring, (blen + 1) * 2); 3883 nstring += (blen + 1) * 2; 3884 } 3885 else 3886 { 3887 * nstring++ = 0; 3888 * nstring++ = 0; 3889 } 3890 3891 astring += (alen + 1) * 2; 3892 bstring += (blen + 1) * 2; 3893 } 3894 3895 BFD_ASSERT (nstring - new_data == (signed) (a->value.leaf->size + copy_needed)); 3896 3897 free (a->value.leaf->data); 3898 a->value.leaf->data = new_data; 3899 a->value.leaf->size += copy_needed; 3900 3901 return TRUE; 3902 } 3903 3904 static void rsrc_merge (rsrc_entry *, rsrc_entry *); 3905 3906 /* Sort the entries in given part of the directory. 3907 We use an old fashioned bubble sort because we are dealing 3908 with lists and we want to handle matches specially. */ 3909 3910 static void 3911 rsrc_sort_entries (rsrc_dir_chain * chain, 3912 bfd_boolean is_name, 3913 rsrc_directory * dir) 3914 { 3915 rsrc_entry * entry; 3916 rsrc_entry * next; 3917 rsrc_entry ** points_to_entry; 3918 bfd_boolean swapped; 3919 3920 if (chain->num_entries < 2) 3921 return; 3922 3923 do 3924 { 3925 swapped = FALSE; 3926 points_to_entry = & chain->first_entry; 3927 entry = * points_to_entry; 3928 next = entry->next_entry; 3929 3930 do 3931 { 3932 signed int cmp = rsrc_cmp (is_name, entry, next); 3933 3934 if (cmp > 0) 3935 { 3936 entry->next_entry = next->next_entry; 3937 next->next_entry = entry; 3938 * points_to_entry = next; 3939 points_to_entry = & next->next_entry; 3940 next = entry->next_entry; 3941 swapped = TRUE; 3942 } 3943 else if (cmp == 0) 3944 { 3945 if (entry->is_dir && next->is_dir) 3946 { 3947 /* When we encounter identical directory entries we have to 3948 merge them together. The exception to this rule is for 3949 resource manifests - there can only be one of these, 3950 even if they differ in language. Zero-language manifests 3951 are assumed to be default manifests (provided by the 3952 Cygwin/MinGW build system) and these can be silently dropped, 3953 unless that would reduce the number of manifests to zero. 3954 There should only ever be one non-zero lang manifest - 3955 if there are more it is an error. A non-zero lang 3956 manifest takes precedence over a default manifest. */ 3957 if (!entry->is_name 3958 && entry->name_id.id == 1 3959 && dir != NULL 3960 && dir->entry != NULL 3961 && !dir->entry->is_name 3962 && dir->entry->name_id.id == 0x18) 3963 { 3964 if (next->value.directory->names.num_entries == 0 3965 && next->value.directory->ids.num_entries == 1 3966 && !next->value.directory->ids.first_entry->is_name 3967 && next->value.directory->ids.first_entry->name_id.id == 0) 3968 /* Fall through so that NEXT is dropped. */ 3969 ; 3970 else if (entry->value.directory->names.num_entries == 0 3971 && entry->value.directory->ids.num_entries == 1 3972 && !entry->value.directory->ids.first_entry->is_name 3973 && entry->value.directory->ids.first_entry->name_id.id == 0) 3974 { 3975 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */ 3976 entry->next_entry = next->next_entry; 3977 next->next_entry = entry; 3978 * points_to_entry = next; 3979 points_to_entry = & next->next_entry; 3980 next = entry->next_entry; 3981 swapped = TRUE; 3982 } 3983 else 3984 { 3985 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests")); 3986 bfd_set_error (bfd_error_file_truncated); 3987 return; 3988 } 3989 3990 /* Unhook NEXT from the chain. */ 3991 /* FIXME: memory loss here. */ 3992 entry->next_entry = next->next_entry; 3993 chain->num_entries --; 3994 if (chain->num_entries < 2) 3995 return; 3996 next = next->next_entry; 3997 } 3998 else 3999 rsrc_merge (entry, next); 4000 } 4001 else if (entry->is_dir != next->is_dir) 4002 { 4003 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf")); 4004 bfd_set_error (bfd_error_file_truncated); 4005 return; 4006 } 4007 else 4008 { 4009 /* Otherwise with identical leaves we issue an error 4010 message - because there should never be duplicates. 4011 The exception is Type 18/Name 1/Lang 0 which is the 4012 defaul manifest - this can just be dropped. */ 4013 if (!entry->is_name 4014 && entry->name_id.id == 0 4015 && dir != NULL 4016 && dir->entry != NULL 4017 && !dir->entry->is_name 4018 && dir->entry->name_id.id == 1 4019 && dir->entry->parent != NULL 4020 && dir->entry->parent->entry != NULL 4021 && !dir->entry->parent->entry->is_name 4022 && dir->entry->parent->entry->name_id.id == 0x18 /* RT_MANIFEST */) 4023 ; 4024 else if (dir != NULL 4025 && dir->entry != NULL 4026 && dir->entry->parent != NULL 4027 && dir->entry->parent->entry != NULL 4028 && !dir->entry->parent->entry->is_name 4029 && dir->entry->parent->entry->name_id.id == 0x6 /* RT_STRING */) 4030 { 4031 /* Strings need special handling. */ 4032 if (! rsrc_merge_string_entries (entry, next)) 4033 { 4034 /* _bfd_error_handler should have been called inside merge_strings. */ 4035 bfd_set_error (bfd_error_file_truncated); 4036 return; 4037 } 4038 } 4039 else 4040 { 4041 if (dir == NULL 4042 || dir->entry == NULL 4043 || dir->entry->parent == NULL 4044 || dir->entry->parent->entry == NULL) 4045 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf")); 4046 else 4047 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"), 4048 rsrc_resource_name (entry, dir)); 4049 bfd_set_error (bfd_error_file_truncated); 4050 return; 4051 } 4052 } 4053 4054 /* Unhook NEXT from the chain. */ 4055 entry->next_entry = next->next_entry; 4056 chain->num_entries --; 4057 if (chain->num_entries < 2) 4058 return; 4059 next = next->next_entry; 4060 } 4061 else 4062 { 4063 points_to_entry = & entry->next_entry; 4064 entry = next; 4065 next = next->next_entry; 4066 } 4067 } 4068 while (next); 4069 4070 chain->last_entry = entry; 4071 } 4072 while (swapped); 4073 } 4074 4075 /* Attach B's chain onto A. */ 4076 static void 4077 rsrc_attach_chain (rsrc_dir_chain * achain, rsrc_dir_chain * bchain) 4078 { 4079 if (bchain->num_entries == 0) 4080 return; 4081 4082 achain->num_entries += bchain->num_entries; 4083 4084 if (achain->first_entry == NULL) 4085 { 4086 achain->first_entry = bchain->first_entry; 4087 achain->last_entry = bchain->last_entry; 4088 } 4089 else 4090 { 4091 achain->last_entry->next_entry = bchain->first_entry; 4092 achain->last_entry = bchain->last_entry; 4093 } 4094 4095 bchain->num_entries = 0; 4096 bchain->first_entry = bchain->last_entry = NULL; 4097 } 4098 4099 static void 4100 rsrc_merge (struct rsrc_entry * a, struct rsrc_entry * b) 4101 { 4102 rsrc_directory * adir; 4103 rsrc_directory * bdir; 4104 4105 BFD_ASSERT (a->is_dir); 4106 BFD_ASSERT (b->is_dir); 4107 4108 adir = a->value.directory; 4109 bdir = b->value.directory; 4110 4111 if (adir->characteristics != bdir->characteristics) 4112 { 4113 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics")); 4114 bfd_set_error (bfd_error_file_truncated); 4115 return; 4116 } 4117 4118 if (adir->major != bdir->major || adir->minor != bdir->minor) 4119 { 4120 _bfd_error_handler (_(".rsrc merge failure: differing directory versions")); 4121 bfd_set_error (bfd_error_file_truncated); 4122 return; 4123 } 4124 4125 /* Attach B's name chain to A. */ 4126 rsrc_attach_chain (& adir->names, & bdir->names); 4127 4128 /* Attach B's ID chain to A. */ 4129 rsrc_attach_chain (& adir->ids, & bdir->ids); 4130 4131 /* Now sort A's entries. */ 4132 rsrc_sort_entries (& adir->names, TRUE, adir); 4133 rsrc_sort_entries (& adir->ids, FALSE, adir); 4134 } 4135 4136 /* Check the .rsrc section. If it contains multiple concatenated 4137 resources then we must merge them properly. Otherwise Windows 4138 will ignore all but the first set. */ 4139 4140 static void 4141 rsrc_process_section (bfd * abfd, 4142 struct coff_final_link_info * pfinfo) 4143 { 4144 rsrc_directory new_table; 4145 bfd_size_type size; 4146 asection * sec; 4147 pe_data_type * pe; 4148 bfd_vma rva_bias; 4149 bfd_byte * data; 4150 bfd_byte * datastart; 4151 bfd_byte * dataend; 4152 bfd_byte * new_data; 4153 unsigned int num_resource_sets; 4154 rsrc_directory * type_tables; 4155 rsrc_write_data write_data; 4156 unsigned int indx; 4157 bfd * input; 4158 unsigned int num_input_rsrc = 0; 4159 unsigned int max_num_input_rsrc = 4; 4160 ptrdiff_t * rsrc_sizes = NULL; 4161 4162 new_table.names.num_entries = 0; 4163 new_table.ids.num_entries = 0; 4164 4165 sec = bfd_get_section_by_name (abfd, ".rsrc"); 4166 if (sec == NULL || (size = sec->rawsize) == 0) 4167 return; 4168 4169 pe = pe_data (abfd); 4170 if (pe == NULL) 4171 return; 4172 4173 rva_bias = sec->vma - pe->pe_opthdr.ImageBase; 4174 4175 data = bfd_malloc (size); 4176 if (data == NULL) 4177 return; 4178 4179 datastart = data; 4180 4181 if (! bfd_get_section_contents (abfd, sec, data, 0, size)) 4182 goto end; 4183 4184 /* Step zero: Scan the input bfds looking for .rsrc sections and record 4185 their lengths. Note - we rely upon the fact that the linker script 4186 does *not* sort the input .rsrc sections, so that the order in the 4187 linkinfo list matches the order in the output .rsrc section. 4188 4189 We need to know the lengths because each input .rsrc section has padding 4190 at the end of a variable amount. (It does not appear to be based upon 4191 the section alignment or the file alignment). We need to skip any 4192 padding bytes when parsing the input .rsrc sections. */ 4193 rsrc_sizes = bfd_malloc (max_num_input_rsrc * sizeof * rsrc_sizes); 4194 if (rsrc_sizes == NULL) 4195 goto end; 4196 4197 for (input = pfinfo->info->input_bfds; 4198 input != NULL; 4199 input = input->link.next) 4200 { 4201 asection * rsrc_sec = bfd_get_section_by_name (input, ".rsrc"); 4202 4203 /* PR 18372 - skip discarded .rsrc sections. */ 4204 if (rsrc_sec != NULL && !discarded_section (rsrc_sec)) 4205 { 4206 if (num_input_rsrc == max_num_input_rsrc) 4207 { 4208 max_num_input_rsrc += 10; 4209 rsrc_sizes = bfd_realloc (rsrc_sizes, max_num_input_rsrc 4210 * sizeof * rsrc_sizes); 4211 if (rsrc_sizes == NULL) 4212 goto end; 4213 } 4214 4215 BFD_ASSERT (rsrc_sec->size > 0); 4216 rsrc_sizes [num_input_rsrc ++] = rsrc_sec->size; 4217 } 4218 } 4219 4220 if (num_input_rsrc < 2) 4221 goto end; 4222 4223 /* Step one: Walk the section, computing the size of the tables, 4224 leaves and data and decide if we need to do anything. */ 4225 dataend = data + size; 4226 num_resource_sets = 0; 4227 4228 while (data < dataend) 4229 { 4230 bfd_byte * p = data; 4231 4232 data = rsrc_count_directory (abfd, data, data, dataend, rva_bias); 4233 4234 if (data > dataend) 4235 { 4236 /* Corrupted .rsrc section - cannot merge. */ 4237 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"), 4238 abfd); 4239 bfd_set_error (bfd_error_file_truncated); 4240 goto end; 4241 } 4242 4243 if ((data - p) > rsrc_sizes [num_resource_sets]) 4244 { 4245 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"), 4246 abfd); 4247 bfd_set_error (bfd_error_file_truncated); 4248 goto end; 4249 } 4250 /* FIXME: Should we add a check for "data - p" being much smaller 4251 than rsrc_sizes[num_resource_sets] ? */ 4252 4253 data = p + rsrc_sizes[num_resource_sets]; 4254 rva_bias += data - p; 4255 ++ num_resource_sets; 4256 } 4257 BFD_ASSERT (num_resource_sets == num_input_rsrc); 4258 4259 /* Step two: Walk the data again, building trees of the resources. */ 4260 data = datastart; 4261 rva_bias = sec->vma - pe->pe_opthdr.ImageBase; 4262 4263 type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables); 4264 if (type_tables == NULL) 4265 goto end; 4266 4267 indx = 0; 4268 while (data < dataend) 4269 { 4270 bfd_byte * p = data; 4271 4272 (void) rsrc_parse_directory (abfd, type_tables + indx, data, data, 4273 dataend, rva_bias, NULL); 4274 data = p + rsrc_sizes[indx]; 4275 rva_bias += data - p; 4276 ++ indx; 4277 } 4278 BFD_ASSERT (indx == num_resource_sets); 4279 4280 /* Step three: Merge the top level tables (there can be only one). 4281 4282 We must ensure that the merged entries are in ascending order. 4283 4284 We also thread the top level table entries from the old tree onto 4285 the new table, so that they can be pulled off later. */ 4286 4287 /* FIXME: Should we verify that all type tables are the same ? */ 4288 new_table.characteristics = type_tables[0].characteristics; 4289 new_table.time = type_tables[0].time; 4290 new_table.major = type_tables[0].major; 4291 new_table.minor = type_tables[0].minor; 4292 4293 /* Chain the NAME entries onto the table. */ 4294 new_table.names.first_entry = NULL; 4295 new_table.names.last_entry = NULL; 4296 4297 for (indx = 0; indx < num_resource_sets; indx++) 4298 rsrc_attach_chain (& new_table.names, & type_tables[indx].names); 4299 4300 rsrc_sort_entries (& new_table.names, TRUE, & new_table); 4301 4302 /* Chain the ID entries onto the table. */ 4303 new_table.ids.first_entry = NULL; 4304 new_table.ids.last_entry = NULL; 4305 4306 for (indx = 0; indx < num_resource_sets; indx++) 4307 rsrc_attach_chain (& new_table.ids, & type_tables[indx].ids); 4308 4309 rsrc_sort_entries (& new_table.ids, FALSE, & new_table); 4310 4311 /* Step four: Create new contents for the .rsrc section. */ 4312 /* Step four point one: Compute the size of each region of the .rsrc section. 4313 We do this now, rather than earlier, as the merging above may have dropped 4314 some entries. */ 4315 sizeof_leaves = sizeof_strings = sizeof_tables_and_entries = 0; 4316 rsrc_compute_region_sizes (& new_table); 4317 /* We increment sizeof_strings to make sure that resource data 4318 starts on an 8-byte boundary. FIXME: Is this correct ? */ 4319 sizeof_strings = (sizeof_strings + 7) & ~ 7; 4320 4321 new_data = bfd_zalloc (abfd, size); 4322 if (new_data == NULL) 4323 goto end; 4324 4325 write_data.abfd = abfd; 4326 write_data.datastart = new_data; 4327 write_data.next_table = new_data; 4328 write_data.next_leaf = new_data + sizeof_tables_and_entries; 4329 write_data.next_string = write_data.next_leaf + sizeof_leaves; 4330 write_data.next_data = write_data.next_string + sizeof_strings; 4331 write_data.rva_bias = sec->vma - pe->pe_opthdr.ImageBase; 4332 4333 rsrc_write_directory (& write_data, & new_table); 4334 4335 /* Step five: Replace the old contents with the new. 4336 We don't recompute the size as it's too late here to shrink section. 4337 See PR ld/20193 for more details. */ 4338 bfd_set_section_contents (pfinfo->output_bfd, sec, new_data, 0, size); 4339 sec->size = sec->rawsize = size; 4340 4341 end: 4342 /* Step six: Free all the memory that we have used. */ 4343 /* FIXME: Free the resource tree, if we have one. */ 4344 free (datastart); 4345 free (rsrc_sizes); 4346 } 4347 4348 /* Handle the .idata section and other things that need symbol table 4349 access. */ 4350 4351 bfd_boolean 4352 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo) 4353 { 4354 struct coff_link_hash_entry *h1; 4355 struct bfd_link_info *info = pfinfo->info; 4356 bfd_boolean result = TRUE; 4357 4358 /* There are a few fields that need to be filled in now while we 4359 have symbol table access. 4360 4361 The .idata subsections aren't directly available as sections, but 4362 they are in the symbol table, so get them from there. */ 4363 4364 /* The import directory. This is the address of .idata$2, with size 4365 of .idata$2 + .idata$3. */ 4366 h1 = coff_link_hash_lookup (coff_hash_table (info), 4367 ".idata$2", FALSE, FALSE, TRUE); 4368 if (h1 != NULL) 4369 { 4370 /* PR ld/2729: We cannot rely upon all the output sections having been 4371 created properly, so check before referencing them. Issue a warning 4372 message for any sections tht could not be found. */ 4373 if ((h1->root.type == bfd_link_hash_defined 4374 || h1->root.type == bfd_link_hash_defweak) 4375 && h1->root.u.def.section != NULL 4376 && h1->root.u.def.section->output_section != NULL) 4377 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress = 4378 (h1->root.u.def.value 4379 + h1->root.u.def.section->output_section->vma 4380 + h1->root.u.def.section->output_offset); 4381 else 4382 { 4383 _bfd_error_handler 4384 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"), 4385 abfd); 4386 result = FALSE; 4387 } 4388 4389 h1 = coff_link_hash_lookup (coff_hash_table (info), 4390 ".idata$4", FALSE, FALSE, TRUE); 4391 if (h1 != NULL 4392 && (h1->root.type == bfd_link_hash_defined 4393 || h1->root.type == bfd_link_hash_defweak) 4394 && h1->root.u.def.section != NULL 4395 && h1->root.u.def.section->output_section != NULL) 4396 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size = 4397 ((h1->root.u.def.value 4398 + h1->root.u.def.section->output_section->vma 4399 + h1->root.u.def.section->output_offset) 4400 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress); 4401 else 4402 { 4403 _bfd_error_handler 4404 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"), 4405 abfd); 4406 result = FALSE; 4407 } 4408 4409 /* The import address table. This is the size/address of 4410 .idata$5. */ 4411 h1 = coff_link_hash_lookup (coff_hash_table (info), 4412 ".idata$5", FALSE, FALSE, TRUE); 4413 if (h1 != NULL 4414 && (h1->root.type == bfd_link_hash_defined 4415 || h1->root.type == bfd_link_hash_defweak) 4416 && h1->root.u.def.section != NULL 4417 && h1->root.u.def.section->output_section != NULL) 4418 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress = 4419 (h1->root.u.def.value 4420 + h1->root.u.def.section->output_section->vma 4421 + h1->root.u.def.section->output_offset); 4422 else 4423 { 4424 _bfd_error_handler 4425 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"), 4426 abfd); 4427 result = FALSE; 4428 } 4429 4430 h1 = coff_link_hash_lookup (coff_hash_table (info), 4431 ".idata$6", FALSE, FALSE, TRUE); 4432 if (h1 != NULL 4433 && (h1->root.type == bfd_link_hash_defined 4434 || h1->root.type == bfd_link_hash_defweak) 4435 && h1->root.u.def.section != NULL 4436 && h1->root.u.def.section->output_section != NULL) 4437 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size = 4438 ((h1->root.u.def.value 4439 + h1->root.u.def.section->output_section->vma 4440 + h1->root.u.def.section->output_offset) 4441 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress); 4442 else 4443 { 4444 _bfd_error_handler 4445 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"), 4446 abfd); 4447 result = FALSE; 4448 } 4449 } 4450 else 4451 { 4452 h1 = coff_link_hash_lookup (coff_hash_table (info), 4453 "__IAT_start__", FALSE, FALSE, TRUE); 4454 if (h1 != NULL 4455 && (h1->root.type == bfd_link_hash_defined 4456 || h1->root.type == bfd_link_hash_defweak) 4457 && h1->root.u.def.section != NULL 4458 && h1->root.u.def.section->output_section != NULL) 4459 { 4460 bfd_vma iat_va; 4461 4462 iat_va = 4463 (h1->root.u.def.value 4464 + h1->root.u.def.section->output_section->vma 4465 + h1->root.u.def.section->output_offset); 4466 4467 h1 = coff_link_hash_lookup (coff_hash_table (info), 4468 "__IAT_end__", FALSE, FALSE, TRUE); 4469 if (h1 != NULL 4470 && (h1->root.type == bfd_link_hash_defined 4471 || h1->root.type == bfd_link_hash_defweak) 4472 && h1->root.u.def.section != NULL 4473 && h1->root.u.def.section->output_section != NULL) 4474 { 4475 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size = 4476 ((h1->root.u.def.value 4477 + h1->root.u.def.section->output_section->vma 4478 + h1->root.u.def.section->output_offset) 4479 - iat_va); 4480 if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0) 4481 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress = 4482 iat_va - pe_data (abfd)->pe_opthdr.ImageBase; 4483 } 4484 else 4485 { 4486 _bfd_error_handler 4487 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]" 4488 " because .idata$6 is missing"), abfd); 4489 result = FALSE; 4490 } 4491 } 4492 } 4493 4494 h1 = coff_link_hash_lookup (coff_hash_table (info), 4495 (bfd_get_symbol_leading_char (abfd) != 0 4496 ? "__tls_used" : "_tls_used"), 4497 FALSE, FALSE, TRUE); 4498 if (h1 != NULL) 4499 { 4500 if ((h1->root.type == bfd_link_hash_defined 4501 || h1->root.type == bfd_link_hash_defweak) 4502 && h1->root.u.def.section != NULL 4503 && h1->root.u.def.section->output_section != NULL) 4504 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress = 4505 (h1->root.u.def.value 4506 + h1->root.u.def.section->output_section->vma 4507 + h1->root.u.def.section->output_offset 4508 - pe_data (abfd)->pe_opthdr.ImageBase); 4509 else 4510 { 4511 _bfd_error_handler 4512 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"), 4513 abfd); 4514 result = FALSE; 4515 } 4516 /* According to PECOFF sepcifications by Microsoft version 8.2 4517 the TLS data directory consists of 4 pointers, followed 4518 by two 4-byte integer. This implies that the total size 4519 is different for 32-bit and 64-bit executables. */ 4520 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 4521 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18; 4522 #else 4523 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28; 4524 #endif 4525 } 4526 4527 /* If there is a .pdata section and we have linked pdata finally, we 4528 need to sort the entries ascending. */ 4529 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64) 4530 { 4531 asection *sec = bfd_get_section_by_name (abfd, ".pdata"); 4532 4533 if (sec) 4534 { 4535 bfd_size_type x = sec->rawsize; 4536 bfd_byte *tmp_data = NULL; 4537 4538 if (x) 4539 tmp_data = bfd_malloc (x); 4540 4541 if (tmp_data != NULL) 4542 { 4543 if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x)) 4544 { 4545 qsort (tmp_data, 4546 (size_t) (x / 12), 4547 12, sort_x64_pdata); 4548 bfd_set_section_contents (pfinfo->output_bfd, sec, 4549 tmp_data, 0, x); 4550 } 4551 free (tmp_data); 4552 } 4553 else 4554 result = FALSE; 4555 } 4556 } 4557 #endif 4558 4559 rsrc_process_section (abfd, pfinfo); 4560 4561 /* If we couldn't find idata$2, we either have an excessively 4562 trivial program or are in DEEP trouble; we have to assume trivial 4563 program.... */ 4564 return result; 4565 } 4566