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