1 /* Support for the generic parts of PE/PEI; the common executable parts. 2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 3 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. 4 Written by Cygnus Solutions. 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 MA 02110-1301, USA. */ 22 23 24 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>. 25 26 PE/PEI rearrangement (and code added): Donn Terry 27 Softway Systems, Inc. */ 28 29 /* Hey look, some documentation [and in a place you expect to find it]! 30 31 The main reference for the pei format is "Microsoft Portable Executable 32 and Common Object File Format Specification 4.1". Get it if you need to 33 do some serious hacking on this code. 34 35 Another reference: 36 "Peering Inside the PE: A Tour of the Win32 Portable Executable 37 File Format", MSJ 1994, Volume 9. 38 39 The *sole* difference between the pe format and the pei format is that the 40 latter has an MSDOS 2.0 .exe header on the front that prints the message 41 "This app must be run under Windows." (or some such). 42 (FIXME: Whether that statement is *really* true or not is unknown. 43 Are there more subtle differences between pe and pei formats? 44 For now assume there aren't. If you find one, then for God sakes 45 document it here!) 46 47 The Microsoft docs use the word "image" instead of "executable" because 48 the former can also refer to a DLL (shared library). Confusion can arise 49 because the `i' in `pei' also refers to "image". The `pe' format can 50 also create images (i.e. executables), it's just that to run on a win32 51 system you need to use the pei format. 52 53 FIXME: Please add more docs here so the next poor fool that has to hack 54 on this code has a chance of getting something accomplished without 55 wasting too much time. */ 56 57 /* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64 58 depending on whether we're compiling for straight PE or PE+. */ 59 #define COFF_WITH_XX 60 61 #include "sysdep.h" 62 #include "bfd.h" 63 #include "libbfd.h" 64 #include "coff/internal.h" 65 #include "bfdver.h" 66 67 /* NOTE: it's strange to be including an architecture specific header 68 in what's supposed to be general (to PE/PEI) code. However, that's 69 where the definitions are, and they don't vary per architecture 70 within PE/PEI, so we get them from there. FIXME: The lack of 71 variance is an assumption which may prove to be incorrect if new 72 PE/PEI targets are created. */ 73 #if defined COFF_WITH_pex64 74 # include "coff/x86_64.h" 75 #elif defined COFF_WITH_pep 76 # include "coff/ia64.h" 77 #else 78 # include "coff/i386.h" 79 #endif 80 81 #include "coff/pe.h" 82 #include "libcoff.h" 83 #include "libpei.h" 84 85 #if defined COFF_WITH_pep || defined COFF_WITH_pex64 86 # undef AOUTSZ 87 # define AOUTSZ PEPAOUTSZ 88 # define PEAOUTHDR PEPAOUTHDR 89 #endif 90 91 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests 92 worked when the code was in peicode.h, but no longer work now that 93 the code is in peigen.c. PowerPC NT is said to be dead. If 94 anybody wants to revive the code, you will have to figure out how 95 to handle those issues. */ 96 97 void 98 _bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1) 99 { 100 SYMENT *ext = (SYMENT *) ext1; 101 struct internal_syment *in = (struct internal_syment *) in1; 102 103 if (ext->e.e_name[0] == 0) 104 { 105 in->_n._n_n._n_zeroes = 0; 106 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset); 107 } 108 else 109 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN); 110 111 in->n_value = H_GET_32 (abfd, ext->e_value); 112 in->n_scnum = H_GET_16 (abfd, ext->e_scnum); 113 114 if (sizeof (ext->e_type) == 2) 115 in->n_type = H_GET_16 (abfd, ext->e_type); 116 else 117 in->n_type = H_GET_32 (abfd, ext->e_type); 118 119 in->n_sclass = H_GET_8 (abfd, ext->e_sclass); 120 in->n_numaux = H_GET_8 (abfd, ext->e_numaux); 121 122 #ifndef STRICT_PE_FORMAT 123 /* This is for Gnu-created DLLs. */ 124 125 /* The section symbols for the .idata$ sections have class 0x68 126 (C_SECTION), which MS documentation indicates is a section 127 symbol. Unfortunately, the value field in the symbol is simply a 128 copy of the .idata section's flags rather than something useful. 129 When these symbols are encountered, change the value to 0 so that 130 they will be handled somewhat correctly in the bfd code. */ 131 if (in->n_sclass == C_SECTION) 132 { 133 char namebuf[SYMNMLEN + 1]; 134 const char *name = NULL; 135 136 in->n_value = 0x0; 137 138 /* Create synthetic empty sections as needed. DJ */ 139 if (in->n_scnum == 0) 140 { 141 asection *sec; 142 143 name = _bfd_coff_internal_syment_name (abfd, in, namebuf); 144 if (name == NULL) 145 /* FIXME: Return error. */ 146 abort (); 147 sec = bfd_get_section_by_name (abfd, name); 148 if (sec != NULL) 149 in->n_scnum = sec->target_index; 150 } 151 152 if (in->n_scnum == 0) 153 { 154 int unused_section_number = 0; 155 asection *sec; 156 flagword flags; 157 158 for (sec = abfd->sections; sec; sec = sec->next) 159 if (unused_section_number <= sec->target_index) 160 unused_section_number = sec->target_index + 1; 161 162 if (name == namebuf) 163 { 164 name = (const char *) bfd_alloc (abfd, strlen (namebuf) + 1); 165 if (name == NULL) 166 /* FIXME: Return error. */ 167 abort (); 168 strcpy ((char *) name, namebuf); 169 } 170 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD; 171 sec = bfd_make_section_anyway_with_flags (abfd, name, flags); 172 if (sec == NULL) 173 /* FIXME: Return error. */ 174 abort (); 175 176 sec->vma = 0; 177 sec->lma = 0; 178 sec->size = 0; 179 sec->filepos = 0; 180 sec->rel_filepos = 0; 181 sec->reloc_count = 0; 182 sec->line_filepos = 0; 183 sec->lineno_count = 0; 184 sec->userdata = NULL; 185 sec->next = NULL; 186 sec->alignment_power = 2; 187 188 sec->target_index = unused_section_number; 189 190 in->n_scnum = unused_section_number; 191 } 192 in->n_sclass = C_STAT; 193 } 194 #endif 195 196 #ifdef coff_swap_sym_in_hook 197 /* This won't work in peigen.c, but since it's for PPC PE, it's not 198 worth fixing. */ 199 coff_swap_sym_in_hook (abfd, ext1, in1); 200 #endif 201 } 202 203 unsigned int 204 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp) 205 { 206 struct internal_syment *in = (struct internal_syment *) inp; 207 SYMENT *ext = (SYMENT *) extp; 208 209 if (in->_n._n_name[0] == 0) 210 { 211 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes); 212 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset); 213 } 214 else 215 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN); 216 217 H_PUT_32 (abfd, in->n_value, ext->e_value); 218 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum); 219 220 if (sizeof (ext->e_type) == 2) 221 H_PUT_16 (abfd, in->n_type, ext->e_type); 222 else 223 H_PUT_32 (abfd, in->n_type, ext->e_type); 224 225 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass); 226 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux); 227 228 return SYMESZ; 229 } 230 231 void 232 _bfd_XXi_swap_aux_in (bfd * abfd, 233 void * ext1, 234 int type, 235 int in_class, 236 int indx ATTRIBUTE_UNUSED, 237 int numaux ATTRIBUTE_UNUSED, 238 void * in1) 239 { 240 AUXENT *ext = (AUXENT *) ext1; 241 union internal_auxent *in = (union internal_auxent *) in1; 242 243 switch (in_class) 244 { 245 case C_FILE: 246 if (ext->x_file.x_fname[0] == 0) 247 { 248 in->x_file.x_n.x_zeroes = 0; 249 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset); 250 } 251 else 252 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN); 253 return; 254 255 case C_STAT: 256 case C_LEAFSTAT: 257 case C_HIDDEN: 258 if (type == T_NULL) 259 { 260 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext); 261 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext); 262 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext); 263 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum); 264 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated); 265 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat); 266 return; 267 } 268 break; 269 } 270 271 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx); 272 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx); 273 274 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type) 275 || ISTAG (in_class)) 276 { 277 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext); 278 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext); 279 } 280 else 281 { 282 in->x_sym.x_fcnary.x_ary.x_dimen[0] = 283 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]); 284 in->x_sym.x_fcnary.x_ary.x_dimen[1] = 285 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]); 286 in->x_sym.x_fcnary.x_ary.x_dimen[2] = 287 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]); 288 in->x_sym.x_fcnary.x_ary.x_dimen[3] = 289 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]); 290 } 291 292 if (ISFCN (type)) 293 { 294 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize); 295 } 296 else 297 { 298 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext); 299 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext); 300 } 301 } 302 303 unsigned int 304 _bfd_XXi_swap_aux_out (bfd * abfd, 305 void * inp, 306 int type, 307 int in_class, 308 int indx ATTRIBUTE_UNUSED, 309 int numaux ATTRIBUTE_UNUSED, 310 void * extp) 311 { 312 union internal_auxent *in = (union internal_auxent *) inp; 313 AUXENT *ext = (AUXENT *) extp; 314 315 memset (ext, 0, AUXESZ); 316 317 switch (in_class) 318 { 319 case C_FILE: 320 if (in->x_file.x_fname[0] == 0) 321 { 322 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes); 323 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset); 324 } 325 else 326 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN); 327 328 return AUXESZ; 329 330 case C_STAT: 331 case C_LEAFSTAT: 332 case C_HIDDEN: 333 if (type == T_NULL) 334 { 335 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext); 336 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext); 337 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext); 338 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum); 339 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated); 340 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat); 341 return AUXESZ; 342 } 343 break; 344 } 345 346 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx); 347 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx); 348 349 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type) 350 || ISTAG (in_class)) 351 { 352 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext); 353 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext); 354 } 355 else 356 { 357 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0], 358 ext->x_sym.x_fcnary.x_ary.x_dimen[0]); 359 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1], 360 ext->x_sym.x_fcnary.x_ary.x_dimen[1]); 361 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2], 362 ext->x_sym.x_fcnary.x_ary.x_dimen[2]); 363 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3], 364 ext->x_sym.x_fcnary.x_ary.x_dimen[3]); 365 } 366 367 if (ISFCN (type)) 368 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize); 369 else 370 { 371 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext); 372 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext); 373 } 374 375 return AUXESZ; 376 } 377 378 void 379 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1) 380 { 381 LINENO *ext = (LINENO *) ext1; 382 struct internal_lineno *in = (struct internal_lineno *) in1; 383 384 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx); 385 in->l_lnno = GET_LINENO_LNNO (abfd, ext); 386 } 387 388 unsigned int 389 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp) 390 { 391 struct internal_lineno *in = (struct internal_lineno *) inp; 392 struct external_lineno *ext = (struct external_lineno *) outp; 393 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx); 394 395 PUT_LINENO_LNNO (abfd, in->l_lnno, ext); 396 return LINESZ; 397 } 398 399 void 400 _bfd_XXi_swap_aouthdr_in (bfd * abfd, 401 void * aouthdr_ext1, 402 void * aouthdr_int1) 403 { 404 PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1; 405 AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1; 406 struct internal_aouthdr *aouthdr_int 407 = (struct internal_aouthdr *) aouthdr_int1; 408 struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe; 409 410 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic); 411 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp); 412 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize); 413 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize); 414 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize); 415 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry); 416 aouthdr_int->text_start = 417 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start); 418 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 419 /* PE32+ does not have data_start member! */ 420 aouthdr_int->data_start = 421 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start); 422 a->BaseOfData = aouthdr_int->data_start; 423 #endif 424 425 a->Magic = aouthdr_int->magic; 426 a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp); 427 a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1); 428 a->SizeOfCode = aouthdr_int->tsize ; 429 a->SizeOfInitializedData = aouthdr_int->dsize ; 430 a->SizeOfUninitializedData = aouthdr_int->bsize ; 431 a->AddressOfEntryPoint = aouthdr_int->entry; 432 a->BaseOfCode = aouthdr_int->text_start; 433 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase); 434 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment); 435 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment); 436 a->MajorOperatingSystemVersion = 437 H_GET_16 (abfd, src->MajorOperatingSystemVersion); 438 a->MinorOperatingSystemVersion = 439 H_GET_16 (abfd, src->MinorOperatingSystemVersion); 440 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion); 441 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion); 442 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion); 443 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion); 444 a->Reserved1 = H_GET_32 (abfd, src->Reserved1); 445 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage); 446 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders); 447 a->CheckSum = H_GET_32 (abfd, src->CheckSum); 448 a->Subsystem = H_GET_16 (abfd, src->Subsystem); 449 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics); 450 a->SizeOfStackReserve = 451 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve); 452 a->SizeOfStackCommit = 453 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit); 454 a->SizeOfHeapReserve = 455 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve); 456 a->SizeOfHeapCommit = 457 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit); 458 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags); 459 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes); 460 461 { 462 int idx; 463 464 for (idx = 0; idx < 16; idx++) 465 { 466 /* If data directory is empty, rva also should be 0. */ 467 int size = 468 H_GET_32 (abfd, src->DataDirectory[idx][1]); 469 470 a->DataDirectory[idx].Size = size; 471 472 if (size) 473 a->DataDirectory[idx].VirtualAddress = 474 H_GET_32 (abfd, src->DataDirectory[idx][0]); 475 else 476 a->DataDirectory[idx].VirtualAddress = 0; 477 } 478 } 479 480 if (aouthdr_int->entry) 481 { 482 aouthdr_int->entry += a->ImageBase; 483 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 484 aouthdr_int->entry &= 0xffffffff; 485 #endif 486 } 487 488 if (aouthdr_int->tsize) 489 { 490 aouthdr_int->text_start += a->ImageBase; 491 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 492 aouthdr_int->text_start &= 0xffffffff; 493 #endif 494 } 495 496 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 497 /* PE32+ does not have data_start member! */ 498 if (aouthdr_int->dsize) 499 { 500 aouthdr_int->data_start += a->ImageBase; 501 aouthdr_int->data_start &= 0xffffffff; 502 } 503 #endif 504 505 #ifdef POWERPC_LE_PE 506 /* These three fields are normally set up by ppc_relocate_section. 507 In the case of reading a file in, we can pick them up from the 508 DataDirectory. */ 509 first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress; 510 thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size; 511 import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size; 512 #endif 513 } 514 515 /* A support function for below. */ 516 517 static void 518 add_data_entry (bfd * abfd, 519 struct internal_extra_pe_aouthdr *aout, 520 int idx, 521 char *name, 522 bfd_vma base) 523 { 524 asection *sec = bfd_get_section_by_name (abfd, name); 525 526 /* Add import directory information if it exists. */ 527 if ((sec != NULL) 528 && (coff_section_data (abfd, sec) != NULL) 529 && (pei_section_data (abfd, sec) != NULL)) 530 { 531 /* If data directory is empty, rva also should be 0. */ 532 int size = pei_section_data (abfd, sec)->virt_size; 533 aout->DataDirectory[idx].Size = size; 534 535 if (size) 536 { 537 aout->DataDirectory[idx].VirtualAddress = 538 (sec->vma - base) & 0xffffffff; 539 sec->flags |= SEC_DATA; 540 } 541 } 542 } 543 544 unsigned int 545 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out) 546 { 547 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in; 548 pe_data_type *pe = pe_data (abfd); 549 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr; 550 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out; 551 bfd_vma sa, fa, ib; 552 IMAGE_DATA_DIRECTORY idata2, idata5, tls; 553 554 sa = extra->SectionAlignment; 555 fa = extra->FileAlignment; 556 ib = extra->ImageBase; 557 558 idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE]; 559 idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE]; 560 tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE]; 561 562 if (aouthdr_in->tsize) 563 { 564 aouthdr_in->text_start -= ib; 565 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 566 aouthdr_in->text_start &= 0xffffffff; 567 #endif 568 } 569 570 if (aouthdr_in->dsize) 571 { 572 aouthdr_in->data_start -= ib; 573 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 574 aouthdr_in->data_start &= 0xffffffff; 575 #endif 576 } 577 578 if (aouthdr_in->entry) 579 { 580 aouthdr_in->entry -= ib; 581 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 582 aouthdr_in->entry &= 0xffffffff; 583 #endif 584 } 585 586 #define FA(x) (((x) + fa -1 ) & (- fa)) 587 #define SA(x) (((x) + sa -1 ) & (- sa)) 588 589 /* We like to have the sizes aligned. */ 590 aouthdr_in->bsize = FA (aouthdr_in->bsize); 591 592 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES; 593 594 /* First null out all data directory entries. */ 595 memset (extra->DataDirectory, 0, sizeof (extra->DataDirectory)); 596 597 add_data_entry (abfd, extra, 0, ".edata", ib); 598 add_data_entry (abfd, extra, 2, ".rsrc", ib); 599 add_data_entry (abfd, extra, 3, ".pdata", ib); 600 601 /* In theory we do not need to call add_data_entry for .idata$2 or 602 .idata$5. It will be done in bfd_coff_final_link where all the 603 required information is available. If however, we are not going 604 to perform a final link, eg because we have been invoked by objcopy 605 or strip, then we need to make sure that these Data Directory 606 entries are initialised properly. 607 608 So - we copy the input values into the output values, and then, if 609 a final link is going to be performed, it can overwrite them. */ 610 extra->DataDirectory[PE_IMPORT_TABLE] = idata2; 611 extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5; 612 extra->DataDirectory[PE_TLS_TABLE] = tls; 613 614 if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0) 615 /* Until other .idata fixes are made (pending patch), the entry for 616 .idata is needed for backwards compatibility. FIXME. */ 617 add_data_entry (abfd, extra, 1, ".idata", ib); 618 619 /* For some reason, the virtual size (which is what's set by 620 add_data_entry) for .reloc is not the same as the size recorded 621 in this slot by MSVC; it doesn't seem to cause problems (so far), 622 but since it's the best we've got, use it. It does do the right 623 thing for .pdata. */ 624 if (pe->has_reloc_section) 625 add_data_entry (abfd, extra, 5, ".reloc", ib); 626 627 { 628 asection *sec; 629 bfd_vma hsize = 0; 630 bfd_vma dsize = 0; 631 bfd_vma isize = 0; 632 bfd_vma tsize = 0; 633 634 for (sec = abfd->sections; sec; sec = sec->next) 635 { 636 int rounded = FA (sec->size); 637 638 /* The first non-zero section filepos is the header size. 639 Sections without contents will have a filepos of 0. */ 640 if (hsize == 0) 641 hsize = sec->filepos; 642 if (sec->flags & SEC_DATA) 643 dsize += rounded; 644 if (sec->flags & SEC_CODE) 645 tsize += rounded; 646 /* The image size is the total VIRTUAL size (which is what is 647 in the virt_size field). Files have been seen (from MSVC 648 5.0 link.exe) where the file size of the .data segment is 649 quite small compared to the virtual size. Without this 650 fix, strip munges the file. 651 652 FIXME: We need to handle holes between sections, which may 653 happpen when we covert from another format. We just use 654 the virtual address and virtual size of the last section 655 for the image size. */ 656 if (coff_section_data (abfd, sec) != NULL 657 && pei_section_data (abfd, sec) != NULL) 658 isize = (sec->vma - extra->ImageBase 659 + SA (FA (pei_section_data (abfd, sec)->virt_size))); 660 } 661 662 aouthdr_in->dsize = dsize; 663 aouthdr_in->tsize = tsize; 664 extra->SizeOfHeaders = hsize; 665 extra->SizeOfImage = isize; 666 } 667 668 H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic); 669 670 /* e.g. 219510000 is linker version 2.19 */ 671 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000)) 672 673 /* This piece of magic sets the "linker version" field to 674 LINKER_VERSION. */ 675 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256), 676 aouthdr_out->standard.vstamp); 677 678 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize); 679 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize); 680 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize); 681 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry); 682 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start, 683 aouthdr_out->standard.text_start); 684 685 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 686 /* PE32+ does not have data_start member! */ 687 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start, 688 aouthdr_out->standard.data_start); 689 #endif 690 691 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase); 692 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment); 693 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment); 694 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion, 695 aouthdr_out->MajorOperatingSystemVersion); 696 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion, 697 aouthdr_out->MinorOperatingSystemVersion); 698 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion); 699 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion); 700 H_PUT_16 (abfd, extra->MajorSubsystemVersion, 701 aouthdr_out->MajorSubsystemVersion); 702 H_PUT_16 (abfd, extra->MinorSubsystemVersion, 703 aouthdr_out->MinorSubsystemVersion); 704 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1); 705 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage); 706 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders); 707 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum); 708 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem); 709 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics); 710 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve, 711 aouthdr_out->SizeOfStackReserve); 712 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit, 713 aouthdr_out->SizeOfStackCommit); 714 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve, 715 aouthdr_out->SizeOfHeapReserve); 716 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit, 717 aouthdr_out->SizeOfHeapCommit); 718 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags); 719 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes, 720 aouthdr_out->NumberOfRvaAndSizes); 721 { 722 int idx; 723 724 for (idx = 0; idx < 16; idx++) 725 { 726 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress, 727 aouthdr_out->DataDirectory[idx][0]); 728 H_PUT_32 (abfd, extra->DataDirectory[idx].Size, 729 aouthdr_out->DataDirectory[idx][1]); 730 } 731 } 732 733 return AOUTSZ; 734 } 735 736 unsigned int 737 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out) 738 { 739 int idx; 740 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in; 741 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out; 742 743 if (pe_data (abfd)->has_reloc_section 744 || pe_data (abfd)->dont_strip_reloc) 745 filehdr_in->f_flags &= ~F_RELFLG; 746 747 if (pe_data (abfd)->dll) 748 filehdr_in->f_flags |= F_DLL; 749 750 filehdr_in->pe.e_magic = DOSMAGIC; 751 filehdr_in->pe.e_cblp = 0x90; 752 filehdr_in->pe.e_cp = 0x3; 753 filehdr_in->pe.e_crlc = 0x0; 754 filehdr_in->pe.e_cparhdr = 0x4; 755 filehdr_in->pe.e_minalloc = 0x0; 756 filehdr_in->pe.e_maxalloc = 0xffff; 757 filehdr_in->pe.e_ss = 0x0; 758 filehdr_in->pe.e_sp = 0xb8; 759 filehdr_in->pe.e_csum = 0x0; 760 filehdr_in->pe.e_ip = 0x0; 761 filehdr_in->pe.e_cs = 0x0; 762 filehdr_in->pe.e_lfarlc = 0x40; 763 filehdr_in->pe.e_ovno = 0x0; 764 765 for (idx = 0; idx < 4; idx++) 766 filehdr_in->pe.e_res[idx] = 0x0; 767 768 filehdr_in->pe.e_oemid = 0x0; 769 filehdr_in->pe.e_oeminfo = 0x0; 770 771 for (idx = 0; idx < 10; idx++) 772 filehdr_in->pe.e_res2[idx] = 0x0; 773 774 filehdr_in->pe.e_lfanew = 0x80; 775 776 /* This next collection of data are mostly just characters. It 777 appears to be constant within the headers put on NT exes. */ 778 filehdr_in->pe.dos_message[0] = 0x0eba1f0e; 779 filehdr_in->pe.dos_message[1] = 0xcd09b400; 780 filehdr_in->pe.dos_message[2] = 0x4c01b821; 781 filehdr_in->pe.dos_message[3] = 0x685421cd; 782 filehdr_in->pe.dos_message[4] = 0x70207369; 783 filehdr_in->pe.dos_message[5] = 0x72676f72; 784 filehdr_in->pe.dos_message[6] = 0x63206d61; 785 filehdr_in->pe.dos_message[7] = 0x6f6e6e61; 786 filehdr_in->pe.dos_message[8] = 0x65622074; 787 filehdr_in->pe.dos_message[9] = 0x6e757220; 788 filehdr_in->pe.dos_message[10] = 0x206e6920; 789 filehdr_in->pe.dos_message[11] = 0x20534f44; 790 filehdr_in->pe.dos_message[12] = 0x65646f6d; 791 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e; 792 filehdr_in->pe.dos_message[14] = 0x24; 793 filehdr_in->pe.dos_message[15] = 0x0; 794 filehdr_in->pe.nt_signature = NT_SIGNATURE; 795 796 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic); 797 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns); 798 799 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat); 800 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, 801 filehdr_out->f_symptr); 802 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms); 803 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr); 804 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags); 805 806 /* Put in extra dos header stuff. This data remains essentially 807 constant, it just has to be tacked on to the beginning of all exes 808 for NT. */ 809 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic); 810 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp); 811 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp); 812 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc); 813 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr); 814 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc); 815 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc); 816 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss); 817 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp); 818 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum); 819 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip); 820 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs); 821 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc); 822 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno); 823 824 for (idx = 0; idx < 4; idx++) 825 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]); 826 827 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid); 828 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo); 829 830 for (idx = 0; idx < 10; idx++) 831 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]); 832 833 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew); 834 835 for (idx = 0; idx < 16; idx++) 836 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx], 837 filehdr_out->dos_message[idx]); 838 839 /* Also put in the NT signature. */ 840 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature); 841 842 return FILHSZ; 843 } 844 845 unsigned int 846 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out) 847 { 848 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in; 849 FILHDR *filehdr_out = (FILHDR *) out; 850 851 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic); 852 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns); 853 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat); 854 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr); 855 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms); 856 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr); 857 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags); 858 859 return FILHSZ; 860 } 861 862 unsigned int 863 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out) 864 { 865 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in; 866 SCNHDR *scnhdr_ext = (SCNHDR *) out; 867 unsigned int ret = SCNHSZ; 868 bfd_vma ps; 869 bfd_vma ss; 870 871 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name)); 872 873 PUT_SCNHDR_VADDR (abfd, 874 ((scnhdr_int->s_vaddr 875 - pe_data (abfd)->pe_opthdr.ImageBase) 876 & 0xffffffff), 877 scnhdr_ext->s_vaddr); 878 879 /* NT wants the size data to be rounded up to the next 880 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss, 881 sometimes). */ 882 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0) 883 { 884 if (bfd_pei_p (abfd)) 885 { 886 ps = scnhdr_int->s_size; 887 ss = 0; 888 } 889 else 890 { 891 ps = 0; 892 ss = scnhdr_int->s_size; 893 } 894 } 895 else 896 { 897 if (bfd_pei_p (abfd)) 898 ps = scnhdr_int->s_paddr; 899 else 900 ps = 0; 901 902 ss = scnhdr_int->s_size; 903 } 904 905 PUT_SCNHDR_SIZE (abfd, ss, 906 scnhdr_ext->s_size); 907 908 /* s_paddr in PE is really the virtual size. */ 909 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr); 910 911 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr, 912 scnhdr_ext->s_scnptr); 913 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr, 914 scnhdr_ext->s_relptr); 915 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr, 916 scnhdr_ext->s_lnnoptr); 917 918 { 919 /* Extra flags must be set when dealing with PE. All sections should also 920 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the 921 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data 922 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set 923 (this is especially important when dealing with the .idata section since 924 the addresses for routines from .dlls must be overwritten). If .reloc 925 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE 926 (0x02000000). Also, the resource data should also be read and 927 writable. */ 928 929 /* FIXME: Alignment is also encoded in this field, at least on PPC and 930 ARM-WINCE. Although - how do we get the original alignment field 931 back ? */ 932 933 typedef struct 934 { 935 const char * section_name; 936 unsigned long must_have; 937 } 938 pe_required_section_flags; 939 940 pe_required_section_flags known_sections [] = 941 { 942 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES }, 943 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 944 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 945 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA }, 946 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 947 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA }, 948 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA }, 949 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE }, 950 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 951 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE }, 952 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 953 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA }, 954 { NULL, 0} 955 }; 956 957 pe_required_section_flags * p; 958 959 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now 960 we know exactly what this specific section wants so we remove it 961 and then allow the must_have field to add it back in if necessary. 962 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the 963 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared 964 by ld --enable-auto-import (if auto-import is actually needed), 965 by ld --omagic, or by obcopy --writable-text. */ 966 967 for (p = known_sections; p->section_name; p++) 968 if (strcmp (scnhdr_int->s_name, p->section_name) == 0) 969 { 970 if (strcmp (scnhdr_int->s_name, ".text") 971 || (bfd_get_file_flags (abfd) & WP_TEXT)) 972 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE; 973 scnhdr_int->s_flags |= p->must_have; 974 break; 975 } 976 977 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags); 978 } 979 980 if (coff_data (abfd)->link_info 981 && ! coff_data (abfd)->link_info->relocatable 982 && ! coff_data (abfd)->link_info->shared 983 && strcmp (scnhdr_int->s_name, ".text") == 0) 984 { 985 /* By inference from looking at MS output, the 32 bit field 986 which is the combination of the number_of_relocs and 987 number_of_linenos is used for the line number count in 988 executables. A 16-bit field won't do for cc1. The MS 989 document says that the number of relocs is zero for 990 executables, but the 17-th bit has been observed to be there. 991 Overflow is not an issue: a 4G-line program will overflow a 992 bunch of other fields long before this! */ 993 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno); 994 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc); 995 } 996 else 997 { 998 if (scnhdr_int->s_nlnno <= 0xffff) 999 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno); 1000 else 1001 { 1002 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"), 1003 bfd_get_filename (abfd), 1004 scnhdr_int->s_nlnno); 1005 bfd_set_error (bfd_error_file_truncated); 1006 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno); 1007 ret = 0; 1008 } 1009 1010 /* Although we could encode 0xffff relocs here, we do not, to be 1011 consistent with other parts of bfd. Also it lets us warn, as 1012 we should never see 0xffff here w/o having the overflow flag 1013 set. */ 1014 if (scnhdr_int->s_nreloc < 0xffff) 1015 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc); 1016 else 1017 { 1018 /* PE can deal with large #s of relocs, but not here. */ 1019 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc); 1020 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL; 1021 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags); 1022 } 1023 } 1024 return ret; 1025 } 1026 1027 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] = 1028 { 1029 N_("Export Directory [.edata (or where ever we found it)]"), 1030 N_("Import Directory [parts of .idata]"), 1031 N_("Resource Directory [.rsrc]"), 1032 N_("Exception Directory [.pdata]"), 1033 N_("Security Directory"), 1034 N_("Base Relocation Directory [.reloc]"), 1035 N_("Debug Directory"), 1036 N_("Description Directory"), 1037 N_("Special Directory"), 1038 N_("Thread Storage Directory [.tls]"), 1039 N_("Load Configuration Directory"), 1040 N_("Bound Import Directory"), 1041 N_("Import Address Table Directory"), 1042 N_("Delay Import Directory"), 1043 N_("CLR Runtime Header"), 1044 N_("Reserved") 1045 }; 1046 1047 #ifdef POWERPC_LE_PE 1048 /* The code for the PPC really falls in the "architecture dependent" 1049 category. However, it's not clear that anyone will ever care, so 1050 we're ignoring the issue for now; if/when PPC matters, some of this 1051 may need to go into peicode.h, or arguments passed to enable the 1052 PPC- specific code. */ 1053 #endif 1054 1055 static bfd_boolean 1056 pe_print_idata (bfd * abfd, void * vfile) 1057 { 1058 FILE *file = (FILE *) vfile; 1059 bfd_byte *data; 1060 asection *section; 1061 bfd_signed_vma adj; 1062 1063 #ifdef POWERPC_LE_PE 1064 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata"); 1065 #endif 1066 1067 bfd_size_type datasize = 0; 1068 bfd_size_type dataoff; 1069 bfd_size_type i; 1070 int onaline = 20; 1071 1072 pe_data_type *pe = pe_data (abfd); 1073 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr; 1074 1075 bfd_vma addr; 1076 1077 addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress; 1078 1079 if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0) 1080 { 1081 /* Maybe the extra header isn't there. Look for the section. */ 1082 section = bfd_get_section_by_name (abfd, ".idata"); 1083 if (section == NULL) 1084 return TRUE; 1085 1086 addr = section->vma; 1087 datasize = section->size; 1088 if (datasize == 0) 1089 return TRUE; 1090 } 1091 else 1092 { 1093 addr += extra->ImageBase; 1094 for (section = abfd->sections; section != NULL; section = section->next) 1095 { 1096 datasize = section->size; 1097 if (addr >= section->vma && addr < section->vma + datasize) 1098 break; 1099 } 1100 1101 if (section == NULL) 1102 { 1103 fprintf (file, 1104 _("\nThere is an import table, but the section containing it could not be found\n")); 1105 return TRUE; 1106 } 1107 } 1108 1109 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"), 1110 section->name, (unsigned long) addr); 1111 1112 dataoff = addr - section->vma; 1113 1114 #ifdef POWERPC_LE_PE 1115 if (rel_section != 0 && rel_section->size != 0) 1116 { 1117 /* The toc address can be found by taking the starting address, 1118 which on the PPC locates a function descriptor. The 1119 descriptor consists of the function code starting address 1120 followed by the address of the toc. The starting address we 1121 get from the bfd, and the descriptor is supposed to be in the 1122 .reldata section. */ 1123 1124 bfd_vma loadable_toc_address; 1125 bfd_vma toc_address; 1126 bfd_vma start_address; 1127 bfd_byte *data; 1128 bfd_vma offset; 1129 1130 if (!bfd_malloc_and_get_section (abfd, rel_section, &data)) 1131 { 1132 if (data != NULL) 1133 free (data); 1134 return FALSE; 1135 } 1136 1137 offset = abfd->start_address - rel_section->vma; 1138 1139 if (offset >= rel_section->size || offset + 8 > rel_section->size) 1140 { 1141 if (data != NULL) 1142 free (data); 1143 return FALSE; 1144 } 1145 1146 start_address = bfd_get_32 (abfd, data + offset); 1147 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4); 1148 toc_address = loadable_toc_address - 32768; 1149 1150 fprintf (file, 1151 _("\nFunction descriptor located at the start address: %04lx\n"), 1152 (unsigned long int) (abfd->start_address)); 1153 fprintf (file, 1154 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"), 1155 start_address, loadable_toc_address, toc_address); 1156 if (data != NULL) 1157 free (data); 1158 } 1159 else 1160 { 1161 fprintf (file, 1162 _("\nNo reldata section! Function descriptor not decoded.\n")); 1163 } 1164 #endif 1165 1166 fprintf (file, 1167 _("\nThe Import Tables (interpreted %s section contents)\n"), 1168 section->name); 1169 fprintf (file, 1170 _("\ 1171 vma: Hint Time Forward DLL First\n\ 1172 Table Stamp Chain Name Thunk\n")); 1173 1174 /* Read the whole section. Some of the fields might be before dataoff. */ 1175 if (!bfd_malloc_and_get_section (abfd, section, &data)) 1176 { 1177 if (data != NULL) 1178 free (data); 1179 return FALSE; 1180 } 1181 1182 adj = section->vma - extra->ImageBase; 1183 1184 /* Print all image import descriptors. */ 1185 for (i = dataoff; i + onaline <= datasize; i += onaline) 1186 { 1187 bfd_vma hint_addr; 1188 bfd_vma time_stamp; 1189 bfd_vma forward_chain; 1190 bfd_vma dll_name; 1191 bfd_vma first_thunk; 1192 int idx = 0; 1193 bfd_size_type j; 1194 char *dll; 1195 1196 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */ 1197 fprintf (file, " %08lx\t", (unsigned long) (i + adj)); 1198 hint_addr = bfd_get_32 (abfd, data + i); 1199 time_stamp = bfd_get_32 (abfd, data + i + 4); 1200 forward_chain = bfd_get_32 (abfd, data + i + 8); 1201 dll_name = bfd_get_32 (abfd, data + i + 12); 1202 first_thunk = bfd_get_32 (abfd, data + i + 16); 1203 1204 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n", 1205 (unsigned long) hint_addr, 1206 (unsigned long) time_stamp, 1207 (unsigned long) forward_chain, 1208 (unsigned long) dll_name, 1209 (unsigned long) first_thunk); 1210 1211 if (hint_addr == 0 && first_thunk == 0) 1212 break; 1213 1214 if (dll_name - adj >= section->size) 1215 break; 1216 1217 dll = (char *) data + dll_name - adj; 1218 fprintf (file, _("\n\tDLL Name: %s\n"), dll); 1219 1220 if (hint_addr != 0) 1221 { 1222 bfd_byte *ft_data; 1223 asection *ft_section; 1224 bfd_vma ft_addr; 1225 bfd_size_type ft_datasize; 1226 int ft_idx; 1227 int ft_allocated; 1228 1229 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n")); 1230 1231 idx = hint_addr - adj; 1232 1233 ft_addr = first_thunk + extra->ImageBase; 1234 ft_idx = first_thunk - adj; 1235 ft_data = data + ft_idx; 1236 ft_datasize = datasize - ft_idx; 1237 ft_allocated = 0; 1238 1239 if (first_thunk != hint_addr) 1240 { 1241 /* Find the section which contains the first thunk. */ 1242 for (ft_section = abfd->sections; 1243 ft_section != NULL; 1244 ft_section = ft_section->next) 1245 { 1246 if (ft_addr >= ft_section->vma 1247 && ft_addr < ft_section->vma + ft_section->size) 1248 break; 1249 } 1250 1251 if (ft_section == NULL) 1252 { 1253 fprintf (file, 1254 _("\nThere is a first thunk, but the section containing it could not be found\n")); 1255 continue; 1256 } 1257 1258 /* Now check to see if this section is the same as our current 1259 section. If it is not then we will have to load its data in. */ 1260 if (ft_section != section) 1261 { 1262 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase); 1263 ft_datasize = ft_section->size - ft_idx; 1264 ft_data = (bfd_byte *) bfd_malloc (ft_datasize); 1265 if (ft_data == NULL) 1266 continue; 1267 1268 /* Read ft_datasize bytes starting at offset ft_idx. */ 1269 if (!bfd_get_section_contents (abfd, ft_section, ft_data, 1270 (bfd_vma) ft_idx, ft_datasize)) 1271 { 1272 free (ft_data); 1273 continue; 1274 } 1275 ft_allocated = 1; 1276 } 1277 } 1278 1279 /* Print HintName vector entries. */ 1280 #ifdef COFF_WITH_pex64 1281 for (j = 0; idx + j + 8 <= datasize; j += 8) 1282 { 1283 unsigned long member = bfd_get_32 (abfd, data + idx + j); 1284 unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4); 1285 1286 if (!member && !member_high) 1287 break; 1288 1289 if (member_high & 0x80000000) 1290 fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>", 1291 member_high,member, member_high & 0x7fffffff, member); 1292 else 1293 { 1294 int ordinal; 1295 char *member_name; 1296 1297 ordinal = bfd_get_16 (abfd, data + member - adj); 1298 member_name = (char *) data + member - adj + 2; 1299 fprintf (file, "\t%04lx\t %4d %s",member, ordinal, member_name); 1300 } 1301 1302 /* If the time stamp is not zero, the import address 1303 table holds actual addresses. */ 1304 if (time_stamp != 0 1305 && first_thunk != 0 1306 && first_thunk != hint_addr 1307 && j + 4 <= ft_datasize) 1308 fprintf (file, "\t%04lx", 1309 (unsigned long) bfd_get_32 (abfd, ft_data + j)); 1310 fprintf (file, "\n"); 1311 } 1312 #else 1313 for (j = 0; idx + j + 4 <= datasize; j += 4) 1314 { 1315 unsigned long member = bfd_get_32 (abfd, data + idx + j); 1316 1317 /* Print single IMAGE_IMPORT_BY_NAME vector. */ 1318 if (member == 0) 1319 break; 1320 1321 if (member & 0x80000000) 1322 fprintf (file, "\t%04lx\t %4lu <none>", 1323 member, member & 0x7fffffff); 1324 else 1325 { 1326 int ordinal; 1327 char *member_name; 1328 1329 ordinal = bfd_get_16 (abfd, data + member - adj); 1330 member_name = (char *) data + member - adj + 2; 1331 fprintf (file, "\t%04lx\t %4d %s", 1332 member, ordinal, member_name); 1333 } 1334 1335 /* If the time stamp is not zero, the import address 1336 table holds actual addresses. */ 1337 if (time_stamp != 0 1338 && first_thunk != 0 1339 && first_thunk != hint_addr 1340 && j + 4 <= ft_datasize) 1341 fprintf (file, "\t%04lx", 1342 (unsigned long) bfd_get_32 (abfd, ft_data + j)); 1343 1344 fprintf (file, "\n"); 1345 } 1346 #endif 1347 if (ft_allocated) 1348 free (ft_data); 1349 } 1350 1351 fprintf (file, "\n"); 1352 } 1353 1354 free (data); 1355 1356 return TRUE; 1357 } 1358 1359 static bfd_boolean 1360 pe_print_edata (bfd * abfd, void * vfile) 1361 { 1362 FILE *file = (FILE *) vfile; 1363 bfd_byte *data; 1364 asection *section; 1365 bfd_size_type datasize = 0; 1366 bfd_size_type dataoff; 1367 bfd_size_type i; 1368 bfd_signed_vma adj; 1369 struct EDT_type 1370 { 1371 long export_flags; /* Reserved - should be zero. */ 1372 long time_stamp; 1373 short major_ver; 1374 short minor_ver; 1375 bfd_vma name; /* RVA - relative to image base. */ 1376 long base; /* Ordinal base. */ 1377 unsigned long num_functions;/* Number in the export address table. */ 1378 unsigned long num_names; /* Number in the name pointer table. */ 1379 bfd_vma eat_addr; /* RVA to the export address table. */ 1380 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */ 1381 bfd_vma ot_addr; /* RVA to the Ordinal Table. */ 1382 } edt; 1383 1384 pe_data_type *pe = pe_data (abfd); 1385 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr; 1386 1387 bfd_vma addr; 1388 1389 addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress; 1390 1391 if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0) 1392 { 1393 /* Maybe the extra header isn't there. Look for the section. */ 1394 section = bfd_get_section_by_name (abfd, ".edata"); 1395 if (section == NULL) 1396 return TRUE; 1397 1398 addr = section->vma; 1399 dataoff = 0; 1400 datasize = section->size; 1401 if (datasize == 0) 1402 return TRUE; 1403 } 1404 else 1405 { 1406 addr += extra->ImageBase; 1407 1408 for (section = abfd->sections; section != NULL; section = section->next) 1409 if (addr >= section->vma && addr < section->vma + section->size) 1410 break; 1411 1412 if (section == NULL) 1413 { 1414 fprintf (file, 1415 _("\nThere is an export table, but the section containing it could not be found\n")); 1416 return TRUE; 1417 } 1418 1419 dataoff = addr - section->vma; 1420 datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size; 1421 if (datasize > section->size - dataoff) 1422 { 1423 fprintf (file, 1424 _("\nThere is an export table in %s, but it does not fit into that section\n"), 1425 section->name); 1426 return TRUE; 1427 } 1428 } 1429 1430 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"), 1431 section->name, (unsigned long) addr); 1432 1433 data = (bfd_byte *) bfd_malloc (datasize); 1434 if (data == NULL) 1435 return FALSE; 1436 1437 if (! bfd_get_section_contents (abfd, section, data, 1438 (file_ptr) dataoff, datasize)) 1439 return FALSE; 1440 1441 /* Go get Export Directory Table. */ 1442 edt.export_flags = bfd_get_32 (abfd, data + 0); 1443 edt.time_stamp = bfd_get_32 (abfd, data + 4); 1444 edt.major_ver = bfd_get_16 (abfd, data + 8); 1445 edt.minor_ver = bfd_get_16 (abfd, data + 10); 1446 edt.name = bfd_get_32 (abfd, data + 12); 1447 edt.base = bfd_get_32 (abfd, data + 16); 1448 edt.num_functions = bfd_get_32 (abfd, data + 20); 1449 edt.num_names = bfd_get_32 (abfd, data + 24); 1450 edt.eat_addr = bfd_get_32 (abfd, data + 28); 1451 edt.npt_addr = bfd_get_32 (abfd, data + 32); 1452 edt.ot_addr = bfd_get_32 (abfd, data + 36); 1453 1454 adj = section->vma - extra->ImageBase + dataoff; 1455 1456 /* Dump the EDT first. */ 1457 fprintf (file, 1458 _("\nThe Export Tables (interpreted %s section contents)\n\n"), 1459 section->name); 1460 1461 fprintf (file, 1462 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags); 1463 1464 fprintf (file, 1465 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp); 1466 1467 fprintf (file, 1468 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver); 1469 1470 fprintf (file, 1471 _("Name \t\t\t\t")); 1472 bfd_fprintf_vma (abfd, file, edt.name); 1473 fprintf (file, 1474 " %s\n", data + edt.name - adj); 1475 1476 fprintf (file, 1477 _("Ordinal Base \t\t\t%ld\n"), edt.base); 1478 1479 fprintf (file, 1480 _("Number in:\n")); 1481 1482 fprintf (file, 1483 _("\tExport Address Table \t\t%08lx\n"), 1484 edt.num_functions); 1485 1486 fprintf (file, 1487 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names); 1488 1489 fprintf (file, 1490 _("Table Addresses\n")); 1491 1492 fprintf (file, 1493 _("\tExport Address Table \t\t")); 1494 bfd_fprintf_vma (abfd, file, edt.eat_addr); 1495 fprintf (file, "\n"); 1496 1497 fprintf (file, 1498 _("\tName Pointer Table \t\t")); 1499 bfd_fprintf_vma (abfd, file, edt.npt_addr); 1500 fprintf (file, "\n"); 1501 1502 fprintf (file, 1503 _("\tOrdinal Table \t\t\t")); 1504 bfd_fprintf_vma (abfd, file, edt.ot_addr); 1505 fprintf (file, "\n"); 1506 1507 /* The next table to find is the Export Address Table. It's basically 1508 a list of pointers that either locate a function in this dll, or 1509 forward the call to another dll. Something like: 1510 typedef union 1511 { 1512 long export_rva; 1513 long forwarder_rva; 1514 } export_address_table_entry; */ 1515 1516 fprintf (file, 1517 _("\nExport Address Table -- Ordinal Base %ld\n"), 1518 edt.base); 1519 1520 for (i = 0; i < edt.num_functions; ++i) 1521 { 1522 bfd_vma eat_member = bfd_get_32 (abfd, 1523 data + edt.eat_addr + (i * 4) - adj); 1524 if (eat_member == 0) 1525 continue; 1526 1527 if (eat_member - adj <= datasize) 1528 { 1529 /* This rva is to a name (forwarding function) in our section. */ 1530 /* Should locate a function descriptor. */ 1531 fprintf (file, 1532 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n", 1533 (long) i, 1534 (long) (i + edt.base), 1535 (unsigned long) eat_member, 1536 _("Forwarder RVA"), 1537 data + eat_member - adj); 1538 } 1539 else 1540 { 1541 /* Should locate a function descriptor in the reldata section. */ 1542 fprintf (file, 1543 "\t[%4ld] +base[%4ld] %04lx %s\n", 1544 (long) i, 1545 (long) (i + edt.base), 1546 (unsigned long) eat_member, 1547 _("Export RVA")); 1548 } 1549 } 1550 1551 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */ 1552 /* Dump them in parallel for clarity. */ 1553 fprintf (file, 1554 _("\n[Ordinal/Name Pointer] Table\n")); 1555 1556 for (i = 0; i < edt.num_names; ++i) 1557 { 1558 bfd_vma name_ptr = bfd_get_32 (abfd, 1559 data + 1560 edt.npt_addr 1561 + (i*4) - adj); 1562 1563 char *name = (char *) data + name_ptr - adj; 1564 1565 bfd_vma ord = bfd_get_16 (abfd, 1566 data + 1567 edt.ot_addr 1568 + (i*2) - adj); 1569 fprintf (file, 1570 "\t[%4ld] %s\n", (long) ord, name); 1571 } 1572 1573 free (data); 1574 1575 return TRUE; 1576 } 1577 1578 /* This really is architecture dependent. On IA-64, a .pdata entry 1579 consists of three dwords containing relative virtual addresses that 1580 specify the start and end address of the code range the entry 1581 covers and the address of the corresponding unwind info data. 1582 1583 On ARM and SH-4, a compressed PDATA structure is used : 1584 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use 1585 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY. 1586 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx . 1587 1588 This is the version for uncompressed data. */ 1589 1590 static bfd_boolean 1591 pe_print_pdata (bfd * abfd, void * vfile) 1592 { 1593 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 1594 # define PDATA_ROW_SIZE (3 * 8) 1595 #else 1596 # define PDATA_ROW_SIZE (5 * 4) 1597 #endif 1598 FILE *file = (FILE *) vfile; 1599 bfd_byte *data = 0; 1600 asection *section = bfd_get_section_by_name (abfd, ".pdata"); 1601 bfd_size_type datasize = 0; 1602 bfd_size_type i; 1603 bfd_size_type start, stop; 1604 int onaline = PDATA_ROW_SIZE; 1605 1606 if (section == NULL 1607 || coff_section_data (abfd, section) == NULL 1608 || pei_section_data (abfd, section) == NULL) 1609 return TRUE; 1610 1611 stop = pei_section_data (abfd, section)->virt_size; 1612 if ((stop % onaline) != 0) 1613 fprintf (file, 1614 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"), 1615 (long) stop, onaline); 1616 1617 fprintf (file, 1618 _("\nThe Function Table (interpreted .pdata section contents)\n")); 1619 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 1620 fprintf (file, 1621 _(" vma:\t\t\tBegin Address End Address Unwind Info\n")); 1622 #else 1623 fprintf (file, _("\ 1624 vma:\t\tBegin End EH EH PrologEnd Exception\n\ 1625 \t\tAddress Address Handler Data Address Mask\n")); 1626 #endif 1627 1628 datasize = section->size; 1629 if (datasize == 0) 1630 return TRUE; 1631 1632 if (! bfd_malloc_and_get_section (abfd, section, &data)) 1633 { 1634 if (data != NULL) 1635 free (data); 1636 return FALSE; 1637 } 1638 1639 start = 0; 1640 1641 for (i = start; i < stop; i += onaline) 1642 { 1643 bfd_vma begin_addr; 1644 bfd_vma end_addr; 1645 bfd_vma eh_handler; 1646 bfd_vma eh_data; 1647 bfd_vma prolog_end_addr; 1648 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) 1649 int em_data; 1650 #endif 1651 1652 if (i + PDATA_ROW_SIZE > stop) 1653 break; 1654 1655 begin_addr = GET_PDATA_ENTRY (abfd, data + i ); 1656 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4); 1657 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8); 1658 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12); 1659 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16); 1660 1661 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0 1662 && eh_data == 0 && prolog_end_addr == 0) 1663 /* We are probably into the padding of the section now. */ 1664 break; 1665 1666 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) 1667 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3); 1668 #endif 1669 eh_handler &= ~(bfd_vma) 0x3; 1670 prolog_end_addr &= ~(bfd_vma) 0x3; 1671 1672 fputc (' ', file); 1673 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file); 1674 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file); 1675 bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file); 1676 bfd_fprintf_vma (abfd, file, eh_handler); 1677 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) 1678 fputc (' ', file); 1679 bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file); 1680 bfd_fprintf_vma (abfd, file, prolog_end_addr); 1681 fprintf (file, " %x", em_data); 1682 #endif 1683 1684 #ifdef POWERPC_LE_PE 1685 if (eh_handler == 0 && eh_data != 0) 1686 { 1687 /* Special bits here, although the meaning may be a little 1688 mysterious. The only one I know for sure is 0x03 1689 Code Significance 1690 0x00 None 1691 0x01 Register Save Millicode 1692 0x02 Register Restore Millicode 1693 0x03 Glue Code Sequence. */ 1694 switch (eh_data) 1695 { 1696 case 0x01: 1697 fprintf (file, _(" Register save millicode")); 1698 break; 1699 case 0x02: 1700 fprintf (file, _(" Register restore millicode")); 1701 break; 1702 case 0x03: 1703 fprintf (file, _(" Glue code sequence")); 1704 break; 1705 default: 1706 break; 1707 } 1708 } 1709 #endif 1710 fprintf (file, "\n"); 1711 } 1712 1713 free (data); 1714 1715 return TRUE; 1716 #undef PDATA_ROW_SIZE 1717 } 1718 1719 typedef struct sym_cache 1720 { 1721 int symcount; 1722 asymbol ** syms; 1723 } sym_cache; 1724 1725 static asymbol ** 1726 slurp_symtab (bfd *abfd, sym_cache *psc) 1727 { 1728 asymbol ** sy = NULL; 1729 long storage; 1730 1731 if (!(bfd_get_file_flags (abfd) & HAS_SYMS)) 1732 { 1733 psc->symcount = 0; 1734 return NULL; 1735 } 1736 1737 storage = bfd_get_symtab_upper_bound (abfd); 1738 if (storage < 0) 1739 return NULL; 1740 if (storage) 1741 sy = (asymbol **) bfd_malloc (storage); 1742 1743 psc->symcount = bfd_canonicalize_symtab (abfd, sy); 1744 if (psc->symcount < 0) 1745 return NULL; 1746 return sy; 1747 } 1748 1749 static const char * 1750 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc) 1751 { 1752 int i; 1753 1754 if (psc->syms == 0) 1755 psc->syms = slurp_symtab (abfd, psc); 1756 1757 for (i = 0; i < psc->symcount; i++) 1758 { 1759 if (psc->syms[i]->section->vma + psc->syms[i]->value == func) 1760 return psc->syms[i]->name; 1761 } 1762 1763 return NULL; 1764 } 1765 1766 static void 1767 cleanup_syms (sym_cache *psc) 1768 { 1769 psc->symcount = 0; 1770 free (psc->syms); 1771 psc->syms = NULL; 1772 } 1773 1774 /* This is the version for "compressed" pdata. */ 1775 1776 bfd_boolean 1777 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile) 1778 { 1779 # define PDATA_ROW_SIZE (2 * 4) 1780 FILE *file = (FILE *) vfile; 1781 bfd_byte *data = NULL; 1782 asection *section = bfd_get_section_by_name (abfd, ".pdata"); 1783 bfd_size_type datasize = 0; 1784 bfd_size_type i; 1785 bfd_size_type start, stop; 1786 int onaline = PDATA_ROW_SIZE; 1787 struct sym_cache cache = {0, 0} ; 1788 1789 if (section == NULL 1790 || coff_section_data (abfd, section) == NULL 1791 || pei_section_data (abfd, section) == NULL) 1792 return TRUE; 1793 1794 stop = pei_section_data (abfd, section)->virt_size; 1795 if ((stop % onaline) != 0) 1796 fprintf (file, 1797 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"), 1798 (long) stop, onaline); 1799 1800 fprintf (file, 1801 _("\nThe Function Table (interpreted .pdata section contents)\n")); 1802 1803 fprintf (file, _("\ 1804 vma:\t\tBegin Prolog Function Flags Exception EH\n\ 1805 \t\tAddress Length Length 32b exc Handler Data\n")); 1806 1807 datasize = section->size; 1808 if (datasize == 0) 1809 return TRUE; 1810 1811 if (! bfd_malloc_and_get_section (abfd, section, &data)) 1812 { 1813 if (data != NULL) 1814 free (data); 1815 return FALSE; 1816 } 1817 1818 start = 0; 1819 1820 for (i = start; i < stop; i += onaline) 1821 { 1822 bfd_vma begin_addr; 1823 bfd_vma other_data; 1824 bfd_vma prolog_length, function_length; 1825 int flag32bit, exception_flag; 1826 asection *tsection; 1827 1828 if (i + PDATA_ROW_SIZE > stop) 1829 break; 1830 1831 begin_addr = GET_PDATA_ENTRY (abfd, data + i ); 1832 other_data = GET_PDATA_ENTRY (abfd, data + i + 4); 1833 1834 if (begin_addr == 0 && other_data == 0) 1835 /* We are probably into the padding of the section now. */ 1836 break; 1837 1838 prolog_length = (other_data & 0x000000FF); 1839 function_length = (other_data & 0x3FFFFF00) >> 8; 1840 flag32bit = (int)((other_data & 0x40000000) >> 30); 1841 exception_flag = (int)((other_data & 0x80000000) >> 31); 1842 1843 fputc (' ', file); 1844 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file); 1845 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file); 1846 bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file); 1847 bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file); 1848 fprintf (file, "%2d %2d ", flag32bit, exception_flag); 1849 1850 /* Get the exception handler's address and the data passed from the 1851 .text section. This is really the data that belongs with the .pdata 1852 but got "compressed" out for the ARM and SH4 architectures. */ 1853 tsection = bfd_get_section_by_name (abfd, ".text"); 1854 if (tsection && coff_section_data (abfd, tsection) 1855 && pei_section_data (abfd, tsection)) 1856 { 1857 bfd_vma eh_off = (begin_addr - 8) - tsection->vma; 1858 bfd_byte *tdata; 1859 1860 tdata = (bfd_byte *) bfd_malloc (8); 1861 if (tdata) 1862 { 1863 if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8)) 1864 { 1865 bfd_vma eh, eh_data; 1866 1867 eh = bfd_get_32 (abfd, tdata); 1868 eh_data = bfd_get_32 (abfd, tdata + 4); 1869 fprintf (file, "%08x ", (unsigned int) eh); 1870 fprintf (file, "%08x", (unsigned int) eh_data); 1871 if (eh != 0) 1872 { 1873 const char *s = my_symbol_for_address (abfd, eh, &cache); 1874 1875 if (s) 1876 fprintf (file, " (%s) ", s); 1877 } 1878 } 1879 free (tdata); 1880 } 1881 } 1882 1883 fprintf (file, "\n"); 1884 } 1885 1886 free (data); 1887 1888 cleanup_syms (& cache); 1889 1890 return TRUE; 1891 #undef PDATA_ROW_SIZE 1892 } 1893 1894 1895 #define IMAGE_REL_BASED_HIGHADJ 4 1896 static const char * const tbl[] = 1897 { 1898 "ABSOLUTE", 1899 "HIGH", 1900 "LOW", 1901 "HIGHLOW", 1902 "HIGHADJ", 1903 "MIPS_JMPADDR", 1904 "SECTION", 1905 "REL32", 1906 "RESERVED1", 1907 "MIPS_JMPADDR16", 1908 "DIR64", 1909 "HIGH3ADJ", 1910 "UNKNOWN", /* MUST be last. */ 1911 }; 1912 1913 static bfd_boolean 1914 pe_print_reloc (bfd * abfd, void * vfile) 1915 { 1916 FILE *file = (FILE *) vfile; 1917 bfd_byte *data = 0; 1918 asection *section = bfd_get_section_by_name (abfd, ".reloc"); 1919 bfd_size_type i; 1920 bfd_size_type start, stop; 1921 1922 if (section == NULL) 1923 return TRUE; 1924 1925 if (section->size == 0) 1926 return TRUE; 1927 1928 fprintf (file, 1929 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n")); 1930 1931 if (! bfd_malloc_and_get_section (abfd, section, &data)) 1932 { 1933 if (data != NULL) 1934 free (data); 1935 return FALSE; 1936 } 1937 1938 start = 0; 1939 1940 stop = section->size; 1941 1942 for (i = start; i < stop;) 1943 { 1944 int j; 1945 bfd_vma virtual_address; 1946 long number, size; 1947 1948 /* The .reloc section is a sequence of blocks, with a header consisting 1949 of two 32 bit quantities, followed by a number of 16 bit entries. */ 1950 virtual_address = bfd_get_32 (abfd, data+i); 1951 size = bfd_get_32 (abfd, data+i+4); 1952 number = (size - 8) / 2; 1953 1954 if (size == 0) 1955 break; 1956 1957 fprintf (file, 1958 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"), 1959 (unsigned long) virtual_address, size, (unsigned long) size, number); 1960 1961 for (j = 0; j < number; ++j) 1962 { 1963 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2); 1964 unsigned int t = (e & 0xF000) >> 12; 1965 int off = e & 0x0FFF; 1966 1967 if (t >= sizeof (tbl) / sizeof (tbl[0])) 1968 t = (sizeof (tbl) / sizeof (tbl[0])) - 1; 1969 1970 fprintf (file, 1971 _("\treloc %4d offset %4x [%4lx] %s"), 1972 j, off, (unsigned long) (off + virtual_address), tbl[t]); 1973 1974 /* HIGHADJ takes an argument, - the next record *is* the 1975 low 16 bits of addend. */ 1976 if (t == IMAGE_REL_BASED_HIGHADJ) 1977 { 1978 fprintf (file, " (%4x)", 1979 ((unsigned int) 1980 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2))); 1981 j++; 1982 } 1983 1984 fprintf (file, "\n"); 1985 } 1986 1987 i += size; 1988 } 1989 1990 free (data); 1991 1992 return TRUE; 1993 } 1994 1995 /* Print out the program headers. */ 1996 1997 bfd_boolean 1998 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile) 1999 { 2000 FILE *file = (FILE *) vfile; 2001 int j; 2002 pe_data_type *pe = pe_data (abfd); 2003 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr; 2004 const char *subsystem_name = NULL; 2005 const char *name; 2006 2007 /* The MS dumpbin program reportedly ands with 0xff0f before 2008 printing the characteristics field. Not sure why. No reason to 2009 emulate it here. */ 2010 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags); 2011 #undef PF 2012 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); } 2013 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped"); 2014 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable"); 2015 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped"); 2016 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped"); 2017 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware"); 2018 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian"); 2019 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words"); 2020 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed"); 2021 PF (IMAGE_FILE_SYSTEM, "system file"); 2022 PF (IMAGE_FILE_DLL, "DLL"); 2023 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian"); 2024 #undef PF 2025 2026 /* ctime implies '\n'. */ 2027 { 2028 time_t t = pe->coff.timestamp; 2029 fprintf (file, "\nTime/Date\t\t%s", ctime (&t)); 2030 } 2031 2032 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC 2033 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b 2034 #endif 2035 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC 2036 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b 2037 #endif 2038 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC 2039 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107 2040 #endif 2041 2042 switch (i->Magic) 2043 { 2044 case IMAGE_NT_OPTIONAL_HDR_MAGIC: 2045 name = "PE32"; 2046 break; 2047 case IMAGE_NT_OPTIONAL_HDR64_MAGIC: 2048 name = "PE32+"; 2049 break; 2050 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC: 2051 name = "ROM"; 2052 break; 2053 default: 2054 name = NULL; 2055 break; 2056 } 2057 fprintf (file, "Magic\t\t\t%04x", i->Magic); 2058 if (name) 2059 fprintf (file, "\t(%s)",name); 2060 fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion); 2061 fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion); 2062 fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode); 2063 fprintf (file, "SizeOfInitializedData\t%08lx\n", 2064 (unsigned long) i->SizeOfInitializedData); 2065 fprintf (file, "SizeOfUninitializedData\t%08lx\n", 2066 (unsigned long) i->SizeOfUninitializedData); 2067 fprintf (file, "AddressOfEntryPoint\t"); 2068 bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint); 2069 fprintf (file, "\nBaseOfCode\t\t"); 2070 bfd_fprintf_vma (abfd, file, i->BaseOfCode); 2071 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 2072 /* PE32+ does not have BaseOfData member! */ 2073 fprintf (file, "\nBaseOfData\t\t"); 2074 bfd_fprintf_vma (abfd, file, i->BaseOfData); 2075 #endif 2076 2077 fprintf (file, "\nImageBase\t\t"); 2078 bfd_fprintf_vma (abfd, file, i->ImageBase); 2079 fprintf (file, "\nSectionAlignment\t"); 2080 bfd_fprintf_vma (abfd, file, i->SectionAlignment); 2081 fprintf (file, "\nFileAlignment\t\t"); 2082 bfd_fprintf_vma (abfd, file, i->FileAlignment); 2083 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion); 2084 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion); 2085 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion); 2086 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion); 2087 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion); 2088 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion); 2089 fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1); 2090 fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage); 2091 fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders); 2092 fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum); 2093 2094 switch (i->Subsystem) 2095 { 2096 case IMAGE_SUBSYSTEM_UNKNOWN: 2097 subsystem_name = "unspecified"; 2098 break; 2099 case IMAGE_SUBSYSTEM_NATIVE: 2100 subsystem_name = "NT native"; 2101 break; 2102 case IMAGE_SUBSYSTEM_WINDOWS_GUI: 2103 subsystem_name = "Windows GUI"; 2104 break; 2105 case IMAGE_SUBSYSTEM_WINDOWS_CUI: 2106 subsystem_name = "Windows CUI"; 2107 break; 2108 case IMAGE_SUBSYSTEM_POSIX_CUI: 2109 subsystem_name = "POSIX CUI"; 2110 break; 2111 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI: 2112 subsystem_name = "Wince CUI"; 2113 break; 2114 // These are from UEFI Platform Initialization Specification 1.1. 2115 case IMAGE_SUBSYSTEM_EFI_APPLICATION: 2116 subsystem_name = "EFI application"; 2117 break; 2118 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER: 2119 subsystem_name = "EFI boot service driver"; 2120 break; 2121 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER: 2122 subsystem_name = "EFI runtime driver"; 2123 break; 2124 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER: 2125 subsystem_name = "SAL runtime driver"; 2126 break; 2127 // This is from revision 8.0 of the MS PE/COFF spec 2128 case IMAGE_SUBSYSTEM_XBOX: 2129 subsystem_name = "XBOX"; 2130 break; 2131 // Added default case for clarity - subsystem_name is NULL anyway. 2132 default: 2133 subsystem_name = NULL; 2134 } 2135 2136 fprintf (file, "Subsystem\t\t%08x", i->Subsystem); 2137 if (subsystem_name) 2138 fprintf (file, "\t(%s)", subsystem_name); 2139 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics); 2140 fprintf (file, "SizeOfStackReserve\t"); 2141 bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve); 2142 fprintf (file, "\nSizeOfStackCommit\t"); 2143 bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit); 2144 fprintf (file, "\nSizeOfHeapReserve\t"); 2145 bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve); 2146 fprintf (file, "\nSizeOfHeapCommit\t"); 2147 bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit); 2148 fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags); 2149 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", 2150 (unsigned long) i->NumberOfRvaAndSizes); 2151 2152 fprintf (file, "\nThe Data Directory\n"); 2153 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++) 2154 { 2155 fprintf (file, "Entry %1x ", j); 2156 bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress); 2157 fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size); 2158 fprintf (file, "%s\n", dir_names[j]); 2159 } 2160 2161 pe_print_idata (abfd, vfile); 2162 pe_print_edata (abfd, vfile); 2163 if (bfd_coff_have_print_pdata (abfd)) 2164 bfd_coff_print_pdata (abfd, vfile); 2165 else 2166 pe_print_pdata (abfd, vfile); 2167 pe_print_reloc (abfd, vfile); 2168 2169 return TRUE; 2170 } 2171 2172 /* Copy any private info we understand from the input bfd 2173 to the output bfd. */ 2174 2175 bfd_boolean 2176 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd) 2177 { 2178 pe_data_type *ipe, *ope; 2179 2180 /* One day we may try to grok other private data. */ 2181 if (ibfd->xvec->flavour != bfd_target_coff_flavour 2182 || obfd->xvec->flavour != bfd_target_coff_flavour) 2183 return TRUE; 2184 2185 ipe = pe_data (ibfd); 2186 ope = pe_data (obfd); 2187 2188 /* pe_opthdr is copied in copy_object. */ 2189 ope->dll = ipe->dll; 2190 2191 /* Don't copy input subsystem if output is different from input. */ 2192 if (obfd->xvec != ibfd->xvec) 2193 ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN; 2194 2195 /* For strip: if we removed .reloc, we'll make a real mess of things 2196 if we don't remove this entry as well. */ 2197 if (! pe_data (obfd)->has_reloc_section) 2198 { 2199 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0; 2200 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0; 2201 } 2202 2203 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED. 2204 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED 2205 won't be added. */ 2206 if (! pe_data (ibfd)->has_reloc_section 2207 && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED)) 2208 pe_data (obfd)->dont_strip_reloc = 1; 2209 2210 return TRUE; 2211 } 2212 2213 /* Copy private section data. */ 2214 2215 bfd_boolean 2216 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd, 2217 asection *isec, 2218 bfd *obfd, 2219 asection *osec) 2220 { 2221 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour 2222 || bfd_get_flavour (obfd) != bfd_target_coff_flavour) 2223 return TRUE; 2224 2225 if (coff_section_data (ibfd, isec) != NULL 2226 && pei_section_data (ibfd, isec) != NULL) 2227 { 2228 if (coff_section_data (obfd, osec) == NULL) 2229 { 2230 bfd_size_type amt = sizeof (struct coff_section_tdata); 2231 osec->used_by_bfd = bfd_zalloc (obfd, amt); 2232 if (osec->used_by_bfd == NULL) 2233 return FALSE; 2234 } 2235 2236 if (pei_section_data (obfd, osec) == NULL) 2237 { 2238 bfd_size_type amt = sizeof (struct pei_section_tdata); 2239 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt); 2240 if (coff_section_data (obfd, osec)->tdata == NULL) 2241 return FALSE; 2242 } 2243 2244 pei_section_data (obfd, osec)->virt_size = 2245 pei_section_data (ibfd, isec)->virt_size; 2246 pei_section_data (obfd, osec)->pe_flags = 2247 pei_section_data (ibfd, isec)->pe_flags; 2248 } 2249 2250 return TRUE; 2251 } 2252 2253 void 2254 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret) 2255 { 2256 coff_get_symbol_info (abfd, symbol, ret); 2257 } 2258 2259 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64) 2260 static int 2261 sort_x64_pdata (const void *l, const void *r) 2262 { 2263 const char *lp = (const char *) l; 2264 const char *rp = (const char *) r; 2265 bfd_vma vl, vr; 2266 vl = bfd_getl32 (lp); vr = bfd_getl32 (rp); 2267 if (vl != vr) 2268 return (vl < vr ? -1 : 1); 2269 /* We compare just begin address. */ 2270 return 0; 2271 } 2272 #endif 2273 2274 /* Handle the .idata section and other things that need symbol table 2275 access. */ 2276 2277 bfd_boolean 2278 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo) 2279 { 2280 struct coff_link_hash_entry *h1; 2281 struct bfd_link_info *info = pfinfo->info; 2282 bfd_boolean result = TRUE; 2283 2284 /* There are a few fields that need to be filled in now while we 2285 have symbol table access. 2286 2287 The .idata subsections aren't directly available as sections, but 2288 they are in the symbol table, so get them from there. */ 2289 2290 /* The import directory. This is the address of .idata$2, with size 2291 of .idata$2 + .idata$3. */ 2292 h1 = coff_link_hash_lookup (coff_hash_table (info), 2293 ".idata$2", FALSE, FALSE, TRUE); 2294 if (h1 != NULL) 2295 { 2296 /* PR ld/2729: We cannot rely upon all the output sections having been 2297 created properly, so check before referencing them. Issue a warning 2298 message for any sections tht could not be found. */ 2299 if ((h1->root.type == bfd_link_hash_defined 2300 || h1->root.type == bfd_link_hash_defweak) 2301 && h1->root.u.def.section != NULL 2302 && h1->root.u.def.section->output_section != NULL) 2303 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress = 2304 (h1->root.u.def.value 2305 + h1->root.u.def.section->output_section->vma 2306 + h1->root.u.def.section->output_offset); 2307 else 2308 { 2309 _bfd_error_handler 2310 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"), 2311 abfd); 2312 result = FALSE; 2313 } 2314 2315 h1 = coff_link_hash_lookup (coff_hash_table (info), 2316 ".idata$4", FALSE, FALSE, TRUE); 2317 if (h1 != NULL 2318 && (h1->root.type == bfd_link_hash_defined 2319 || h1->root.type == bfd_link_hash_defweak) 2320 && h1->root.u.def.section != NULL 2321 && h1->root.u.def.section->output_section != NULL) 2322 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size = 2323 ((h1->root.u.def.value 2324 + h1->root.u.def.section->output_section->vma 2325 + h1->root.u.def.section->output_offset) 2326 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress); 2327 else 2328 { 2329 _bfd_error_handler 2330 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"), 2331 abfd); 2332 result = FALSE; 2333 } 2334 2335 /* The import address table. This is the size/address of 2336 .idata$5. */ 2337 h1 = coff_link_hash_lookup (coff_hash_table (info), 2338 ".idata$5", FALSE, FALSE, TRUE); 2339 if (h1 != NULL 2340 && (h1->root.type == bfd_link_hash_defined 2341 || h1->root.type == bfd_link_hash_defweak) 2342 && h1->root.u.def.section != NULL 2343 && h1->root.u.def.section->output_section != NULL) 2344 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress = 2345 (h1->root.u.def.value 2346 + h1->root.u.def.section->output_section->vma 2347 + h1->root.u.def.section->output_offset); 2348 else 2349 { 2350 _bfd_error_handler 2351 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"), 2352 abfd); 2353 result = FALSE; 2354 } 2355 2356 h1 = coff_link_hash_lookup (coff_hash_table (info), 2357 ".idata$6", FALSE, FALSE, TRUE); 2358 if (h1 != NULL 2359 && (h1->root.type == bfd_link_hash_defined 2360 || h1->root.type == bfd_link_hash_defweak) 2361 && h1->root.u.def.section != NULL 2362 && h1->root.u.def.section->output_section != NULL) 2363 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size = 2364 ((h1->root.u.def.value 2365 + h1->root.u.def.section->output_section->vma 2366 + h1->root.u.def.section->output_offset) 2367 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress); 2368 else 2369 { 2370 _bfd_error_handler 2371 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"), 2372 abfd); 2373 result = FALSE; 2374 } 2375 } 2376 else 2377 { 2378 h1 = coff_link_hash_lookup (coff_hash_table (info), 2379 "__IAT_start__", FALSE, FALSE, TRUE); 2380 if (h1 != NULL 2381 && (h1->root.type == bfd_link_hash_defined 2382 || h1->root.type == bfd_link_hash_defweak) 2383 && h1->root.u.def.section != NULL 2384 && h1->root.u.def.section->output_section != NULL) 2385 { 2386 bfd_vma iat_va; 2387 2388 iat_va = 2389 (h1->root.u.def.value 2390 + h1->root.u.def.section->output_section->vma 2391 + h1->root.u.def.section->output_offset); 2392 2393 h1 = coff_link_hash_lookup (coff_hash_table (info), 2394 "__IAT_end__", FALSE, FALSE, TRUE); 2395 if (h1 != NULL 2396 && (h1->root.type == bfd_link_hash_defined 2397 || h1->root.type == bfd_link_hash_defweak) 2398 && h1->root.u.def.section != NULL 2399 && h1->root.u.def.section->output_section != NULL) 2400 { 2401 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size = 2402 ((h1->root.u.def.value 2403 + h1->root.u.def.section->output_section->vma 2404 + h1->root.u.def.section->output_offset) 2405 - iat_va); 2406 if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0) 2407 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress = 2408 iat_va - pe_data (abfd)->pe_opthdr.ImageBase; 2409 } 2410 else 2411 { 2412 _bfd_error_handler 2413 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]" 2414 " because .idata$6 is missing"), abfd); 2415 result = FALSE; 2416 } 2417 } 2418 } 2419 2420 h1 = coff_link_hash_lookup (coff_hash_table (info), 2421 (bfd_get_symbol_leading_char(abfd) != 0 2422 ? "__tls_used" : "_tls_used"), 2423 FALSE, FALSE, TRUE); 2424 if (h1 != NULL) 2425 { 2426 if ((h1->root.type == bfd_link_hash_defined 2427 || h1->root.type == bfd_link_hash_defweak) 2428 && h1->root.u.def.section != NULL 2429 && h1->root.u.def.section->output_section != NULL) 2430 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress = 2431 (h1->root.u.def.value 2432 + h1->root.u.def.section->output_section->vma 2433 + h1->root.u.def.section->output_offset 2434 - pe_data (abfd)->pe_opthdr.ImageBase); 2435 else 2436 { 2437 _bfd_error_handler 2438 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"), 2439 abfd); 2440 result = FALSE; 2441 } 2442 /* According to PECOFF sepcifications by Microsoft version 8.2 2443 the TLS data directory consists of 4 pointers, followed 2444 by two 4-byte integer. This implies that the total size 2445 is different for 32-bit and 64-bit executables. */ 2446 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 2447 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18; 2448 #else 2449 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28; 2450 #endif 2451 } 2452 2453 /* If there is a .pdata section and we have linked pdata finally, we 2454 need to sort the entries ascending. */ 2455 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64) 2456 { 2457 asection *sec = bfd_get_section_by_name (abfd, ".pdata"); 2458 2459 if (sec) 2460 { 2461 bfd_size_type x = sec->rawsize; 2462 bfd_byte *tmp_data = NULL; 2463 2464 if (x) 2465 tmp_data = bfd_malloc (x); 2466 2467 if (tmp_data != NULL) 2468 { 2469 if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x)) 2470 { 2471 qsort (tmp_data, 2472 (size_t) (x / 12), 2473 12, sort_x64_pdata); 2474 bfd_set_section_contents (pfinfo->output_bfd, sec, 2475 tmp_data, 0, x); 2476 } 2477 free (tmp_data); 2478 } 2479 } 2480 } 2481 #endif 2482 2483 /* If we couldn't find idata$2, we either have an excessively 2484 trivial program or are in DEEP trouble; we have to assume trivial 2485 program.... */ 2486 return result; 2487 } 2488