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