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