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