bfd/peXXigen.c

   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 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 "bfd.h"
  60 #include "sysdep.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 \f
  94 void
  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
 192 unsigned 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
 220 void
 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
 291 unsigned 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
 365 void
 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
 375 unsigned 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
 386 void
 387 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
 388                           void * aouthdr_ext1,
 389                           void * aouthdr_int1)
 390 {
 391   struct internal_extra_pe_aouthdr *a;
 392   PEAOUTHDR * src = (PEAOUTHDR *) (aouthdr_ext1);
 393   AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
 394   struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
 395
 396   aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
 397   aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
 398   aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
 399   aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
 400   aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
 401   aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
 402   aouthdr_int->text_start =
 403     GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
 404 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 405   /* PE32+ does not have data_start member!  */
 406   aouthdr_int->data_start =
 407     GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
 408 #endif
 409
 410   a = &aouthdr_int->pe;
 411   a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
 412   a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
 413   a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
 414   a->MajorOperatingSystemVersion =
 415     H_GET_16 (abfd, src->MajorOperatingSystemVersion);
 416   a->MinorOperatingSystemVersion =
 417     H_GET_16 (abfd, src->MinorOperatingSystemVersion);
 418   a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
 419   a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
 420   a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
 421   a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
 422   a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
 423   a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
 424   a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
 425   a->CheckSum = H_GET_32 (abfd, src->CheckSum);
 426   a->Subsystem = H_GET_16 (abfd, src->Subsystem);
 427   a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
 428   a->SizeOfStackReserve =
 429     GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
 430   a->SizeOfStackCommit =
 431     GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
 432   a->SizeOfHeapReserve =
 433     GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
 434   a->SizeOfHeapCommit =
 435     GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
 436   a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
 437   a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
 438
 439   {
 440     int idx;
 441
 442     for (idx = 0; idx < 16; idx++)
 443       {
 444         /* If data directory is empty, rva also should be 0.  */
 445         int size =
 446           H_GET_32 (abfd, src->DataDirectory[idx][1]);
 447
 448         a->DataDirectory[idx].Size = size;
 449
 450         if (size)
 451           a->DataDirectory[idx].VirtualAddress =
 452             H_GET_32 (abfd, src->DataDirectory[idx][0]);
 453         else
 454           a->DataDirectory[idx].VirtualAddress = 0;
 455       }
 456   }
 457
 458   if (aouthdr_int->entry)
 459     {
 460       aouthdr_int->entry += a->ImageBase;
 461 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 462       aouthdr_int->entry &= 0xffffffff;
 463 #endif
 464     }
 465
 466   if (aouthdr_int->tsize)
 467     {
 468       aouthdr_int->text_start += a->ImageBase;
 469 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 470       aouthdr_int->text_start &= 0xffffffff;
 471 #endif
 472     }
 473
 474 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 475   /* PE32+ does not have data_start member!  */
 476   if (aouthdr_int->dsize)
 477     {
 478       aouthdr_int->data_start += a->ImageBase;
 479       aouthdr_int->data_start &= 0xffffffff;
 480     }
 481 #endif
 482
 483 #ifdef POWERPC_LE_PE
 484   /* These three fields are normally set up by ppc_relocate_section.
 485      In the case of reading a file in, we can pick them up from the
 486      DataDirectory.  */
 487   first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
 488   thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
 489   import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
 490 #endif
 491 }
 492
 493 /* A support function for below.  */
 494
 495 static void
 496 add_data_entry (bfd * abfd,
 497                 struct internal_extra_pe_aouthdr *aout,
 498                 int idx,
 499                 char *name,
 500                 bfd_vma base)
 501 {
 502   asection *sec = bfd_get_section_by_name (abfd, name);
 503
 504   /* Add import directory information if it exists.  */
 505   if ((sec != NULL)
 506       && (coff_section_data (abfd, sec) != NULL)
 507       && (pei_section_data (abfd, sec) != NULL))
 508     {
 509       /* If data directory is empty, rva also should be 0.  */
 510       int size = pei_section_data (abfd, sec)->virt_size;
 511       aout->DataDirectory[idx].Size = size;
 512
 513       if (size)
 514         {
 515           aout->DataDirectory[idx].VirtualAddress =
 516             (sec->vma - base) & 0xffffffff;
 517           sec->flags |= SEC_DATA;
 518         }
 519     }
 520 }
 521
 522 unsigned int
 523 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
 524 {
 525   struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
 526   pe_data_type *pe = pe_data (abfd);
 527   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
 528   PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
 529   bfd_vma sa, fa, ib;
 530   IMAGE_DATA_DIRECTORY idata2, idata5, tls;
 531
 532   if (pe->force_minimum_alignment)
 533     {
 534       if (!extra->FileAlignment)
 535         extra->FileAlignment = PE_DEF_FILE_ALIGNMENT;
 536       if (!extra->SectionAlignment)
 537         extra->SectionAlignment = PE_DEF_SECTION_ALIGNMENT;
 538     }
 539
 540   if (extra->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
 541     extra->Subsystem = pe->target_subsystem;
 542
 543   sa = extra->SectionAlignment;
 544   fa = extra->FileAlignment;
 545   ib = extra->ImageBase;
 546
 547   idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
 548   idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
 549   tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
 550
 551   if (aouthdr_in->tsize)
 552     {
 553       aouthdr_in->text_start -= ib;
 554 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 555       aouthdr_in->text_start &= 0xffffffff;
 556 #endif
 557     }
 558
 559   if (aouthdr_in->dsize)
 560     {
 561       aouthdr_in->data_start -= ib;
 562 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 563       aouthdr_in->data_start &= 0xffffffff;
 564 #endif
 565     }
 566
 567   if (aouthdr_in->entry)
 568     {
 569       aouthdr_in->entry -= ib;
 570 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 571       aouthdr_in->entry &= 0xffffffff;
 572 #endif
 573     }
 574
 575 #define FA(x) (((x) + fa -1 ) & (- fa))
 576 #define SA(x) (((x) + sa -1 ) & (- sa))
 577
 578   /* We like to have the sizes aligned.  */
 579   aouthdr_in->bsize = FA (aouthdr_in->bsize);
 580
 581   extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
 582
 583   /* First null out all data directory entries.  */
 584   memset (extra->DataDirectory, 0, sizeof (extra->DataDirectory));
 585
 586   add_data_entry (abfd, extra, 0, ".edata", ib);
 587   add_data_entry (abfd, extra, 2, ".rsrc", ib);
 588   add_data_entry (abfd, extra, 3, ".pdata", ib);
 589
 590   /* In theory we do not need to call add_data_entry for .idata$2 or
 591      .idata$5.  It will be done in bfd_coff_final_link where all the
 592      required information is available.  If however, we are not going
 593      to perform a final link, eg because we have been invoked by objcopy
 594      or strip, then we need to make sure that these Data Directory
 595      entries are initialised properly.
 596
 597      So - we copy the input values into the output values, and then, if
 598      a final link is going to be performed, it can overwrite them.  */
 599   extra->DataDirectory[PE_IMPORT_TABLE]  = idata2;
 600   extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
 601   extra->DataDirectory[PE_TLS_TABLE] = tls;
 602
 603   if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
 604     /* Until other .idata fixes are made (pending patch), the entry for
 605        .idata is needed for backwards compatibility.  FIXME.  */
 606     add_data_entry (abfd, extra, 1, ".idata", ib);
 607
 608   /* For some reason, the virtual size (which is what's set by
 609      add_data_entry) for .reloc is not the same as the size recorded
 610      in this slot by MSVC; it doesn't seem to cause problems (so far),
 611      but since it's the best we've got, use it.  It does do the right
 612      thing for .pdata.  */
 613   if (pe->has_reloc_section)
 614     add_data_entry (abfd, extra, 5, ".reloc", ib);
 615
 616   {
 617     asection *sec;
 618     bfd_vma hsize = 0;
 619     bfd_vma dsize = 0;
 620     bfd_vma isize = 0;
 621     bfd_vma tsize = 0;
 622
 623     for (sec = abfd->sections; sec; sec = sec->next)
 624       {
 625         int rounded = FA (sec->size);
 626
 627         /* The first non-zero section filepos is the header size.
 628            Sections without contents will have a filepos of 0.  */
 629         if (hsize == 0)
 630           hsize = sec->filepos;
 631         if (sec->flags & SEC_DATA)
 632           dsize += rounded;
 633         if (sec->flags & SEC_CODE)
 634           tsize += rounded;
 635         /* The image size is the total VIRTUAL size (which is what is
 636            in the virt_size field).  Files have been seen (from MSVC
 637            5.0 link.exe) where the file size of the .data segment is
 638            quite small compared to the virtual size.  Without this
 639            fix, strip munges the file.  */
 640         if (coff_section_data (abfd, sec) != NULL
 641             && pei_section_data (abfd, sec) != NULL)
 642           isize += SA (FA (pei_section_data (abfd, sec)->virt_size));
 643       }
 644
 645     aouthdr_in->dsize = dsize;
 646     aouthdr_in->tsize = tsize;
 647     extra->SizeOfHeaders = hsize;
 648     extra->SizeOfImage = SA (hsize) + isize;
 649   }
 650
 651   H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
 652
 653 #define LINKER_VERSION 256 /* That is, 2.56 */
 654
 655   /* This piece of magic sets the "linker version" field to
 656      LINKER_VERSION.  */
 657   H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
 658             aouthdr_out->standard.vstamp);
 659
 660   PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
 661   PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
 662   PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
 663   PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
 664   PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
 665                           aouthdr_out->standard.text_start);
 666
 667 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 668   /* PE32+ does not have data_start member!  */
 669   PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
 670                           aouthdr_out->standard.data_start);
 671 #endif
 672
 673   PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
 674   H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
 675   H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
 676   H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
 677             aouthdr_out->MajorOperatingSystemVersion);
 678   H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
 679             aouthdr_out->MinorOperatingSystemVersion);
 680   H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
 681   H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
 682   H_PUT_16 (abfd, extra->MajorSubsystemVersion,
 683             aouthdr_out->MajorSubsystemVersion);
 684   H_PUT_16 (abfd, extra->MinorSubsystemVersion,
 685             aouthdr_out->MinorSubsystemVersion);
 686   H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
 687   H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
 688   H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
 689   H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
 690   H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
 691   H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
 692   PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
 693                                     aouthdr_out->SizeOfStackReserve);
 694   PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
 695                                    aouthdr_out->SizeOfStackCommit);
 696   PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
 697                                    aouthdr_out->SizeOfHeapReserve);
 698   PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
 699                                   aouthdr_out->SizeOfHeapCommit);
 700   H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
 701   H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
 702             aouthdr_out->NumberOfRvaAndSizes);
 703   {
 704     int idx;
 705
 706     for (idx = 0; idx < 16; idx++)
 707       {
 708         H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
 709                   aouthdr_out->DataDirectory[idx][0]);
 710         H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
 711                   aouthdr_out->DataDirectory[idx][1]);
 712       }
 713   }
 714
 715   return AOUTSZ;
 716 }
 717
 718 unsigned int
 719 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
 720 {
 721   int idx;
 722   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 723   struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
 724
 725   if (pe_data (abfd)->has_reloc_section)
 726     filehdr_in->f_flags &= ~F_RELFLG;
 727
 728   if (pe_data (abfd)->dll)
 729     filehdr_in->f_flags |= F_DLL;
 730
 731   filehdr_in->pe.e_magic    = DOSMAGIC;
 732   filehdr_in->pe.e_cblp     = 0x90;
 733   filehdr_in->pe.e_cp       = 0x3;
 734   filehdr_in->pe.e_crlc     = 0x0;
 735   filehdr_in->pe.e_cparhdr  = 0x4;
 736   filehdr_in->pe.e_minalloc = 0x0;
 737   filehdr_in->pe.e_maxalloc = 0xffff;
 738   filehdr_in->pe.e_ss       = 0x0;
 739   filehdr_in->pe.e_sp       = 0xb8;
 740   filehdr_in->pe.e_csum     = 0x0;
 741   filehdr_in->pe.e_ip       = 0x0;
 742   filehdr_in->pe.e_cs       = 0x0;
 743   filehdr_in->pe.e_lfarlc   = 0x40;
 744   filehdr_in->pe.e_ovno     = 0x0;
 745
 746   for (idx = 0; idx < 4; idx++)
 747     filehdr_in->pe.e_res[idx] = 0x0;
 748
 749   filehdr_in->pe.e_oemid   = 0x0;
 750   filehdr_in->pe.e_oeminfo = 0x0;
 751
 752   for (idx = 0; idx < 10; idx++)
 753     filehdr_in->pe.e_res2[idx] = 0x0;
 754
 755   filehdr_in->pe.e_lfanew = 0x80;
 756
 757   /* This next collection of data are mostly just characters.  It
 758      appears to be constant within the headers put on NT exes.  */
 759   filehdr_in->pe.dos_message[0]  = 0x0eba1f0e;
 760   filehdr_in->pe.dos_message[1]  = 0xcd09b400;
 761   filehdr_in->pe.dos_message[2]  = 0x4c01b821;
 762   filehdr_in->pe.dos_message[3]  = 0x685421cd;
 763   filehdr_in->pe.dos_message[4]  = 0x70207369;
 764   filehdr_in->pe.dos_message[5]  = 0x72676f72;
 765   filehdr_in->pe.dos_message[6]  = 0x63206d61;
 766   filehdr_in->pe.dos_message[7]  = 0x6f6e6e61;
 767   filehdr_in->pe.dos_message[8]  = 0x65622074;
 768   filehdr_in->pe.dos_message[9]  = 0x6e757220;
 769   filehdr_in->pe.dos_message[10] = 0x206e6920;
 770   filehdr_in->pe.dos_message[11] = 0x20534f44;
 771   filehdr_in->pe.dos_message[12] = 0x65646f6d;
 772   filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
 773   filehdr_in->pe.dos_message[14] = 0x24;
 774   filehdr_in->pe.dos_message[15] = 0x0;
 775   filehdr_in->pe.nt_signature = NT_SIGNATURE;
 776
 777   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
 778   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 779
 780   H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
 781   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
 782                       filehdr_out->f_symptr);
 783   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 784   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 785   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 786
 787   /* Put in extra dos header stuff.  This data remains essentially
 788      constant, it just has to be tacked on to the beginning of all exes
 789      for NT.  */
 790   H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
 791   H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
 792   H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
 793   H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
 794   H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
 795   H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
 796   H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
 797   H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
 798   H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
 799   H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
 800   H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
 801   H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
 802   H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
 803   H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
 804
 805   for (idx = 0; idx < 4; idx++)
 806     H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
 807
 808   H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
 809   H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
 810
 811   for (idx = 0; idx < 10; idx++)
 812     H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
 813
 814   H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
 815
 816   for (idx = 0; idx < 16; idx++)
 817     H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
 818               filehdr_out->dos_message[idx]);
 819
 820   /* Also put in the NT signature.  */
 821   H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
 822
 823   return FILHSZ;
 824 }
 825
 826 unsigned int
 827 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
 828 {
 829   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 830   FILHDR *filehdr_out = (FILHDR *) out;
 831
 832   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
 833   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 834   H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
 835   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
 836   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 837   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 838   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 839
 840   return FILHSZ;
 841 }
 842
 843 unsigned int
 844 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
 845 {
 846   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 847   SCNHDR *scnhdr_ext = (SCNHDR *) out;
 848   unsigned int ret = SCNHSZ;
 849   bfd_vma ps;
 850   bfd_vma ss;
 851
 852   memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
 853
 854   PUT_SCNHDR_VADDR (abfd,
 855                     ((scnhdr_int->s_vaddr
 856                       - pe_data (abfd)->pe_opthdr.ImageBase)
 857                      & 0xffffffff),
 858                     scnhdr_ext->s_vaddr);
 859
 860   /* NT wants the size data to be rounded up to the next
 861      NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
 862      sometimes).  */
 863   if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
 864     {
 865       if (bfd_pe_executable_p (abfd))
 866         {
 867           ps = scnhdr_int->s_size;
 868           ss = 0;
 869         }
 870       else
 871        {
 872          ps = 0;
 873          ss = scnhdr_int->s_size;
 874        }
 875     }
 876   else
 877     {
 878       if (bfd_pe_executable_p (abfd))
 879         ps = scnhdr_int->s_paddr;
 880       else
 881         ps = 0;
 882
 883       ss = scnhdr_int->s_size;
 884     }
 885
 886   PUT_SCNHDR_SIZE (abfd, ss,
 887                    scnhdr_ext->s_size);
 888
 889   /* s_paddr in PE is really the virtual size.  */
 890   PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
 891
 892   PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
 893                      scnhdr_ext->s_scnptr);
 894   PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
 895                      scnhdr_ext->s_relptr);
 896   PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
 897                       scnhdr_ext->s_lnnoptr);
 898
 899   {
 900     /* Extra flags must be set when dealing with PE.  All sections should also
 901        have the IMAGE_SCN_MEM_READ (0x40000000) flag set.  In addition, the
 902        .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
 903        sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
 904        (this is especially important when dealing with the .idata section since
 905        the addresses for routines from .dlls must be overwritten).  If .reloc
 906        section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
 907        (0x02000000).  Also, the resource data should also be read and
 908        writable.  */
 909
 910     /* FIXME: Alignment is also encoded in this field, at least on PPC and
 911        ARM-WINCE.  Although - how do we get the original alignment field
 912        back ?  */
 913
 914     typedef struct
 915     {
 916       const char *      section_name;
 917       unsigned long     must_have;
 918     }
 919     pe_required_section_flags;
 920
 921     pe_required_section_flags known_sections [] =
 922       {
 923         { ".arch",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
 924         { ".bss",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 925         { ".data",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 926         { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
 927         { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 928         { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
 929         { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
 930         { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
 931         { ".rsrc",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 932         { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
 933         { ".tls",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 934         { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
 935         { NULL, 0}
 936       };
 937
 938     pe_required_section_flags * p;
 939
 940     /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
 941        we know exactly what this specific section wants so we remove it
 942        and then allow the must_have field to add it back in if necessary.
 943        However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
 944        default WP_TEXT file flag has been cleared.  WP_TEXT may be cleared
 945        by ld --enable-auto-import (if auto-import is actually needed),
 946        by ld --omagic, or by obcopy --writable-text.  */
 947
 948     for (p = known_sections; p->section_name; p++)
 949       if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
 950         {
 951           if (strcmp (scnhdr_int->s_name, ".text")
 952               || (bfd_get_file_flags (abfd) & WP_TEXT))
 953             scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
 954           scnhdr_int->s_flags |= p->must_have;
 955           break;
 956         }
 957
 958     H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
 959   }
 960
 961   if (coff_data (abfd)->link_info
 962       && ! coff_data (abfd)->link_info->relocatable
 963       && ! coff_data (abfd)->link_info->shared
 964       && strcmp (scnhdr_int->s_name, ".text") == 0)
 965     {
 966       /* By inference from looking at MS output, the 32 bit field
 967          which is the combination of the number_of_relocs and
 968          number_of_linenos is used for the line number count in
 969          executables.  A 16-bit field won't do for cc1.  The MS
 970          document says that the number of relocs is zero for
 971          executables, but the 17-th bit has been observed to be there.
 972          Overflow is not an issue: a 4G-line program will overflow a
 973          bunch of other fields long before this!  */
 974       H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
 975       H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
 976     }
 977   else
 978     {
 979       if (scnhdr_int->s_nlnno <= 0xffff)
 980         H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
 981       else
 982         {
 983           (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
 984                                  bfd_get_filename (abfd),
 985                                  scnhdr_int->s_nlnno);
 986           bfd_set_error (bfd_error_file_truncated);
 987           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
 988           ret = 0;
 989         }
 990
 991       /* Although we could encode 0xffff relocs here, we do not, to be
 992          consistent with other parts of bfd. Also it lets us warn, as
 993          we should never see 0xffff here w/o having the overflow flag
 994          set.  */
 995       if (scnhdr_int->s_nreloc < 0xffff)
 996         H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
 997       else
 998         {
 999           /* PE can deal with large #s of relocs, but not here.  */
1000           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1001           scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1002           H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1003         }
1004     }
1005   return ret;
1006 }
1007
1008 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1009 {
1010   N_("Export Directory [.edata (or where ever we found it)]"),
1011   N_("Import Directory [parts of .idata]"),
1012   N_("Resource Directory [.rsrc]"),
1013   N_("Exception Directory [.pdata]"),
1014   N_("Security Directory"),
1015   N_("Base Relocation Directory [.reloc]"),
1016   N_("Debug Directory"),
1017   N_("Description Directory"),
1018   N_("Special Directory"),
1019   N_("Thread Storage Directory [.tls]"),
1020   N_("Load Configuration Directory"),
1021   N_("Bound Import Directory"),
1022   N_("Import Address Table Directory"),
1023   N_("Delay Import Directory"),
1024   N_("CLR Runtime Header"),
1025   N_("Reserved")
1026 };
1027
1028 #ifdef POWERPC_LE_PE
1029 /* The code for the PPC really falls in the "architecture dependent"
1030    category.  However, it's not clear that anyone will ever care, so
1031    we're ignoring the issue for now; if/when PPC matters, some of this
1032    may need to go into peicode.h, or arguments passed to enable the
1033    PPC- specific code.  */
1034 #endif
1035
1036 static bfd_boolean
1037 pe_print_idata (bfd * abfd, void * vfile)
1038 {
1039   FILE *file = (FILE *) vfile;
1040   bfd_byte *data;
1041   asection *section;
1042   bfd_signed_vma adj;
1043
1044 #ifdef POWERPC_LE_PE
1045   asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1046 #endif
1047
1048   bfd_size_type datasize = 0;
1049   bfd_size_type dataoff;
1050   bfd_size_type i;
1051   int onaline = 20;
1052
1053   pe_data_type *pe = pe_data (abfd);
1054   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1055
1056   bfd_vma addr;
1057
1058   addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1059
1060   if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1061     {
1062       /* Maybe the extra header isn't there.  Look for the section.  */
1063       section = bfd_get_section_by_name (abfd, ".idata");
1064       if (section == NULL)
1065         return TRUE;
1066
1067       addr = section->vma;
1068       datasize = section->size;
1069       if (datasize == 0)
1070         return TRUE;
1071     }
1072   else
1073     {
1074       addr += extra->ImageBase;
1075       for (section = abfd->sections; section != NULL; section = section->next)
1076         {
1077           datasize = section->size;
1078           if (addr >= section->vma && addr < section->vma + datasize)
1079             break;
1080         }
1081
1082       if (section == NULL)
1083         {
1084           fprintf (file,
1085                    _("\nThere is an import table, but the section containing it could not be found\n"));
1086           return TRUE;
1087         }
1088     }
1089
1090   fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1091            section->name, (unsigned long) addr);
1092
1093   dataoff = addr - section->vma;
1094   datasize -= dataoff;
1095
1096 #ifdef POWERPC_LE_PE
1097   if (rel_section != 0 && rel_section->size != 0)
1098     {
1099       /* The toc address can be found by taking the starting address,
1100          which on the PPC locates a function descriptor. The
1101          descriptor consists of the function code starting address
1102          followed by the address of the toc. The starting address we
1103          get from the bfd, and the descriptor is supposed to be in the
1104          .reldata section.  */
1105
1106       bfd_vma loadable_toc_address;
1107       bfd_vma toc_address;
1108       bfd_vma start_address;
1109       bfd_byte *data;
1110       bfd_vma offset;
1111
1112       if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1113         {
1114           if (data != NULL)
1115             free (data);
1116           return FALSE;
1117         }
1118
1119       offset = abfd->start_address - rel_section->vma;
1120
1121       if (offset >= rel_section->size || offset + 8 > rel_section->size)
1122         {
1123           if (data != NULL)
1124             free (data);
1125           return FALSE;
1126         }
1127
1128       start_address = bfd_get_32 (abfd, data + offset);
1129       loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1130       toc_address = loadable_toc_address - 32768;
1131
1132       fprintf (file,
1133                _("\nFunction descriptor located at the start address: %04lx\n"),
1134                (unsigned long int) (abfd->start_address));
1135       fprintf (file,
1136                _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1137                start_address, loadable_toc_address, toc_address);
1138       if (data != NULL)
1139         free (data);
1140     }
1141   else
1142     {
1143       fprintf (file,
1144                _("\nNo reldata section! Function descriptor not decoded.\n"));
1145     }
1146 #endif
1147
1148   fprintf (file,
1149            _("\nThe Import Tables (interpreted %s section contents)\n"),
1150            section->name);
1151   fprintf (file,
1152            _("\
1153  vma:            Hint    Time      Forward  DLL       First\n\
1154                  Table   Stamp     Chain    Name      Thunk\n"));
1155
1156   /* Read the whole section.  Some of the fields might be before dataoff.  */
1157   if (!bfd_malloc_and_get_section (abfd, section, &data))
1158     {
1159       if (data != NULL)
1160         free (data);
1161       return FALSE;
1162     }
1163
1164   adj = section->vma - extra->ImageBase;
1165
1166   /* Print all image import descriptors.  */
1167   for (i = 0; i < datasize; i += onaline)
1168     {
1169       bfd_vma hint_addr;
1170       bfd_vma time_stamp;
1171       bfd_vma forward_chain;
1172       bfd_vma dll_name;
1173       bfd_vma first_thunk;
1174       int idx = 0;
1175       bfd_size_type j;
1176       char *dll;
1177
1178       /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress).  */
1179       fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
1180       hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1181       time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1182       forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1183       dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1184       first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1185
1186       fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1187                (unsigned long) hint_addr,
1188                (unsigned long) time_stamp,
1189                (unsigned long) forward_chain,
1190                (unsigned long) dll_name,
1191                (unsigned long) first_thunk);
1192
1193       if (hint_addr == 0 && first_thunk == 0)
1194         break;
1195
1196       if (dll_name - adj >= section->size)
1197         break;
1198
1199       dll = (char *) data + dll_name - adj;
1200       fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1201
1202       if (hint_addr != 0)
1203         {
1204           bfd_byte *ft_data;
1205           asection *ft_section;
1206           bfd_vma ft_addr;
1207           bfd_size_type ft_datasize;
1208           int ft_idx;
1209           int ft_allocated = 0;
1210
1211           fprintf (file, _("\tvma:  Hint/Ord Member-Name Bound-To\n"));
1212
1213           idx = hint_addr - adj;
1214
1215           ft_addr = first_thunk + extra->ImageBase;
1216           ft_data = data;
1217           ft_idx = first_thunk - adj;
1218           ft_allocated = 0;
1219
1220           if (first_thunk != hint_addr)
1221             {
1222               /* Find the section which contains the first thunk.  */
1223               for (ft_section = abfd->sections;
1224                    ft_section != NULL;
1225                    ft_section = ft_section->next)
1226                 {
1227                   ft_datasize = ft_section->size;
1228                   if (ft_addr >= ft_section->vma
1229                       && ft_addr < ft_section->vma + ft_datasize)
1230                     break;
1231                 }
1232
1233               if (ft_section == NULL)
1234                 {
1235                   fprintf (file,
1236                        _("\nThere is a first thunk, but the section containing it could not be found\n"));
1237                   continue;
1238                 }
1239
1240               /* Now check to see if this section is the same as our current
1241                  section.  If it is not then we will have to load its data in.  */
1242               if (ft_section == section)
1243                 {
1244                   ft_data = data;
1245                   ft_idx = first_thunk - adj;
1246                 }
1247               else
1248                 {
1249                   ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1250                   ft_data = bfd_malloc (datasize);
1251                   if (ft_data == NULL)
1252                     continue;
1253
1254                   /* Read datasize bfd_bytes starting at offset ft_idx.  */
1255                   if (! bfd_get_section_contents
1256                       (abfd, ft_section, ft_data, (bfd_vma) ft_idx, datasize))
1257                     {
1258                       free (ft_data);
1259                       continue;
1260                     }
1261
1262                   ft_idx = 0;
1263                   ft_allocated = 1;
1264                 }
1265             }
1266
1267           /* Print HintName vector entries.  */
1268 #ifdef COFF_WITH_pex64
1269           for (j = 0; j < datasize; j += 8)
1270             {
1271               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1272               unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1273
1274               if (!member && !member_high)
1275                 break;
1276
1277               if (member_high & 0x80000000)
1278                 fprintf (file, "\t%lx%08lx\t %4lx%08lx  <none>",
1279                          member_high,member, member_high & 0x7fffffff, member);
1280               else
1281                 {
1282                   int ordinal;
1283                   char *member_name;
1284
1285                   ordinal = bfd_get_16 (abfd, data + member - adj);
1286                   member_name = (char *) data + member - adj + 2;
1287                   fprintf (file, "\t%04lx\t %4d  %s",member, ordinal, member_name);
1288                 }
1289
1290               /* If the time stamp is not zero, the import address
1291                  table holds actual addresses.  */
1292               if (time_stamp != 0
1293                   && first_thunk != 0
1294                   && first_thunk != hint_addr)
1295                 fprintf (file, "\t%04lx",
1296                          (long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1297               fprintf (file, "\n");
1298             }
1299 #else
1300           for (j = 0; j < datasize; j += 4)
1301             {
1302               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1303
1304               /* Print single IMAGE_IMPORT_BY_NAME vector.  */
1305               if (member == 0)
1306                 break;
1307
1308               if (member & 0x80000000)
1309                 fprintf (file, "\t%04lx\t %4lu  <none>",
1310                          member, member & 0x7fffffff);
1311               else
1312                 {
1313                   int ordinal;
1314                   char *member_name;
1315
1316                   ordinal = bfd_get_16 (abfd, data + member - adj);
1317                   member_name = (char *) data + member - adj + 2;
1318                   fprintf (file, "\t%04lx\t %4d  %s",
1319                            member, ordinal, member_name);
1320                 }
1321
1322               /* If the time stamp is not zero, the import address
1323                  table holds actual addresses.  */
1324               if (time_stamp != 0
1325                   && first_thunk != 0
1326                   && first_thunk != hint_addr)
1327                 fprintf (file, "\t%04lx",
1328                          (long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1329
1330               fprintf (file, "\n");
1331             }
1332 #endif
1333           if (ft_allocated)
1334             free (ft_data);
1335         }
1336
1337       fprintf (file, "\n");
1338     }
1339
1340   free (data);
1341
1342   return TRUE;
1343 }
1344
1345 static bfd_boolean
1346 pe_print_edata (bfd * abfd, void * vfile)
1347 {
1348   FILE *file = (FILE *) vfile;
1349   bfd_byte *data;
1350   asection *section;
1351   bfd_size_type datasize = 0;
1352   bfd_size_type dataoff;
1353   bfd_size_type i;
1354   bfd_signed_vma adj;
1355   struct EDT_type
1356   {
1357     long export_flags;          /* Reserved - should be zero.  */
1358     long time_stamp;
1359     short major_ver;
1360     short minor_ver;
1361     bfd_vma name;               /* RVA - relative to image base.  */
1362     long base;                  /* Ordinal base.  */
1363     unsigned long num_functions;/* Number in the export address table.  */
1364     unsigned long num_names;    /* Number in the name pointer table.  */
1365     bfd_vma eat_addr;           /* RVA to the export address table.  */
1366     bfd_vma npt_addr;           /* RVA to the Export Name Pointer Table.  */
1367     bfd_vma ot_addr;            /* RVA to the Ordinal Table.  */
1368   } edt;
1369
1370   pe_data_type *pe = pe_data (abfd);
1371   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1372
1373   bfd_vma addr;
1374
1375   addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1376
1377   if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1378     {
1379       /* Maybe the extra header isn't there.  Look for the section.  */
1380       section = bfd_get_section_by_name (abfd, ".edata");
1381       if (section == NULL)
1382         return TRUE;
1383
1384       addr = section->vma;
1385       dataoff = 0;
1386       datasize = section->size;
1387       if (datasize == 0)
1388         return TRUE;
1389     }
1390   else
1391     {
1392       addr += extra->ImageBase;
1393
1394       for (section = abfd->sections; section != NULL; section = section->next)
1395         if (addr >= section->vma && addr < section->vma + section->size)
1396           break;
1397
1398       if (section == NULL)
1399         {
1400           fprintf (file,
1401                    _("\nThere is an export table, but the section containing it could not be found\n"));
1402           return TRUE;
1403         }
1404
1405       dataoff = addr - section->vma;
1406       datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1407       if (datasize > section->size - dataoff)
1408         {
1409           fprintf (file,
1410                    _("\nThere is an export table in %s, but it does not fit into that section\n"),
1411                    section->name);
1412           return TRUE;
1413         }
1414     }
1415
1416   fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1417            section->name, (unsigned long) addr);
1418
1419   data = bfd_malloc (datasize);
1420   if (data == NULL)
1421     return FALSE;
1422
1423   if (! bfd_get_section_contents (abfd, section, data,
1424                                   (file_ptr) dataoff, datasize))
1425     return FALSE;
1426
1427   /* Go get Export Directory Table.  */
1428   edt.export_flags   = bfd_get_32 (abfd, data +  0);
1429   edt.time_stamp     = bfd_get_32 (abfd, data +  4);
1430   edt.major_ver      = bfd_get_16 (abfd, data +  8);
1431   edt.minor_ver      = bfd_get_16 (abfd, data + 10);
1432   edt.name           = bfd_get_32 (abfd, data + 12);
1433   edt.base           = bfd_get_32 (abfd, data + 16);
1434   edt.num_functions  = bfd_get_32 (abfd, data + 20);
1435   edt.num_names      = bfd_get_32 (abfd, data + 24);
1436   edt.eat_addr       = bfd_get_32 (abfd, data + 28);
1437   edt.npt_addr       = bfd_get_32 (abfd, data + 32);
1438   edt.ot_addr        = bfd_get_32 (abfd, data + 36);
1439
1440   adj = section->vma - extra->ImageBase + dataoff;
1441
1442   /* Dump the EDT first.  */
1443   fprintf (file,
1444            _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1445            section->name);
1446
1447   fprintf (file,
1448            _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1449
1450   fprintf (file,
1451            _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1452
1453   fprintf (file,
1454            _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1455
1456   fprintf (file,
1457            _("Name \t\t\t\t"));
1458   fprintf_vma (file, edt.name);
1459   fprintf (file,
1460            " %s\n", data + edt.name - adj);
1461
1462   fprintf (file,
1463            _("Ordinal Base \t\t\t%ld\n"), edt.base);
1464
1465   fprintf (file,
1466            _("Number in:\n"));
1467
1468   fprintf (file,
1469            _("\tExport Address Table \t\t%08lx\n"),
1470            edt.num_functions);
1471
1472   fprintf (file,
1473            _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1474
1475   fprintf (file,
1476            _("Table Addresses\n"));
1477
1478   fprintf (file,
1479            _("\tExport Address Table \t\t"));
1480   fprintf_vma (file, edt.eat_addr);
1481   fprintf (file, "\n");
1482
1483   fprintf (file,
1484            _("\tName Pointer Table \t\t"));
1485   fprintf_vma (file, edt.npt_addr);
1486   fprintf (file, "\n");
1487
1488   fprintf (file,
1489            _("\tOrdinal Table \t\t\t"));
1490   fprintf_vma (file, edt.ot_addr);
1491   fprintf (file, "\n");
1492
1493   /* The next table to find is the Export Address Table. It's basically
1494      a list of pointers that either locate a function in this dll, or
1495      forward the call to another dll. Something like:
1496       typedef union
1497       {
1498         long export_rva;
1499         long forwarder_rva;
1500       } export_address_table_entry;  */
1501
1502   fprintf (file,
1503           _("\nExport Address Table -- Ordinal Base %ld\n"),
1504           edt.base);
1505
1506   for (i = 0; i < edt.num_functions; ++i)
1507     {
1508       bfd_vma eat_member = bfd_get_32 (abfd,
1509                                        data + edt.eat_addr + (i * 4) - adj);
1510       if (eat_member == 0)
1511         continue;
1512
1513       if (eat_member - adj <= datasize)
1514         {
1515           /* This rva is to a name (forwarding function) in our section.  */
1516           /* Should locate a function descriptor.  */
1517           fprintf (file,
1518                    "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1519                    (long) i,
1520                    (long) (i + edt.base),
1521                    (unsigned long) eat_member,
1522                    _("Forwarder RVA"),
1523                    data + eat_member - adj);
1524         }
1525       else
1526         {
1527           /* Should locate a function descriptor in the reldata section.  */
1528           fprintf (file,
1529                    "\t[%4ld] +base[%4ld] %04lx %s\n",
1530                    (long) i,
1531                    (long) (i + edt.base),
1532                    (unsigned long) eat_member,
1533                    _("Export RVA"));
1534         }
1535     }
1536
1537   /* The Export Name Pointer Table is paired with the Export Ordinal Table.  */
1538   /* Dump them in parallel for clarity.  */
1539   fprintf (file,
1540            _("\n[Ordinal/Name Pointer] Table\n"));
1541
1542   for (i = 0; i < edt.num_names; ++i)
1543     {
1544       bfd_vma name_ptr = bfd_get_32 (abfd,
1545                                     data +
1546                                     edt.npt_addr
1547                                     + (i*4) - adj);
1548
1549       char *name = (char *) data + name_ptr - adj;
1550
1551       bfd_vma ord = bfd_get_16 (abfd,
1552                                     data +
1553                                     edt.ot_addr
1554                                     + (i*2) - adj);
1555       fprintf (file,
1556               "\t[%4ld] %s\n", (long) ord, name);
1557     }
1558
1559   free (data);
1560
1561   return TRUE;
1562 }
1563
1564 /* This really is architecture dependent.  On IA-64, a .pdata entry
1565    consists of three dwords containing relative virtual addresses that
1566    specify the start and end address of the code range the entry
1567    covers and the address of the corresponding unwind info data.  */
1568
1569 static bfd_boolean
1570 pe_print_pdata (bfd * abfd, void * vfile)
1571 {
1572 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1573 # define PDATA_ROW_SIZE (3 * 8)
1574 #else
1575 # define PDATA_ROW_SIZE (5 * 4)
1576 #endif
1577   FILE *file = (FILE *) vfile;
1578   bfd_byte *data = 0;
1579   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1580   bfd_size_type datasize = 0;
1581   bfd_size_type i;
1582   bfd_size_type start, stop;
1583   int onaline = PDATA_ROW_SIZE;
1584
1585   if (section == NULL
1586       || coff_section_data (abfd, section) == NULL
1587       || pei_section_data (abfd, section) == NULL)
1588     return TRUE;
1589
1590   stop = pei_section_data (abfd, section)->virt_size;
1591   if ((stop % onaline) != 0)
1592     fprintf (file,
1593              _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1594              (long) stop, onaline);
1595
1596   fprintf (file,
1597            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1598 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1599   fprintf (file,
1600            _(" vma:\t\t\tBegin Address    End Address      Unwind Info\n"));
1601 #else
1602   fprintf (file, _("\
1603  vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n\
1604      \t\tAddress  Address  Handler  Data     Address    Mask\n"));
1605 #endif
1606
1607   datasize = section->size;
1608   if (datasize == 0)
1609     return TRUE;
1610
1611   if (! bfd_malloc_and_get_section (abfd, section, &data))
1612     {
1613       if (data != NULL)
1614         free (data);
1615       return FALSE;
1616     }
1617
1618   start = 0;
1619
1620   for (i = start; i < stop; i += onaline)
1621     {
1622       bfd_vma begin_addr;
1623       bfd_vma end_addr;
1624       bfd_vma eh_handler;
1625       bfd_vma eh_data;
1626       bfd_vma prolog_end_addr;
1627       int em_data;
1628
1629       if (i + PDATA_ROW_SIZE > stop)
1630         break;
1631
1632       begin_addr      = GET_PDATA_ENTRY (abfd, data + i     );
1633       end_addr        = GET_PDATA_ENTRY (abfd, data + i +  4);
1634       eh_handler      = GET_PDATA_ENTRY (abfd, data + i +  8);
1635       eh_data         = GET_PDATA_ENTRY (abfd, data + i + 12);
1636       prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1637
1638       if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1639           && eh_data == 0 && prolog_end_addr == 0)
1640         /* We are probably into the padding of the section now.  */
1641         break;
1642
1643       em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1644       eh_handler &= ~(bfd_vma) 0x3;
1645       prolog_end_addr &= ~(bfd_vma) 0x3;
1646
1647       fputc (' ', file);
1648       fprintf_vma (file, i + section->vma); fputc ('\t', file);
1649       fprintf_vma (file, begin_addr); fputc (' ', file);
1650       fprintf_vma (file, end_addr); fputc (' ', file);
1651       fprintf_vma (file, eh_handler);
1652 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1653       fputc (' ', file);
1654       fprintf_vma (file, eh_data); fputc (' ', file);
1655       fprintf_vma (file, prolog_end_addr);
1656       fprintf (file, "   %x", em_data);
1657 #endif
1658
1659 #ifdef POWERPC_LE_PE
1660       if (eh_handler == 0 && eh_data != 0)
1661         {
1662           /* Special bits here, although the meaning may be a little
1663              mysterious. The only one I know for sure is 0x03
1664              Code Significance
1665              0x00 None
1666              0x01 Register Save Millicode
1667              0x02 Register Restore Millicode
1668              0x03 Glue Code Sequence.  */
1669           switch (eh_data)
1670             {
1671             case 0x01:
1672               fprintf (file, _(" Register save millicode"));
1673               break;
1674             case 0x02:
1675               fprintf (file, _(" Register restore millicode"));
1676               break;
1677             case 0x03:
1678               fprintf (file, _(" Glue code sequence"));
1679               break;
1680             default:
1681               break;
1682             }
1683         }
1684 #endif
1685       fprintf (file, "\n");
1686     }
1687
1688   free (data);
1689
1690   return TRUE;
1691 }
1692
1693 #define IMAGE_REL_BASED_HIGHADJ 4
1694 static const char * const tbl[] =
1695 {
1696   "ABSOLUTE",
1697   "HIGH",
1698   "LOW",
1699   "HIGHLOW",
1700   "HIGHADJ",
1701   "MIPS_JMPADDR",
1702   "SECTION",
1703   "REL32",
1704   "RESERVED1",
1705   "MIPS_JMPADDR16",
1706   "DIR64",
1707   "HIGH3ADJ",
1708   "UNKNOWN",   /* MUST be last.  */
1709 };
1710
1711 static bfd_boolean
1712 pe_print_reloc (bfd * abfd, void * vfile)
1713 {
1714   FILE *file = (FILE *) vfile;
1715   bfd_byte *data = 0;
1716   asection *section = bfd_get_section_by_name (abfd, ".reloc");
1717   bfd_size_type datasize;
1718   bfd_size_type i;
1719   bfd_size_type start, stop;
1720
1721   if (section == NULL)
1722     return TRUE;
1723
1724   if (section->size == 0)
1725     return TRUE;
1726
1727   fprintf (file,
1728            _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1729
1730   datasize = section->size;
1731   if (! bfd_malloc_and_get_section (abfd, section, &data))
1732     {
1733       if (data != NULL)
1734         free (data);
1735       return FALSE;
1736     }
1737
1738   start = 0;
1739
1740   stop = section->size;
1741
1742   for (i = start; i < stop;)
1743     {
1744       int j;
1745       bfd_vma virtual_address;
1746       long number, size;
1747
1748       /* The .reloc section is a sequence of blocks, with a header consisting
1749          of two 32 bit quantities, followed by a number of 16 bit entries.  */
1750       virtual_address = bfd_get_32 (abfd, data+i);
1751       size = bfd_get_32 (abfd, data+i+4);
1752       number = (size - 8) / 2;
1753
1754       if (size == 0)
1755         break;
1756
1757       fprintf (file,
1758                _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1759                (unsigned long) virtual_address, size, size, number);
1760
1761       for (j = 0; j < number; ++j)
1762         {
1763           unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1764           unsigned int t = (e & 0xF000) >> 12;
1765           int off = e & 0x0FFF;
1766
1767           if (t >= sizeof (tbl) / sizeof (tbl[0]))
1768             t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1769
1770           fprintf (file,
1771                    _("\treloc %4d offset %4x [%4lx] %s"),
1772                    j, off, (long) (off + virtual_address), tbl[t]);
1773
1774           /* HIGHADJ takes an argument, - the next record *is* the
1775              low 16 bits of addend.  */
1776           if (t == IMAGE_REL_BASED_HIGHADJ)
1777             {
1778               fprintf (file, " (%4x)",
1779                        ((unsigned int)
1780                         bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1781               j++;
1782             }
1783
1784           fprintf (file, "\n");
1785         }
1786
1787       i += size;
1788     }
1789
1790   free (data);
1791
1792   return TRUE;
1793 }
1794
1795 /* Print out the program headers.  */
1796
1797 bfd_boolean
1798 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
1799 {
1800   FILE *file = (FILE *) vfile;
1801   int j;
1802   pe_data_type *pe = pe_data (abfd);
1803   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
1804   const char *subsystem_name = NULL;
1805
1806   /* The MS dumpbin program reportedly ands with 0xff0f before
1807      printing the characteristics field.  Not sure why.  No reason to
1808      emulate it here.  */
1809   fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
1810 #undef PF
1811 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
1812   PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
1813   PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
1814   PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
1815   PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
1816   PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
1817   PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
1818   PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
1819   PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
1820   PF (IMAGE_FILE_SYSTEM, "system file");
1821   PF (IMAGE_FILE_DLL, "DLL");
1822   PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
1823 #undef PF
1824
1825   /* ctime implies '\n'.  */
1826   {
1827     time_t t = pe->coff.timestamp;
1828     fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
1829   }
1830   fprintf (file, "\nImageBase\t\t");
1831   fprintf_vma (file, i->ImageBase);
1832   fprintf (file, "\nSectionAlignment\t");
1833   fprintf_vma (file, i->SectionAlignment);
1834   fprintf (file, "\nFileAlignment\t\t");
1835   fprintf_vma (file, i->FileAlignment);
1836   fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1837   fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1838   fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
1839   fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
1840   fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1841   fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1842   fprintf (file, "Win32Version\t\t%08lx\n", i->Reserved1);
1843   fprintf (file, "SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1844   fprintf (file, "SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1845   fprintf (file, "CheckSum\t\t%08lx\n", i->CheckSum);
1846
1847   switch (i->Subsystem)
1848     {
1849     case IMAGE_SUBSYSTEM_UNKNOWN:
1850       subsystem_name = "unspecified";
1851       break;
1852     case IMAGE_SUBSYSTEM_NATIVE:
1853       subsystem_name = "NT native";
1854       break;
1855     case IMAGE_SUBSYSTEM_WINDOWS_GUI:
1856       subsystem_name = "Windows GUI";
1857       break;
1858     case IMAGE_SUBSYSTEM_WINDOWS_CUI:
1859       subsystem_name = "Windows CUI";
1860       break;
1861     case IMAGE_SUBSYSTEM_POSIX_CUI:
1862       subsystem_name = "POSIX CUI";
1863       break;
1864     case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
1865       subsystem_name = "Wince CUI";
1866       break;
1867     case IMAGE_SUBSYSTEM_EFI_APPLICATION:
1868       subsystem_name = "EFI application";
1869       break;
1870     case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
1871       subsystem_name = "EFI boot service driver";
1872       break;
1873     case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
1874       subsystem_name = "EFI runtime driver";
1875       break;
1876     // These are from revision 8.0 of the MS PE/COFF spec
1877     case IMAGE_SUBSYSTEM_EFI_ROM:
1878       subsystem_name = "EFI ROM";
1879       break;
1880     case IMAGE_SUBSYSTEM_XBOX:
1881       subsystem_name = "XBOX";
1882       break;
1883     // Added default case for clarity - subsystem_name is NULL anyway.
1884     default:
1885       subsystem_name = NULL;
1886     }
1887
1888   fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
1889   if (subsystem_name)
1890     fprintf (file, "\t(%s)", subsystem_name);
1891   fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
1892   fprintf (file, "SizeOfStackReserve\t");
1893   fprintf_vma (file, i->SizeOfStackReserve);
1894   fprintf (file, "\nSizeOfStackCommit\t");
1895   fprintf_vma (file, i->SizeOfStackCommit);
1896   fprintf (file, "\nSizeOfHeapReserve\t");
1897   fprintf_vma (file, i->SizeOfHeapReserve);
1898   fprintf (file, "\nSizeOfHeapCommit\t");
1899   fprintf_vma (file, i->SizeOfHeapCommit);
1900   fprintf (file, "\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
1901   fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1902
1903   fprintf (file, "\nThe Data Directory\n");
1904   for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1905     {
1906       fprintf (file, "Entry %1x ", j);
1907       fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1908       fprintf (file, " %08lx ", i->DataDirectory[j].Size);
1909       fprintf (file, "%s\n", dir_names[j]);
1910     }
1911
1912   pe_print_idata (abfd, vfile);
1913   pe_print_edata (abfd, vfile);
1914   pe_print_pdata (abfd, vfile);
1915   pe_print_reloc (abfd, vfile);
1916
1917   return TRUE;
1918 }
1919
1920 /* Copy any private info we understand from the input bfd
1921    to the output bfd.  */
1922
1923 bfd_boolean
1924 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
1925 {
1926   /* One day we may try to grok other private data.  */
1927   if (ibfd->xvec->flavour != bfd_target_coff_flavour
1928       || obfd->xvec->flavour != bfd_target_coff_flavour)
1929     return TRUE;
1930
1931   pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr;
1932   pe_data (obfd)->dll = pe_data (ibfd)->dll;
1933
1934   /* For strip: if we removed .reloc, we'll make a real mess of things
1935      if we don't remove this entry as well.  */
1936   if (! pe_data (obfd)->has_reloc_section)
1937     {
1938       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
1939       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
1940     }
1941   return TRUE;
1942 }
1943
1944 /* Copy private section data.  */
1945
1946 bfd_boolean
1947 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
1948                                        asection *isec,
1949                                        bfd *obfd,
1950                                        asection *osec)
1951 {
1952   if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
1953       || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
1954     return TRUE;
1955
1956   if (coff_section_data (ibfd, isec) != NULL
1957       && pei_section_data (ibfd, isec) != NULL)
1958     {
1959       if (coff_section_data (obfd, osec) == NULL)
1960         {
1961           bfd_size_type amt = sizeof (struct coff_section_tdata);
1962           osec->used_by_bfd = bfd_zalloc (obfd, amt);
1963           if (osec->used_by_bfd == NULL)
1964             return FALSE;
1965         }
1966
1967       if (pei_section_data (obfd, osec) == NULL)
1968         {
1969           bfd_size_type amt = sizeof (struct pei_section_tdata);
1970           coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
1971           if (coff_section_data (obfd, osec)->tdata == NULL)
1972             return FALSE;
1973         }
1974
1975       pei_section_data (obfd, osec)->virt_size =
1976         pei_section_data (ibfd, isec)->virt_size;
1977       pei_section_data (obfd, osec)->pe_flags =
1978         pei_section_data (ibfd, isec)->pe_flags;
1979     }
1980
1981   return TRUE;
1982 }
1983
1984 void
1985 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
1986 {
1987   coff_get_symbol_info (abfd, symbol, ret);
1988 }
1989
1990 /* Handle the .idata section and other things that need symbol table
1991    access.  */
1992
1993 bfd_boolean
1994 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
1995 {
1996   struct coff_link_hash_entry *h1;
1997   struct bfd_link_info *info = pfinfo->info;
1998   bfd_boolean result = TRUE;
1999
2000   /* There are a few fields that need to be filled in now while we
2001      have symbol table access.
2002
2003      The .idata subsections aren't directly available as sections, but
2004      they are in the symbol table, so get them from there.  */
2005
2006   /* The import directory.  This is the address of .idata$2, with size
2007      of .idata$2 + .idata$3.  */
2008   h1 = coff_link_hash_lookup (coff_hash_table (info),
2009                               ".idata$2", FALSE, FALSE, TRUE);
2010   if (h1 != NULL)
2011     {
2012       /* PR ld/2729: We cannot rely upon all the output sections having been
2013          created properly, so check before referencing them.  Issue a warning
2014          message for any sections tht could not be found.  */
2015       if (h1->root.u.def.section != NULL
2016           && h1->root.u.def.section->output_section != NULL)
2017         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
2018           (h1->root.u.def.value
2019            + h1->root.u.def.section->output_section->vma
2020            + h1->root.u.def.section->output_offset);
2021       else
2022         {
2023           _bfd_error_handler
2024             (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
2025              abfd);
2026           result = FALSE;
2027         }
2028
2029       h1 = coff_link_hash_lookup (coff_hash_table (info),
2030                                   ".idata$4", FALSE, FALSE, TRUE);
2031       if (h1 != NULL
2032           && h1->root.u.def.section != NULL
2033           && h1->root.u.def.section->output_section != NULL)
2034         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
2035           ((h1->root.u.def.value
2036             + h1->root.u.def.section->output_section->vma
2037             + h1->root.u.def.section->output_offset)
2038            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
2039       else
2040         {
2041           _bfd_error_handler
2042             (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
2043              abfd);
2044           result = FALSE;
2045         }
2046
2047       /* The import address table.  This is the size/address of
2048          .idata$5.  */
2049       h1 = coff_link_hash_lookup (coff_hash_table (info),
2050                                   ".idata$5", FALSE, FALSE, TRUE);
2051       if (h1 != NULL
2052           && h1->root.u.def.section != NULL
2053           && h1->root.u.def.section->output_section != NULL)
2054         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
2055           (h1->root.u.def.value
2056            + h1->root.u.def.section->output_section->vma
2057            + h1->root.u.def.section->output_offset);
2058       else
2059         {
2060           _bfd_error_handler
2061             (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
2062              abfd);
2063           result = FALSE;
2064         }
2065
2066       h1 = coff_link_hash_lookup (coff_hash_table (info),
2067                                   ".idata$6", FALSE, FALSE, TRUE);
2068       if (h1 != NULL
2069           && h1->root.u.def.section != NULL
2070           && h1->root.u.def.section->output_section != NULL)
2071         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
2072           ((h1->root.u.def.value
2073             + h1->root.u.def.section->output_section->vma
2074             + h1->root.u.def.section->output_offset)
2075            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
2076       else
2077         {
2078           _bfd_error_handler
2079             (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
2080              abfd);
2081           result = FALSE;
2082         }
2083     }
2084
2085   h1 = coff_link_hash_lookup (coff_hash_table (info),
2086                               "__tls_used", FALSE, FALSE, TRUE);
2087   if (h1 != NULL)
2088     {
2089       if (h1->root.u.def.section != NULL
2090           && h1->root.u.def.section->output_section != NULL)
2091         pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
2092           (h1->root.u.def.value
2093            + h1->root.u.def.section->output_section->vma
2094            + h1->root.u.def.section->output_offset
2095            - pe_data (abfd)->pe_opthdr.ImageBase);
2096       else
2097         {
2098           _bfd_error_handler
2099             (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
2100              abfd);
2101           result = FALSE;
2102         }
2103
2104       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
2105     }
2106
2107   /* If we couldn't find idata$2, we either have an excessively
2108      trivial program or are in DEEP trouble; we have to assume trivial
2109      program....  */
2110   return result;
2111 }