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