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 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 66/* NOTE: it's strange to be including an architecture specific header 67 in what's supposed to be general (to PE/PEI) code. However, that's 68 where the definitions are, and they don't vary per architecture 69 within PE/PEI, so we get them from there. FIXME: The lack of 70 variance is an assumption which may prove to be incorrect if new 71 PE/PEI targets are created. */ 72#if defined COFF_WITH_pex64 73# include "coff/x86_64.h" 74#elif defined COFF_WITH_pep 75# include "coff/ia64.h" 76#else 77# include "coff/i386.h" 78#endif 79 80#include "coff/pe.h" 81#include "libcoff.h" 82#include "libpei.h" 83 84#if defined COFF_WITH_pep || defined COFF_WITH_pex64 85# undef AOUTSZ 86# define AOUTSZ PEPAOUTSZ 87# define PEAOUTHDR PEPAOUTHDR 88#endif 89 90/* FIXME: This file has various tests of POWERPC_LE_PE. Those tests 91 worked when the code was in peicode.h, but no longer work now that 92 the code is in peigen.c. PowerPC NT is said to be dead. If 93 anybody wants to revive the code, you will have to figure out how 94 to handle those issues. */ 95 96void 97_bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1) 98{ 99 SYMENT *ext = (SYMENT *) ext1; 100 struct internal_syment *in = (struct internal_syment *) in1; 101 102 if (ext->e.e_name[0] == 0) 103 { 104 in->_n._n_n._n_zeroes = 0; 105 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset); 106 } 107 else 108 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN); 109 110 in->n_value = H_GET_32 (abfd, ext->e_value); 111 in->n_scnum = H_GET_16 (abfd, ext->e_scnum); 112 113 if (sizeof (ext->e_type) == 2) 114 in->n_type = H_GET_16 (abfd, ext->e_type); 115 else 116 in->n_type = H_GET_32 (abfd, ext->e_type); 117 118 in->n_sclass = H_GET_8 (abfd, ext->e_sclass); 119 in->n_numaux = H_GET_8 (abfd, ext->e_numaux); 120 121#ifndef STRICT_PE_FORMAT 122 /* This is for Gnu-created DLLs. */ 123 124 /* The section symbols for the .idata$ sections have class 0x68 125 (C_SECTION), which MS documentation indicates is a section 126 symbol. Unfortunately, the value field in the symbol is simply a 127 copy of the .idata section's flags rather than something useful. 128 When these symbols are encountered, change the value to 0 so that 129 they will be handled somewhat correctly in the bfd code. */ 130 if (in->n_sclass == C_SECTION) 131 { 132 in->n_value = 0x0; 133 134 /* Create synthetic empty sections as needed. DJ */ 135 if (in->n_scnum == 0) 136 { 137 asection *sec; 138 139 for (sec = abfd->sections; sec; sec = sec->next) 140 { 141 if (strcmp (sec->name, in->n_name) == 0) 142 { 143 in->n_scnum = sec->target_index; 144 break; 145 } 146 } 147 } 148 149 if (in->n_scnum == 0) 150 { 151 int unused_section_number = 0; 152 asection *sec; 153 char *name; 154 flagword flags; 155 156 for (sec = abfd->sections; sec; sec = sec->next) 157 if (unused_section_number <= sec->target_index) 158 unused_section_number = sec->target_index + 1; 159 160 name = bfd_alloc (abfd, (bfd_size_type) strlen (in->n_name) + 10); 161 if (name == NULL) 162 return; 163 strcpy (name, in->n_name); 164 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD; 165 sec = bfd_make_section_anyway_with_flags (abfd, name, flags); 166 167 sec->vma = 0; 168 sec->lma = 0; 169 sec->size = 0; 170 sec->filepos = 0; 171 sec->rel_filepos = 0; 172 sec->reloc_count = 0; 173 sec->line_filepos = 0; 174 sec->lineno_count = 0; 175 sec->userdata = NULL; 176 sec->next = NULL; 177 sec->alignment_power = 2; 178 179 sec->target_index = unused_section_number; 180 181 in->n_scnum = unused_section_number; 182 } 183 in->n_sclass = C_STAT; 184 } 185#endif 186 187#ifdef coff_swap_sym_in_hook 188 /* This won't work in peigen.c, but since it's for PPC PE, it's not 189 worth fixing. */ 190 coff_swap_sym_in_hook (abfd, ext1, in1); 191#endif 192} 193 194unsigned int 195_bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp) 196{ 197 struct internal_syment *in = (struct internal_syment *) inp; 198 SYMENT *ext = (SYMENT *) extp; 199 200 if (in->_n._n_name[0] == 0) 201 { 202 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes); 203 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset); 204 } 205 else 206 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN); 207 208 H_PUT_32 (abfd, in->n_value, ext->e_value); 209 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum); 210 211 if (sizeof (ext->e_type) == 2) 212 H_PUT_16 (abfd, in->n_type, ext->e_type); 213 else 214 H_PUT_32 (abfd, in->n_type, ext->e_type); 215 216 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass); 217 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux); 218 219 return SYMESZ; 220} 221 222void 223_bfd_XXi_swap_aux_in (bfd * abfd, 224 void * ext1, 225 int type, 226 int class, 227 int indx ATTRIBUTE_UNUSED, 228 int numaux ATTRIBUTE_UNUSED, 229 void * in1) 230{ 231 AUXENT *ext = (AUXENT *) ext1; 232 union internal_auxent *in = (union internal_auxent *) in1; 233 234 switch (class) 235 { 236 case C_FILE: 237 if (ext->x_file.x_fname[0] == 0) 238 { 239 in->x_file.x_n.x_zeroes = 0; 240 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset); 241 } 242 else 243 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN); 244 return; 245 246 case C_STAT: 247 case C_LEAFSTAT: 248 case C_HIDDEN: 249 if (type == T_NULL) 250 { 251 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext); 252 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext); 253 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext); 254 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum); 255 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated); 256 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat); 257 return; 258 } 259 break; 260 } 261 262 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx); 263 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx); 264 265 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class)) 266 { 267 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext); 268 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext); 269 } 270 else 271 { 272 in->x_sym.x_fcnary.x_ary.x_dimen[0] = 273 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]); 274 in->x_sym.x_fcnary.x_ary.x_dimen[1] = 275 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]); 276 in->x_sym.x_fcnary.x_ary.x_dimen[2] = 277 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]); 278 in->x_sym.x_fcnary.x_ary.x_dimen[3] = 279 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]); 280 } 281 282 if (ISFCN (type)) 283 { 284 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize); 285 } 286 else 287 { 288 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext); 289 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext); 290 } 291} 292 293unsigned int 294_bfd_XXi_swap_aux_out (bfd * abfd, 295 void * inp, 296 int type, 297 int class, 298 int indx ATTRIBUTE_UNUSED, 299 int numaux ATTRIBUTE_UNUSED, 300 void * extp) 301{ 302 union internal_auxent *in = (union internal_auxent *) inp; 303 AUXENT *ext = (AUXENT *) extp; 304 305 memset (ext, 0, AUXESZ); 306 307 switch (class) 308 { 309 case C_FILE: 310 if (in->x_file.x_fname[0] == 0) 311 { 312 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes); 313 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset); 314 } 315 else 316 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN); 317 318 return AUXESZ; 319 320 case C_STAT: 321 case C_LEAFSTAT: 322 case C_HIDDEN: 323 if (type == T_NULL) 324 { 325 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext); 326 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext); 327 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext); 328 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum); 329 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated); 330 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat); 331 return AUXESZ; 332 } 333 break; 334 } 335 336 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx); 337 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx); 338 339 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class)) 340 { 341 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext); 342 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext); 343 } 344 else 345 { 346 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0], 347 ext->x_sym.x_fcnary.x_ary.x_dimen[0]); 348 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1], 349 ext->x_sym.x_fcnary.x_ary.x_dimen[1]); 350 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2], 351 ext->x_sym.x_fcnary.x_ary.x_dimen[2]); 352 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3], 353 ext->x_sym.x_fcnary.x_ary.x_dimen[3]); 354 } 355 356 if (ISFCN (type)) 357 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize); 358 else 359 { 360 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext); 361 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext); 362 } 363 364 return AUXESZ; 365} 366 367void 368_bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1) 369{ 370 LINENO *ext = (LINENO *) ext1; 371 struct internal_lineno *in = (struct internal_lineno *) in1; 372 373 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx); 374 in->l_lnno = GET_LINENO_LNNO (abfd, ext); 375} 376 377unsigned int 378_bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp) 379{ 380 struct internal_lineno *in = (struct internal_lineno *) inp; 381 struct external_lineno *ext = (struct external_lineno *) outp; 382 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx); 383 384 PUT_LINENO_LNNO (abfd, in->l_lnno, ext); 385 return LINESZ; 386} 387 388void 389_bfd_XXi_swap_aouthdr_in (bfd * abfd, 390 void * aouthdr_ext1, 391 void * aouthdr_int1) 392{ 393 PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1; 394 AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1; 395 struct internal_aouthdr *aouthdr_int 396 = (struct internal_aouthdr *) aouthdr_int1; 397 struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe; 398 399 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic); 400 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp); 401 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize); 402 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize); 403 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize); 404 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry); 405 aouthdr_int->text_start = 406 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start); 407#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 408 /* PE32+ does not have data_start member! */ 409 aouthdr_int->data_start = 410 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start); 411 a->BaseOfData = aouthdr_int->data_start; 412#endif 413 414 a->Magic = aouthdr_int->magic; 415 a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp); 416 a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1); 417 a->SizeOfCode = aouthdr_int->tsize ; 418 a->SizeOfInitializedData = aouthdr_int->dsize ; 419 a->SizeOfUninitializedData = aouthdr_int->bsize ; 420 a->AddressOfEntryPoint = aouthdr_int->entry; 421 a->BaseOfCode = aouthdr_int->text_start; 422 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase); 423 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment); 424 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment); 425 a->MajorOperatingSystemVersion = 426 H_GET_16 (abfd, src->MajorOperatingSystemVersion); 427 a->MinorOperatingSystemVersion = 428 H_GET_16 (abfd, src->MinorOperatingSystemVersion); 429 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion); 430 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion); 431 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion); 432 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion); 433 a->Reserved1 = H_GET_32 (abfd, src->Reserved1); 434 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage); 435 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders); 436 a->CheckSum = H_GET_32 (abfd, src->CheckSum); 437 a->Subsystem = H_GET_16 (abfd, src->Subsystem); 438 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics); 439 a->SizeOfStackReserve = 440 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve); 441 a->SizeOfStackCommit = 442 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit); 443 a->SizeOfHeapReserve = 444 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve); 445 a->SizeOfHeapCommit = 446 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit); 447 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags); 448 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes); 449 450 { 451 int idx; 452 453 for (idx = 0; idx < 16; idx++) 454 { 455 /* If data directory is empty, rva also should be 0. */ 456 int size = 457 H_GET_32 (abfd, src->DataDirectory[idx][1]); 458 459 a->DataDirectory[idx].Size = size; 460 461 if (size) 462 a->DataDirectory[idx].VirtualAddress = 463 H_GET_32 (abfd, src->DataDirectory[idx][0]); 464 else 465 a->DataDirectory[idx].VirtualAddress = 0; 466 } 467 } 468 469 if (aouthdr_int->entry) 470 { 471 aouthdr_int->entry += a->ImageBase; 472#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 473 aouthdr_int->entry &= 0xffffffff; 474#endif 475 } 476 477 if (aouthdr_int->tsize) 478 { 479 aouthdr_int->text_start += a->ImageBase; 480#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 481 aouthdr_int->text_start &= 0xffffffff; 482#endif 483 } 484 485#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 486 /* PE32+ does not have data_start member! */ 487 if (aouthdr_int->dsize) 488 { 489 aouthdr_int->data_start += a->ImageBase; 490 aouthdr_int->data_start &= 0xffffffff; 491 } 492#endif 493 494#ifdef POWERPC_LE_PE 495 /* These three fields are normally set up by ppc_relocate_section. 496 In the case of reading a file in, we can pick them up from the 497 DataDirectory. */ 498 first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress; 499 thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size; 500 import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size; 501#endif 502} 503 504/* A support function for below. */ 505 506static void 507add_data_entry (bfd * abfd, 508 struct internal_extra_pe_aouthdr *aout, 509 int idx, 510 char *name, 511 bfd_vma base) 512{ 513 asection *sec = bfd_get_section_by_name (abfd, name); 514 515 /* Add import directory information if it exists. */ 516 if ((sec != NULL) 517 && (coff_section_data (abfd, sec) != NULL) 518 && (pei_section_data (abfd, sec) != NULL)) 519 { 520 /* If data directory is empty, rva also should be 0. */ 521 int size = pei_section_data (abfd, sec)->virt_size; 522 aout->DataDirectory[idx].Size = size; 523 524 if (size) 525 { 526 aout->DataDirectory[idx].VirtualAddress = 527 (sec->vma - base) & 0xffffffff; 528 sec->flags |= SEC_DATA; 529 } 530 } 531} 532 533unsigned int 534_bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out) 535{ 536 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in; 537 pe_data_type *pe = pe_data (abfd); 538 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr; 539 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out; 540 bfd_vma sa, fa, ib; 541 IMAGE_DATA_DIRECTORY idata2, idata5, tls; 542 543 if (pe->force_minimum_alignment) 544 { 545 if (!extra->FileAlignment) 546 extra->FileAlignment = PE_DEF_FILE_ALIGNMENT; 547 if (!extra->SectionAlignment) 548 extra->SectionAlignment = PE_DEF_SECTION_ALIGNMENT; 549 } 550 551 if (extra->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) 552 extra->Subsystem = pe->target_subsystem; 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#define LINKER_VERSION 256 /* That is, 2.56 */ 671 672 /* This piece of magic sets the "linker version" field to 673 LINKER_VERSION. */ 674 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256), 675 aouthdr_out->standard.vstamp); 676 677 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize); 678 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize); 679 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize); 680 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry); 681 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start, 682 aouthdr_out->standard.text_start); 683 684#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 685 /* PE32+ does not have data_start member! */ 686 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start, 687 aouthdr_out->standard.data_start); 688#endif 689 690 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase); 691 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment); 692 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment); 693 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion, 694 aouthdr_out->MajorOperatingSystemVersion); 695 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion, 696 aouthdr_out->MinorOperatingSystemVersion); 697 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion); 698 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion); 699 H_PUT_16 (abfd, extra->MajorSubsystemVersion, 700 aouthdr_out->MajorSubsystemVersion); 701 H_PUT_16 (abfd, extra->MinorSubsystemVersion, 702 aouthdr_out->MinorSubsystemVersion); 703 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1); 704 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage); 705 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders); 706 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum); 707 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem); 708 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics); 709 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve, 710 aouthdr_out->SizeOfStackReserve); 711 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit, 712 aouthdr_out->SizeOfStackCommit); 713 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve, 714 aouthdr_out->SizeOfHeapReserve); 715 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit, 716 aouthdr_out->SizeOfHeapCommit); 717 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags); 718 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes, 719 aouthdr_out->NumberOfRvaAndSizes); 720 { 721 int idx; 722 723 for (idx = 0; idx < 16; idx++) 724 { 725 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress, 726 aouthdr_out->DataDirectory[idx][0]); 727 H_PUT_32 (abfd, extra->DataDirectory[idx].Size, 728 aouthdr_out->DataDirectory[idx][1]); 729 } 730 } 731 732 return AOUTSZ; 733} 734 735unsigned int 736_bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out) 737{ 738 int idx; 739 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in; 740 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out; 741 742 if (pe_data (abfd)->has_reloc_section) 743 filehdr_in->f_flags &= ~F_RELFLG; 744 745 if (pe_data (abfd)->dll) 746 filehdr_in->f_flags |= F_DLL; 747 748 filehdr_in->pe.e_magic = DOSMAGIC; 749 filehdr_in->pe.e_cblp = 0x90; 750 filehdr_in->pe.e_cp = 0x3; 751 filehdr_in->pe.e_crlc = 0x0; 752 filehdr_in->pe.e_cparhdr = 0x4; 753 filehdr_in->pe.e_minalloc = 0x0; 754 filehdr_in->pe.e_maxalloc = 0xffff; 755 filehdr_in->pe.e_ss = 0x0; 756 filehdr_in->pe.e_sp = 0xb8; 757 filehdr_in->pe.e_csum = 0x0; 758 filehdr_in->pe.e_ip = 0x0; 759 filehdr_in->pe.e_cs = 0x0; 760 filehdr_in->pe.e_lfarlc = 0x40; 761 filehdr_in->pe.e_ovno = 0x0; 762 763 for (idx = 0; idx < 4; idx++) 764 filehdr_in->pe.e_res[idx] = 0x0; 765 766 filehdr_in->pe.e_oemid = 0x0; 767 filehdr_in->pe.e_oeminfo = 0x0; 768 769 for (idx = 0; idx < 10; idx++) 770 filehdr_in->pe.e_res2[idx] = 0x0; 771 772 filehdr_in->pe.e_lfanew = 0x80; 773 774 /* This next collection of data are mostly just characters. It 775 appears to be constant within the headers put on NT exes. */ 776 filehdr_in->pe.dos_message[0] = 0x0eba1f0e; 777 filehdr_in->pe.dos_message[1] = 0xcd09b400; 778 filehdr_in->pe.dos_message[2] = 0x4c01b821; 779 filehdr_in->pe.dos_message[3] = 0x685421cd; 780 filehdr_in->pe.dos_message[4] = 0x70207369; 781 filehdr_in->pe.dos_message[5] = 0x72676f72; 782 filehdr_in->pe.dos_message[6] = 0x63206d61; 783 filehdr_in->pe.dos_message[7] = 0x6f6e6e61; 784 filehdr_in->pe.dos_message[8] = 0x65622074; 785 filehdr_in->pe.dos_message[9] = 0x6e757220; 786 filehdr_in->pe.dos_message[10] = 0x206e6920; 787 filehdr_in->pe.dos_message[11] = 0x20534f44; 788 filehdr_in->pe.dos_message[12] = 0x65646f6d; 789 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e; 790 filehdr_in->pe.dos_message[14] = 0x24; 791 filehdr_in->pe.dos_message[15] = 0x0; 792 filehdr_in->pe.nt_signature = NT_SIGNATURE; 793 794 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic); 795 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns); 796 797 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat); 798 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, 799 filehdr_out->f_symptr); 800 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms); 801 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr); 802 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags); 803 804 /* Put in extra dos header stuff. This data remains essentially 805 constant, it just has to be tacked on to the beginning of all exes 806 for NT. */ 807 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic); 808 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp); 809 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp); 810 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc); 811 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr); 812 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc); 813 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc); 814 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss); 815 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp); 816 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum); 817 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip); 818 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs); 819 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc); 820 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno); 821 822 for (idx = 0; idx < 4; idx++) 823 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]); 824 825 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid); 826 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo); 827 828 for (idx = 0; idx < 10; idx++) 829 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]); 830 831 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew); 832 833 for (idx = 0; idx < 16; idx++) 834 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx], 835 filehdr_out->dos_message[idx]); 836 837 /* Also put in the NT signature. */ 838 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature); 839 840 return FILHSZ; 841} 842 843unsigned int 844_bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out) 845{ 846 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in; 847 FILHDR *filehdr_out = (FILHDR *) out; 848 849 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic); 850 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns); 851 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat); 852 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr); 853 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms); 854 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr); 855 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags); 856 857 return FILHSZ; 858} 859 860unsigned int 861_bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out) 862{ 863 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in; 864 SCNHDR *scnhdr_ext = (SCNHDR *) out; 865 unsigned int ret = SCNHSZ; 866 bfd_vma ps; 867 bfd_vma ss; 868 869 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name)); 870 871 PUT_SCNHDR_VADDR (abfd, 872 ((scnhdr_int->s_vaddr 873 - pe_data (abfd)->pe_opthdr.ImageBase) 874 & 0xffffffff), 875 scnhdr_ext->s_vaddr); 876 877 /* NT wants the size data to be rounded up to the next 878 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss, 879 sometimes). */ 880 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0) 881 { 882 if (bfd_pe_executable_p (abfd)) 883 { 884 ps = scnhdr_int->s_size; 885 ss = 0; 886 } 887 else 888 { 889 ps = 0; 890 ss = scnhdr_int->s_size; 891 } 892 } 893 else 894 { 895 if (bfd_pe_executable_p (abfd)) 896 ps = scnhdr_int->s_paddr; 897 else 898 ps = 0; 899 900 ss = scnhdr_int->s_size; 901 } 902 903 PUT_SCNHDR_SIZE (abfd, ss, 904 scnhdr_ext->s_size); 905 906 /* s_paddr in PE is really the virtual size. */ 907 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr); 908 909 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr, 910 scnhdr_ext->s_scnptr); 911 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr, 912 scnhdr_ext->s_relptr); 913 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr, 914 scnhdr_ext->s_lnnoptr); 915 916 { 917 /* Extra flags must be set when dealing with PE. All sections should also 918 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the 919 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data 920 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set 921 (this is especially important when dealing with the .idata section since 922 the addresses for routines from .dlls must be overwritten). If .reloc 923 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE 924 (0x02000000). Also, the resource data should also be read and 925 writable. */ 926 927 /* FIXME: Alignment is also encoded in this field, at least on PPC and 928 ARM-WINCE. Although - how do we get the original alignment field 929 back ? */ 930 931 typedef struct 932 { 933 const char * section_name; 934 unsigned long must_have; 935 } 936 pe_required_section_flags; 937 938 pe_required_section_flags known_sections [] = 939 { 940 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES }, 941 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 942 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 943 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA }, 944 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 945 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA }, 946 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA }, 947 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE }, 948 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 949 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE }, 950 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE }, 951 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA }, 952 { NULL, 0} 953 }; 954 955 pe_required_section_flags * p; 956 957 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now 958 we know exactly what this specific section wants so we remove it 959 and then allow the must_have field to add it back in if necessary. 960 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the 961 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared 962 by ld --enable-auto-import (if auto-import is actually needed), 963 by ld --omagic, or by obcopy --writable-text. */ 964 965 for (p = known_sections; p->section_name; p++) 966 if (strcmp (scnhdr_int->s_name, p->section_name) == 0) 967 { 968 if (strcmp (scnhdr_int->s_name, ".text") 969 || (bfd_get_file_flags (abfd) & WP_TEXT)) 970 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE; 971 scnhdr_int->s_flags |= p->must_have; 972 break; 973 } 974 975 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags); 976 } 977 978 if (coff_data (abfd)->link_info 979 && ! coff_data (abfd)->link_info->relocatable 980 && ! coff_data (abfd)->link_info->shared 981 && strcmp (scnhdr_int->s_name, ".text") == 0) 982 { 983 /* By inference from looking at MS output, the 32 bit field 984 which is the combination of the number_of_relocs and 985 number_of_linenos is used for the line number count in 986 executables. A 16-bit field won't do for cc1. The MS 987 document says that the number of relocs is zero for 988 executables, but the 17-th bit has been observed to be there. 989 Overflow is not an issue: a 4G-line program will overflow a 990 bunch of other fields long before this! */ 991 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno); 992 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc); 993 } 994 else 995 { 996 if (scnhdr_int->s_nlnno <= 0xffff) 997 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno); 998 else 999 { 1000 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"), 1001 bfd_get_filename (abfd), 1002 scnhdr_int->s_nlnno); 1003 bfd_set_error (bfd_error_file_truncated); 1004 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno); 1005 ret = 0; 1006 } 1007 1008 /* Although we could encode 0xffff relocs here, we do not, to be 1009 consistent with other parts of bfd. Also it lets us warn, as 1010 we should never see 0xffff here w/o having the overflow flag 1011 set. */ 1012 if (scnhdr_int->s_nreloc < 0xffff) 1013 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc); 1014 else 1015 { 1016 /* PE can deal with large #s of relocs, but not here. */ 1017 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc); 1018 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL; 1019 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags); 1020 } 1021 } 1022 return ret; 1023} 1024 1025static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] = 1026{ 1027 N_("Export Directory [.edata (or where ever we found it)]"), 1028 N_("Import Directory [parts of .idata]"), 1029 N_("Resource Directory [.rsrc]"), 1030 N_("Exception Directory [.pdata]"), 1031 N_("Security Directory"), 1032 N_("Base Relocation Directory [.reloc]"), 1033 N_("Debug Directory"), 1034 N_("Description Directory"), 1035 N_("Special Directory"), 1036 N_("Thread Storage Directory [.tls]"), 1037 N_("Load Configuration Directory"), 1038 N_("Bound Import Directory"), 1039 N_("Import Address Table Directory"), 1040 N_("Delay Import Directory"), 1041 N_("CLR Runtime Header"), 1042 N_("Reserved") 1043}; 1044 1045#ifdef POWERPC_LE_PE 1046/* The code for the PPC really falls in the "architecture dependent" 1047 category. However, it's not clear that anyone will ever care, so 1048 we're ignoring the issue for now; if/when PPC matters, some of this 1049 may need to go into peicode.h, or arguments passed to enable the 1050 PPC- specific code. */ 1051#endif 1052 1053static bfd_boolean 1054pe_print_idata (bfd * abfd, void * vfile) 1055{ 1056 FILE *file = (FILE *) vfile; 1057 bfd_byte *data; 1058 asection *section; 1059 bfd_signed_vma adj; 1060 1061#ifdef POWERPC_LE_PE 1062 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata"); 1063#endif 1064 1065 bfd_size_type datasize = 0; 1066 bfd_size_type dataoff; 1067 bfd_size_type i; 1068 int onaline = 20; 1069 1070 pe_data_type *pe = pe_data (abfd); 1071 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr; 1072 1073 bfd_vma addr; 1074 1075 addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress; 1076 1077 if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0) 1078 { 1079 /* Maybe the extra header isn't there. Look for the section. */ 1080 section = bfd_get_section_by_name (abfd, ".idata"); 1081 if (section == NULL) 1082 return TRUE; 1083 1084 addr = section->vma; 1085 datasize = section->size; 1086 if (datasize == 0) 1087 return TRUE; 1088 } 1089 else 1090 { 1091 addr += extra->ImageBase; 1092 for (section = abfd->sections; section != NULL; section = section->next) 1093 { 1094 datasize = section->size; 1095 if (addr >= section->vma && addr < section->vma + datasize) 1096 break; 1097 } 1098 1099 if (section == NULL) 1100 { 1101 fprintf (file, 1102 _("\nThere is an import table, but the section containing it could not be found\n")); 1103 return TRUE; 1104 } 1105 } 1106 1107 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"), 1108 section->name, (unsigned long) addr); 1109 1110 dataoff = addr - section->vma; 1111 datasize -= dataoff; 1112 1113#ifdef POWERPC_LE_PE 1114 if (rel_section != 0 && rel_section->size != 0) 1115 { 1116 /* The toc address can be found by taking the starting address, 1117 which on the PPC locates a function descriptor. The 1118 descriptor consists of the function code starting address 1119 followed by the address of the toc. The starting address we 1120 get from the bfd, and the descriptor is supposed to be in the 1121 .reldata section. */ 1122 1123 bfd_vma loadable_toc_address; 1124 bfd_vma toc_address; 1125 bfd_vma start_address; 1126 bfd_byte *data; 1127 bfd_vma offset; 1128 1129 if (!bfd_malloc_and_get_section (abfd, rel_section, &data)) 1130 { 1131 if (data != NULL) 1132 free (data); 1133 return FALSE; 1134 } 1135 1136 offset = abfd->start_address - rel_section->vma; 1137 1138 if (offset >= rel_section->size || offset + 8 > rel_section->size) 1139 { 1140 if (data != NULL) 1141 free (data); 1142 return FALSE; 1143 } 1144 1145 start_address = bfd_get_32 (abfd, data + offset); 1146 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4); 1147 toc_address = loadable_toc_address - 32768; 1148 1149 fprintf (file, 1150 _("\nFunction descriptor located at the start address: %04lx\n"), 1151 (unsigned long int) (abfd->start_address)); 1152 fprintf (file, 1153 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"), 1154 start_address, loadable_toc_address, toc_address); 1155 if (data != NULL) 1156 free (data); 1157 } 1158 else 1159 { 1160 fprintf (file, 1161 _("\nNo reldata section! Function descriptor not decoded.\n")); 1162 } 1163#endif 1164 1165 fprintf (file, 1166 _("\nThe Import Tables (interpreted %s section contents)\n"), 1167 section->name); 1168 fprintf (file, 1169 _("\ 1170 vma: Hint Time Forward DLL First\n\ 1171 Table Stamp Chain Name Thunk\n")); 1172 1173 /* Read the whole section. Some of the fields might be before dataoff. */ 1174 if (!bfd_malloc_and_get_section (abfd, section, &data)) 1175 { 1176 if (data != NULL) 1177 free (data); 1178 return FALSE; 1179 } 1180 1181 adj = section->vma - extra->ImageBase; 1182 1183 /* Print all image import descriptors. */ 1184 for (i = 0; i < datasize; i += onaline) 1185 { 1186 bfd_vma hint_addr; 1187 bfd_vma time_stamp; 1188 bfd_vma forward_chain; 1189 bfd_vma dll_name; 1190 bfd_vma first_thunk; 1191 int idx = 0; 1192 bfd_size_type j; 1193 char *dll; 1194 1195 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */ 1196 fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff)); 1197 hint_addr = bfd_get_32 (abfd, data + i + dataoff); 1198 time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff); 1199 forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff); 1200 dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff); 1201 first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff); 1202 1203 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n", 1204 (unsigned long) hint_addr, 1205 (unsigned long) time_stamp, 1206 (unsigned long) forward_chain, 1207 (unsigned long) dll_name, 1208 (unsigned long) first_thunk); 1209 1210 if (hint_addr == 0 && first_thunk == 0) 1211 break; 1212 1213 if (dll_name - adj >= section->size) 1214 break; 1215 1216 dll = (char *) data + dll_name - adj; 1217 fprintf (file, _("\n\tDLL Name: %s\n"), dll); 1218 1219 if (hint_addr != 0) 1220 { 1221 bfd_byte *ft_data; 1222 asection *ft_section; 1223 bfd_vma ft_addr; 1224 bfd_size_type ft_datasize; 1225 int ft_idx; 1226 int ft_allocated = 0; 1227 1228 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n")); 1229 1230 idx = hint_addr - adj; 1231 1232 ft_addr = first_thunk + extra->ImageBase; 1233 ft_data = data; 1234 ft_idx = first_thunk - adj; 1235 ft_allocated = 0; 1236 1237 if (first_thunk != hint_addr) 1238 { 1239 /* Find the section which contains the first thunk. */ 1240 for (ft_section = abfd->sections; 1241 ft_section != NULL; 1242 ft_section = ft_section->next) 1243 { 1244 ft_datasize = ft_section->size; 1245 if (ft_addr >= ft_section->vma 1246 && ft_addr < ft_section->vma + ft_datasize) 1247 break; 1248 } 1249 1250 if (ft_section == NULL) 1251 { 1252 fprintf (file, 1253 _("\nThere is a first thunk, but the section containing it could not be found\n")); 1254 continue; 1255 } 1256 1257 /* Now check to see if this section is the same as our current 1258 section. If it is not then we will have to load its data in. */ 1259 if (ft_section == section) 1260 { 1261 ft_data = data; 1262 ft_idx = first_thunk - adj; 1263 } 1264 else 1265 { 1266 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase); 1267 ft_data = bfd_malloc (datasize); 1268 if (ft_data == NULL) 1269 continue; 1270 1271 /* Read datasize bfd_bytes starting at offset ft_idx. */ 1272 if (! bfd_get_section_contents 1273 (abfd, ft_section, ft_data, (bfd_vma) ft_idx, datasize)) 1274 { 1275 free (ft_data); 1276 continue; 1277 } 1278 1279 ft_idx = 0; 1280 ft_allocated = 1; 1281 } 1282 } 1283 1284 /* Print HintName vector entries. */ 1285#ifdef COFF_WITH_pex64 1286 for (j = 0; j < datasize; j += 8) 1287 { 1288 unsigned long member = bfd_get_32 (abfd, data + idx + j); 1289 unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4); 1290 1291 if (!member && !member_high) 1292 break; 1293 1294 if (member_high & 0x80000000) 1295 fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>", 1296 member_high,member, member_high & 0x7fffffff, member); 1297 else 1298 { 1299 int ordinal; 1300 char *member_name; 1301 1302 ordinal = bfd_get_16 (abfd, data + member - adj); 1303 member_name = (char *) data + member - adj + 2; 1304 fprintf (file, "\t%04lx\t %4d %s",member, ordinal, member_name); 1305 } 1306 1307 /* If the time stamp is not zero, the import address 1308 table holds actual addresses. */ 1309 if (time_stamp != 0 1310 && first_thunk != 0 1311 && first_thunk != hint_addr) 1312 fprintf (file, "\t%04lx", 1313 (long) bfd_get_32 (abfd, ft_data + ft_idx + j)); 1314 fprintf (file, "\n"); 1315 } 1316#else 1317 for (j = 0; j < datasize; j += 4) 1318 { 1319 unsigned long member = bfd_get_32 (abfd, data + idx + j); 1320 1321 /* Print single IMAGE_IMPORT_BY_NAME vector. */ 1322 if (member == 0) 1323 break; 1324 1325 if (member & 0x80000000) 1326 fprintf (file, "\t%04lx\t %4lu <none>", 1327 member, member & 0x7fffffff); 1328 else 1329 { 1330 int ordinal; 1331 char *member_name; 1332 1333 ordinal = bfd_get_16 (abfd, data + member - adj); 1334 member_name = (char *) data + member - adj + 2; 1335 fprintf (file, "\t%04lx\t %4d %s", 1336 member, ordinal, member_name); 1337 } 1338 1339 /* If the time stamp is not zero, the import address 1340 table holds actual addresses. */ 1341 if (time_stamp != 0 1342 && first_thunk != 0 1343 && first_thunk != hint_addr) 1344 fprintf (file, "\t%04lx", 1345 (long) bfd_get_32 (abfd, ft_data + ft_idx + j)); 1346 1347 fprintf (file, "\n"); 1348 } 1349#endif 1350 if (ft_allocated) 1351 free (ft_data); 1352 } 1353 1354 fprintf (file, "\n"); 1355 } 1356 1357 free (data); 1358 1359 return TRUE; 1360} 1361 1362static bfd_boolean 1363pe_print_edata (bfd * abfd, void * vfile) 1364{ 1365 FILE *file = (FILE *) vfile; 1366 bfd_byte *data; 1367 asection *section; 1368 bfd_size_type datasize = 0; 1369 bfd_size_type dataoff; 1370 bfd_size_type i; 1371 bfd_signed_vma adj; 1372 struct EDT_type 1373 { 1374 long export_flags; /* Reserved - should be zero. */ 1375 long time_stamp; 1376 short major_ver; 1377 short minor_ver; 1378 bfd_vma name; /* RVA - relative to image base. */ 1379 long base; /* Ordinal base. */ 1380 unsigned long num_functions;/* Number in the export address table. */ 1381 unsigned long num_names; /* Number in the name pointer table. */ 1382 bfd_vma eat_addr; /* RVA to the export address table. */ 1383 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */ 1384 bfd_vma ot_addr; /* RVA to the Ordinal Table. */ 1385 } edt; 1386 1387 pe_data_type *pe = pe_data (abfd); 1388 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr; 1389 1390 bfd_vma addr; 1391 1392 addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress; 1393 1394 if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0) 1395 { 1396 /* Maybe the extra header isn't there. Look for the section. */ 1397 section = bfd_get_section_by_name (abfd, ".edata"); 1398 if (section == NULL) 1399 return TRUE; 1400 1401 addr = section->vma; 1402 dataoff = 0; 1403 datasize = section->size; 1404 if (datasize == 0) 1405 return TRUE; 1406 } 1407 else 1408 { 1409 addr += extra->ImageBase; 1410 1411 for (section = abfd->sections; section != NULL; section = section->next) 1412 if (addr >= section->vma && addr < section->vma + section->size) 1413 break; 1414 1415 if (section == NULL) 1416 { 1417 fprintf (file, 1418 _("\nThere is an export table, but the section containing it could not be found\n")); 1419 return TRUE; 1420 } 1421 1422 dataoff = addr - section->vma; 1423 datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size; 1424 if (datasize > section->size - dataoff) 1425 { 1426 fprintf (file, 1427 _("\nThere is an export table in %s, but it does not fit into that section\n"), 1428 section->name); 1429 return TRUE; 1430 } 1431 } 1432 1433 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"), 1434 section->name, (unsigned long) addr); 1435 1436 data = bfd_malloc (datasize); 1437 if (data == NULL) 1438 return FALSE; 1439 1440 if (! bfd_get_section_contents (abfd, section, data, 1441 (file_ptr) dataoff, datasize)) 1442 return FALSE; 1443 1444 /* Go get Export Directory Table. */ 1445 edt.export_flags = bfd_get_32 (abfd, data + 0); 1446 edt.time_stamp = bfd_get_32 (abfd, data + 4); 1447 edt.major_ver = bfd_get_16 (abfd, data + 8); 1448 edt.minor_ver = bfd_get_16 (abfd, data + 10); 1449 edt.name = bfd_get_32 (abfd, data + 12); 1450 edt.base = bfd_get_32 (abfd, data + 16); 1451 edt.num_functions = bfd_get_32 (abfd, data + 20); 1452 edt.num_names = bfd_get_32 (abfd, data + 24); 1453 edt.eat_addr = bfd_get_32 (abfd, data + 28); 1454 edt.npt_addr = bfd_get_32 (abfd, data + 32); 1455 edt.ot_addr = bfd_get_32 (abfd, data + 36); 1456 1457 adj = section->vma - extra->ImageBase + dataoff; 1458 1459 /* Dump the EDT first. */ 1460 fprintf (file, 1461 _("\nThe Export Tables (interpreted %s section contents)\n\n"), 1462 section->name); 1463 1464 fprintf (file, 1465 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags); 1466 1467 fprintf (file, 1468 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp); 1469 1470 fprintf (file, 1471 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver); 1472 1473 fprintf (file, 1474 _("Name \t\t\t\t")); 1475 fprintf_vma (file, edt.name); 1476 fprintf (file, 1477 " %s\n", data + edt.name - adj); 1478 1479 fprintf (file, 1480 _("Ordinal Base \t\t\t%ld\n"), edt.base); 1481 1482 fprintf (file, 1483 _("Number in:\n")); 1484 1485 fprintf (file, 1486 _("\tExport Address Table \t\t%08lx\n"), 1487 edt.num_functions); 1488 1489 fprintf (file, 1490 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names); 1491 1492 fprintf (file, 1493 _("Table Addresses\n")); 1494 1495 fprintf (file, 1496 _("\tExport Address Table \t\t")); 1497 fprintf_vma (file, edt.eat_addr); 1498 fprintf (file, "\n"); 1499 1500 fprintf (file, 1501 _("\tName Pointer Table \t\t")); 1502 fprintf_vma (file, edt.npt_addr); 1503 fprintf (file, "\n"); 1504 1505 fprintf (file, 1506 _("\tOrdinal Table \t\t\t")); 1507 fprintf_vma (file, edt.ot_addr); 1508 fprintf (file, "\n"); 1509 1510 /* The next table to find is the Export Address Table. It's basically 1511 a list of pointers that either locate a function in this dll, or 1512 forward the call to another dll. Something like: 1513 typedef union 1514 { 1515 long export_rva; 1516 long forwarder_rva; 1517 } export_address_table_entry; */ 1518 1519 fprintf (file, 1520 _("\nExport Address Table -- Ordinal Base %ld\n"), 1521 edt.base); 1522 1523 for (i = 0; i < edt.num_functions; ++i) 1524 { 1525 bfd_vma eat_member = bfd_get_32 (abfd, 1526 data + edt.eat_addr + (i * 4) - adj); 1527 if (eat_member == 0) 1528 continue; 1529 1530 if (eat_member - adj <= datasize) 1531 { 1532 /* This rva is to a name (forwarding function) in our section. */ 1533 /* Should locate a function descriptor. */ 1534 fprintf (file, 1535 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n", 1536 (long) i, 1537 (long) (i + edt.base), 1538 (unsigned long) eat_member, 1539 _("Forwarder RVA"), 1540 data + eat_member - adj); 1541 } 1542 else 1543 { 1544 /* Should locate a function descriptor in the reldata section. */ 1545 fprintf (file, 1546 "\t[%4ld] +base[%4ld] %04lx %s\n", 1547 (long) i, 1548 (long) (i + edt.base), 1549 (unsigned long) eat_member, 1550 _("Export RVA")); 1551 } 1552 } 1553 1554 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */ 1555 /* Dump them in parallel for clarity. */ 1556 fprintf (file, 1557 _("\n[Ordinal/Name Pointer] Table\n")); 1558 1559 for (i = 0; i < edt.num_names; ++i) 1560 { 1561 bfd_vma name_ptr = bfd_get_32 (abfd, 1562 data + 1563 edt.npt_addr 1564 + (i*4) - adj); 1565 1566 char *name = (char *) data + name_ptr - adj; 1567 1568 bfd_vma ord = bfd_get_16 (abfd, 1569 data + 1570 edt.ot_addr 1571 + (i*2) - adj); 1572 fprintf (file, 1573 "\t[%4ld] %s\n", (long) ord, name); 1574 } 1575 1576 free (data); 1577 1578 return TRUE; 1579} 1580 1581/* This really is architecture dependent. On IA-64, a .pdata entry 1582 consists of three dwords containing relative virtual addresses that 1583 specify the start and end address of the code range the entry 1584 covers and the address of the corresponding unwind info data. */ 1585 1586static bfd_boolean 1587pe_print_pdata (bfd * abfd, void * vfile) 1588{ 1589#if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 1590# define PDATA_ROW_SIZE (3 * 8) 1591#else 1592# define PDATA_ROW_SIZE (5 * 4) 1593#endif 1594 FILE *file = (FILE *) vfile; 1595 bfd_byte *data = 0; 1596 asection *section = bfd_get_section_by_name (abfd, ".pdata"); 1597 bfd_size_type datasize = 0; 1598 bfd_size_type i; 1599 bfd_size_type start, stop; 1600 int onaline = PDATA_ROW_SIZE; 1601 1602 if (section == NULL 1603 || coff_section_data (abfd, section) == NULL 1604 || pei_section_data (abfd, section) == NULL) 1605 return TRUE; 1606 1607 stop = pei_section_data (abfd, section)->virt_size; 1608 if ((stop % onaline) != 0) 1609 fprintf (file, 1610 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"), 1611 (long) stop, onaline); 1612 1613 fprintf (file, 1614 _("\nThe Function Table (interpreted .pdata section contents)\n")); 1615#if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 1616 fprintf (file, 1617 _(" vma:\t\t\tBegin Address End Address Unwind Info\n")); 1618#else 1619 fprintf (file, _("\ 1620 vma:\t\tBegin End EH EH PrologEnd Exception\n\ 1621 \t\tAddress Address Handler Data Address Mask\n")); 1622#endif 1623 1624 datasize = section->size; 1625 if (datasize == 0) 1626 return TRUE; 1627 1628 if (! bfd_malloc_and_get_section (abfd, section, &data)) 1629 { 1630 if (data != NULL) 1631 free (data); 1632 return FALSE; 1633 } 1634 1635 start = 0; 1636 1637 for (i = start; i < stop; i += onaline) 1638 { 1639 bfd_vma begin_addr; 1640 bfd_vma end_addr; 1641 bfd_vma eh_handler; 1642 bfd_vma eh_data; 1643 bfd_vma prolog_end_addr; 1644 int em_data; 1645 1646 if (i + PDATA_ROW_SIZE > stop) 1647 break; 1648 1649 begin_addr = GET_PDATA_ENTRY (abfd, data + i ); 1650 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4); 1651 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8); 1652 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12); 1653 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16); 1654 1655 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0 1656 && eh_data == 0 && prolog_end_addr == 0) 1657 /* We are probably into the padding of the section now. */ 1658 break; 1659 1660 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3); 1661 eh_handler &= ~(bfd_vma) 0x3; 1662 prolog_end_addr &= ~(bfd_vma) 0x3; 1663 1664 fputc (' ', file); 1665 fprintf_vma (file, i + section->vma); fputc ('\t', file); 1666 fprintf_vma (file, begin_addr); fputc (' ', file); 1667 fprintf_vma (file, end_addr); fputc (' ', file); 1668 fprintf_vma (file, eh_handler); 1669#if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) 1670 fputc (' ', file); 1671 fprintf_vma (file, eh_data); fputc (' ', file); 1672 fprintf_vma (file, prolog_end_addr); 1673 fprintf (file, " %x", em_data); 1674#endif 1675 1676#ifdef POWERPC_LE_PE 1677 if (eh_handler == 0 && eh_data != 0) 1678 { 1679 /* Special bits here, although the meaning may be a little 1680 mysterious. The only one I know for sure is 0x03 1681 Code Significance 1682 0x00 None 1683 0x01 Register Save Millicode 1684 0x02 Register Restore Millicode 1685 0x03 Glue Code Sequence. */ 1686 switch (eh_data) 1687 { 1688 case 0x01: 1689 fprintf (file, _(" Register save millicode")); 1690 break; 1691 case 0x02: 1692 fprintf (file, _(" Register restore millicode")); 1693 break; 1694 case 0x03: 1695 fprintf (file, _(" Glue code sequence")); 1696 break; 1697 default: 1698 break; 1699 } 1700 } 1701#endif 1702 fprintf (file, "\n"); 1703 } 1704 1705 free (data); 1706 1707 return TRUE; 1708} 1709 1710#define IMAGE_REL_BASED_HIGHADJ 4 1711static const char * const tbl[] = 1712{ 1713 "ABSOLUTE", 1714 "HIGH", 1715 "LOW", 1716 "HIGHLOW", 1717 "HIGHADJ", 1718 "MIPS_JMPADDR", 1719 "SECTION", 1720 "REL32", 1721 "RESERVED1", 1722 "MIPS_JMPADDR16", 1723 "DIR64", 1724 "HIGH3ADJ", 1725 "UNKNOWN", /* MUST be last. */ 1726}; 1727 1728static bfd_boolean 1729pe_print_reloc (bfd * abfd, void * vfile) 1730{ 1731 FILE *file = (FILE *) vfile; 1732 bfd_byte *data = 0; 1733 asection *section = bfd_get_section_by_name (abfd, ".reloc"); 1734 bfd_size_type datasize; 1735 bfd_size_type i; 1736 bfd_size_type start, stop; 1737 1738 if (section == NULL) 1739 return TRUE; 1740 1741 if (section->size == 0) 1742 return TRUE; 1743 1744 fprintf (file, 1745 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n")); 1746 1747 datasize = section->size; 1748 if (! bfd_malloc_and_get_section (abfd, section, &data)) 1749 { 1750 if (data != NULL) 1751 free (data); 1752 return FALSE; 1753 } 1754 1755 start = 0; 1756 1757 stop = section->size; 1758 1759 for (i = start; i < stop;) 1760 { 1761 int j; 1762 bfd_vma virtual_address; 1763 long number, size; 1764 1765 /* The .reloc section is a sequence of blocks, with a header consisting 1766 of two 32 bit quantities, followed by a number of 16 bit entries. */ 1767 virtual_address = bfd_get_32 (abfd, data+i); 1768 size = bfd_get_32 (abfd, data+i+4); 1769 number = (size - 8) / 2; 1770 1771 if (size == 0) 1772 break; 1773 1774 fprintf (file, 1775 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"), 1776 (unsigned long) virtual_address, size, size, number); 1777 1778 for (j = 0; j < number; ++j) 1779 { 1780 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2); 1781 unsigned int t = (e & 0xF000) >> 12; 1782 int off = e & 0x0FFF; 1783 1784 if (t >= sizeof (tbl) / sizeof (tbl[0])) 1785 t = (sizeof (tbl) / sizeof (tbl[0])) - 1; 1786 1787 fprintf (file, 1788 _("\treloc %4d offset %4x [%4lx] %s"), 1789 j, off, (long) (off + virtual_address), tbl[t]); 1790 1791 /* HIGHADJ takes an argument, - the next record *is* the 1792 low 16 bits of addend. */ 1793 if (t == IMAGE_REL_BASED_HIGHADJ) 1794 { 1795 fprintf (file, " (%4x)", 1796 ((unsigned int) 1797 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2))); 1798 j++; 1799 } 1800 1801 fprintf (file, "\n"); 1802 } 1803 1804 i += size; 1805 } 1806 1807 free (data); 1808 1809 return TRUE; 1810} 1811 1812/* Print out the program headers. */ 1813 1814bfd_boolean 1815_bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile) 1816{ 1817 FILE *file = (FILE *) vfile; 1818 int j; 1819 pe_data_type *pe = pe_data (abfd); 1820 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr; 1821 const char *subsystem_name = NULL; 1822 const char *name; 1823 1824 /* The MS dumpbin program reportedly ands with 0xff0f before 1825 printing the characteristics field. Not sure why. No reason to 1826 emulate it here. */ 1827 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags); 1828#undef PF 1829#define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); } 1830 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped"); 1831 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable"); 1832 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped"); 1833 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped"); 1834 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware"); 1835 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian"); 1836 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words"); 1837 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed"); 1838 PF (IMAGE_FILE_SYSTEM, "system file"); 1839 PF (IMAGE_FILE_DLL, "DLL"); 1840 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian"); 1841#undef PF 1842 1843 /* ctime implies '\n'. */ 1844 { 1845 time_t t = pe->coff.timestamp; 1846 fprintf (file, "\nTime/Date\t\t%s", ctime (&t)); 1847 } 1848 1849#ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC 1850# define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b 1851#endif 1852#ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC 1853# define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b 1854#endif 1855#ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC 1856# define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107 1857#endif 1858 1859 switch (i->Magic) 1860 { 1861 case IMAGE_NT_OPTIONAL_HDR_MAGIC: 1862 name = "PE32"; 1863 break; 1864 case IMAGE_NT_OPTIONAL_HDR64_MAGIC: 1865 name = "PE32+"; 1866 break; 1867 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC: 1868 name = "ROM"; 1869 break; 1870 default: 1871 name = NULL; 1872 break; 1873 } 1874 fprintf (file, "Magic\t\t\t%04x", i->Magic); 1875 if (name) 1876 fprintf (file, "\t(%s)",name); 1877 fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion); 1878 fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion); 1879 fprintf (file, "SizeOfCode\t\t%08lx\n", i->SizeOfCode); 1880 fprintf (file, "SizeOfInitializedData\t%08lx\n", 1881 i->SizeOfInitializedData); 1882 fprintf (file, "SizeOfUninitializedData\t%08lx\n", 1883 i->SizeOfUninitializedData); 1884 fprintf (file, "AddressOfEntryPoint\t"); 1885 fprintf_vma (file, i->AddressOfEntryPoint); 1886 fprintf (file, "\nBaseOfCode\t\t"); 1887 fprintf_vma (file, i->BaseOfCode); 1888#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) 1889 /* PE32+ does not have BaseOfData member! */ 1890 fprintf (file, "\nBaseOfData\t\t"); 1891 fprintf_vma (file, i->BaseOfData); 1892#endif 1893 1894 fprintf (file, "\nImageBase\t\t"); 1895 fprintf_vma (file, i->ImageBase); 1896 fprintf (file, "\nSectionAlignment\t"); 1897 fprintf_vma (file, i->SectionAlignment); 1898 fprintf (file, "\nFileAlignment\t\t"); 1899 fprintf_vma (file, i->FileAlignment); 1900 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion); 1901 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion); 1902 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion); 1903 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion); 1904 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion); 1905 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion); 1906 fprintf (file, "Win32Version\t\t%08lx\n", i->Reserved1); 1907 fprintf (file, "SizeOfImage\t\t%08lx\n", i->SizeOfImage); 1908 fprintf (file, "SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders); 1909 fprintf (file, "CheckSum\t\t%08lx\n", i->CheckSum); 1910 1911 switch (i->Subsystem) 1912 { 1913 case IMAGE_SUBSYSTEM_UNKNOWN: 1914 subsystem_name = "unspecified"; 1915 break; 1916 case IMAGE_SUBSYSTEM_NATIVE: 1917 subsystem_name = "NT native"; 1918 break; 1919 case IMAGE_SUBSYSTEM_WINDOWS_GUI: 1920 subsystem_name = "Windows GUI"; 1921 break; 1922 case IMAGE_SUBSYSTEM_WINDOWS_CUI: 1923 subsystem_name = "Windows CUI"; 1924 break; 1925 case IMAGE_SUBSYSTEM_POSIX_CUI: 1926 subsystem_name = "POSIX CUI"; 1927 break; 1928 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI: 1929 subsystem_name = "Wince CUI"; 1930 break; 1931 case IMAGE_SUBSYSTEM_EFI_APPLICATION: 1932 subsystem_name = "EFI application"; 1933 break; 1934 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER: 1935 subsystem_name = "EFI boot service driver"; 1936 break; 1937 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER: 1938 subsystem_name = "EFI runtime driver"; 1939 break; 1940 // These are from revision 8.0 of the MS PE/COFF spec 1941 case IMAGE_SUBSYSTEM_EFI_ROM: 1942 subsystem_name = "EFI ROM"; 1943 break; 1944 case IMAGE_SUBSYSTEM_XBOX: 1945 subsystem_name = "XBOX"; 1946 break; 1947 // Added default case for clarity - subsystem_name is NULL anyway. 1948 default: 1949 subsystem_name = NULL; 1950 } 1951 1952 fprintf (file, "Subsystem\t\t%08x", i->Subsystem); 1953 if (subsystem_name) 1954 fprintf (file, "\t(%s)", subsystem_name); 1955 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics); 1956 fprintf (file, "SizeOfStackReserve\t"); 1957 fprintf_vma (file, i->SizeOfStackReserve); 1958 fprintf (file, "\nSizeOfStackCommit\t"); 1959 fprintf_vma (file, i->SizeOfStackCommit); 1960 fprintf (file, "\nSizeOfHeapReserve\t"); 1961 fprintf_vma (file, i->SizeOfHeapReserve); 1962 fprintf (file, "\nSizeOfHeapCommit\t"); 1963 fprintf_vma (file, i->SizeOfHeapCommit); 1964 fprintf (file, "\nLoaderFlags\t\t%08lx\n", i->LoaderFlags); 1965 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes); 1966 1967 fprintf (file, "\nThe Data Directory\n"); 1968 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++) 1969 { 1970 fprintf (file, "Entry %1x ", j); 1971 fprintf_vma (file, i->DataDirectory[j].VirtualAddress); 1972 fprintf (file, " %08lx ", i->DataDirectory[j].Size); 1973 fprintf (file, "%s\n", dir_names[j]); 1974 } 1975 1976 pe_print_idata (abfd, vfile); 1977 pe_print_edata (abfd, vfile); 1978 pe_print_pdata (abfd, vfile); 1979 pe_print_reloc (abfd, vfile); 1980 1981 return TRUE; 1982} 1983 1984/* Copy any private info we understand from the input bfd 1985 to the output bfd. */ 1986 1987bfd_boolean 1988_bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd) 1989{ 1990 /* One day we may try to grok other private data. */ 1991 if (ibfd->xvec->flavour != bfd_target_coff_flavour 1992 || obfd->xvec->flavour != bfd_target_coff_flavour) 1993 return TRUE; 1994 1995 pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr; 1996 pe_data (obfd)->dll = pe_data (ibfd)->dll; 1997 1998 /* For strip: if we removed .reloc, we'll make a real mess of things 1999 if we don't remove this entry as well. */ 2000 if (! pe_data (obfd)->has_reloc_section) 2001 { 2002 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0; 2003 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0; 2004 } 2005 return TRUE; 2006} 2007 2008/* Copy private section data. */ 2009 2010bfd_boolean 2011_bfd_XX_bfd_copy_private_section_data (bfd *ibfd, 2012 asection *isec, 2013 bfd *obfd, 2014 asection *osec) 2015{ 2016 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour 2017 || bfd_get_flavour (obfd) != bfd_target_coff_flavour) 2018 return TRUE; 2019 2020 if (coff_section_data (ibfd, isec) != NULL 2021 && pei_section_data (ibfd, isec) != NULL) 2022 { 2023 if (coff_section_data (obfd, osec) == NULL) 2024 { 2025 bfd_size_type amt = sizeof (struct coff_section_tdata); 2026 osec->used_by_bfd = bfd_zalloc (obfd, amt); 2027 if (osec->used_by_bfd == NULL) 2028 return FALSE; 2029 } 2030 2031 if (pei_section_data (obfd, osec) == NULL) 2032 { 2033 bfd_size_type amt = sizeof (struct pei_section_tdata); 2034 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt); 2035 if (coff_section_data (obfd, osec)->tdata == NULL) 2036 return FALSE; 2037 } 2038 2039 pei_section_data (obfd, osec)->virt_size = 2040 pei_section_data (ibfd, isec)->virt_size; 2041 pei_section_data (obfd, osec)->pe_flags = 2042 pei_section_data (ibfd, isec)->pe_flags; 2043 } 2044 2045 return TRUE; 2046} 2047 2048void 2049_bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret) 2050{ 2051 coff_get_symbol_info (abfd, symbol, ret); 2052} 2053 2054/* Handle the .idata section and other things that need symbol table 2055 access. */ 2056 2057bfd_boolean 2058_bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo) 2059{ 2060 struct coff_link_hash_entry *h1; 2061 struct bfd_link_info *info = pfinfo->info; 2062 bfd_boolean result = TRUE; 2063 2064 /* There are a few fields that need to be filled in now while we 2065 have symbol table access. 2066 2067 The .idata subsections aren't directly available as sections, but 2068 they are in the symbol table, so get them from there. */ 2069 2070 /* The import directory. This is the address of .idata$2, with size 2071 of .idata$2 + .idata$3. */ 2072 h1 = coff_link_hash_lookup (coff_hash_table (info), 2073 ".idata$2", FALSE, FALSE, TRUE); 2074 if (h1 != NULL) 2075 { 2076 /* PR ld/2729: We cannot rely upon all the output sections having been 2077 created properly, so check before referencing them. Issue a warning 2078 message for any sections tht could not be found. */ 2079 if (h1->root.u.def.section != NULL 2080 && h1->root.u.def.section->output_section != NULL) 2081 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress = 2082 (h1->root.u.def.value 2083 + h1->root.u.def.section->output_section->vma 2084 + h1->root.u.def.section->output_offset); 2085 else 2086 { 2087 _bfd_error_handler 2088 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"), 2089 abfd); 2090 result = FALSE; 2091 } 2092 2093 h1 = coff_link_hash_lookup (coff_hash_table (info), 2094 ".idata$4", FALSE, FALSE, TRUE); 2095 if (h1 != NULL 2096 && h1->root.u.def.section != NULL 2097 && h1->root.u.def.section->output_section != NULL) 2098 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size = 2099 ((h1->root.u.def.value 2100 + h1->root.u.def.section->output_section->vma 2101 + h1->root.u.def.section->output_offset) 2102 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress); 2103 else 2104 { 2105 _bfd_error_handler 2106 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"), 2107 abfd); 2108 result = FALSE; 2109 } 2110 2111 /* The import address table. This is the size/address of 2112 .idata$5. */ 2113 h1 = coff_link_hash_lookup (coff_hash_table (info), 2114 ".idata$5", FALSE, FALSE, TRUE); 2115 if (h1 != NULL 2116 && h1->root.u.def.section != NULL 2117 && h1->root.u.def.section->output_section != NULL) 2118 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress = 2119 (h1->root.u.def.value 2120 + h1->root.u.def.section->output_section->vma 2121 + h1->root.u.def.section->output_offset); 2122 else 2123 { 2124 _bfd_error_handler 2125 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"), 2126 abfd); 2127 result = FALSE; 2128 } 2129 2130 h1 = coff_link_hash_lookup (coff_hash_table (info), 2131 ".idata$6", FALSE, FALSE, TRUE); 2132 if (h1 != NULL 2133 && h1->root.u.def.section != NULL 2134 && h1->root.u.def.section->output_section != NULL) 2135 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size = 2136 ((h1->root.u.def.value 2137 + h1->root.u.def.section->output_section->vma 2138 + h1->root.u.def.section->output_offset) 2139 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress); 2140 else 2141 { 2142 _bfd_error_handler 2143 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"), 2144 abfd); 2145 result = FALSE; 2146 } 2147 } 2148 2149 h1 = coff_link_hash_lookup (coff_hash_table (info), 2150 "__tls_used", FALSE, FALSE, TRUE); 2151 if (h1 != NULL) 2152 { 2153 if (h1->root.u.def.section != NULL 2154 && h1->root.u.def.section->output_section != NULL) 2155 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress = 2156 (h1->root.u.def.value 2157 + h1->root.u.def.section->output_section->vma 2158 + h1->root.u.def.section->output_offset 2159 - pe_data (abfd)->pe_opthdr.ImageBase); 2160 else 2161 { 2162 _bfd_error_handler 2163 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"), 2164 abfd); 2165 result = FALSE; 2166 } 2167 2168 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18; 2169 } 2170 2171 /* If we couldn't find idata$2, we either have an excessively 2172 trivial program or are in DEEP trouble; we have to assume trivial 2173 program.... */ 2174 return result; 2175} 2176