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