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