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, 2008, 2009  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_pei_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_pei_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                          (unsigned 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                          (unsigned 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    On ARM and SH-4, a compressed PDATA structure is used :
1587    _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1588    _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1589    See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1590
1591    This is the version for uncompressed data.  */
1592
1593 static bfd_boolean
1594 pe_print_pdata (bfd * abfd, void * vfile)
1595 {
1596 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1597 # define PDATA_ROW_SIZE (3 * 8)
1598 #else
1599 # define PDATA_ROW_SIZE (5 * 4)
1600 #endif
1601   FILE *file = (FILE *) vfile;
1602   bfd_byte *data = 0;
1603   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1604   bfd_size_type datasize = 0;
1605   bfd_size_type i;
1606   bfd_size_type start, stop;
1607   int onaline = PDATA_ROW_SIZE;
1608
1609   if (section == NULL
1610       || coff_section_data (abfd, section) == NULL
1611       || pei_section_data (abfd, section) == NULL)
1612     return TRUE;
1613
1614   stop = pei_section_data (abfd, section)->virt_size;
1615   if ((stop % onaline) != 0)
1616     fprintf (file,
1617              _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1618              (long) stop, onaline);
1619
1620   fprintf (file,
1621            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1622 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1623   fprintf (file,
1624            _(" vma:\t\t\tBegin Address    End Address      Unwind Info\n"));
1625 #else
1626   fprintf (file, _("\
1627  vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n\
1628      \t\tAddress  Address  Handler  Data     Address    Mask\n"));
1629 #endif
1630
1631   datasize = section->size;
1632   if (datasize == 0)
1633     return TRUE;
1634
1635   if (! bfd_malloc_and_get_section (abfd, section, &data))
1636     {
1637       if (data != NULL)
1638         free (data);
1639       return FALSE;
1640     }
1641
1642   start = 0;
1643
1644   for (i = start; i < stop; i += onaline)
1645     {
1646       bfd_vma begin_addr;
1647       bfd_vma end_addr;
1648       bfd_vma eh_handler;
1649       bfd_vma eh_data;
1650       bfd_vma prolog_end_addr;
1651       int em_data;
1652
1653       if (i + PDATA_ROW_SIZE > stop)
1654         break;
1655
1656       begin_addr      = GET_PDATA_ENTRY (abfd, data + i     );
1657       end_addr        = GET_PDATA_ENTRY (abfd, data + i +  4);
1658       eh_handler      = GET_PDATA_ENTRY (abfd, data + i +  8);
1659       eh_data         = GET_PDATA_ENTRY (abfd, data + i + 12);
1660       prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1661
1662       if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1663           && eh_data == 0 && prolog_end_addr == 0)
1664         /* We are probably into the padding of the section now.  */
1665         break;
1666
1667       em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1668       eh_handler &= ~(bfd_vma) 0x3;
1669       prolog_end_addr &= ~(bfd_vma) 0x3;
1670
1671       fputc (' ', file);
1672       fprintf_vma (file, i + section->vma); fputc ('\t', file);
1673       fprintf_vma (file, begin_addr); fputc (' ', file);
1674       fprintf_vma (file, end_addr); fputc (' ', file);
1675       fprintf_vma (file, eh_handler);
1676 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1677       fputc (' ', file);
1678       fprintf_vma (file, eh_data); fputc (' ', file);
1679       fprintf_vma (file, prolog_end_addr);
1680       fprintf (file, "   %x", em_data);
1681 #endif
1682
1683 #ifdef POWERPC_LE_PE
1684       if (eh_handler == 0 && eh_data != 0)
1685         {
1686           /* Special bits here, although the meaning may be a little
1687              mysterious. The only one I know for sure is 0x03
1688              Code Significance
1689              0x00 None
1690              0x01 Register Save Millicode
1691              0x02 Register Restore Millicode
1692              0x03 Glue Code Sequence.  */
1693           switch (eh_data)
1694             {
1695             case 0x01:
1696               fprintf (file, _(" Register save millicode"));
1697               break;
1698             case 0x02:
1699               fprintf (file, _(" Register restore millicode"));
1700               break;
1701             case 0x03:
1702               fprintf (file, _(" Glue code sequence"));
1703               break;
1704             default:
1705               break;
1706             }
1707         }
1708 #endif
1709       fprintf (file, "\n");
1710     }
1711
1712   free (data);
1713
1714   return TRUE;
1715 #undef PDATA_ROW_SIZE
1716 }
1717
1718 typedef struct sym_cache
1719 {
1720   int        symcount;
1721   asymbol ** syms;
1722 } sym_cache;
1723
1724 static asymbol **
1725 slurp_symtab (bfd *abfd, sym_cache *psc)
1726 {
1727   asymbol ** sy = NULL;
1728   long storage;
1729
1730   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1731     {
1732       psc->symcount = 0;
1733       return NULL;
1734     }
1735
1736   storage = bfd_get_symtab_upper_bound (abfd);
1737   if (storage < 0)
1738     return NULL;
1739   if (storage)
1740     sy = bfd_malloc (storage);
1741
1742   psc->symcount = bfd_canonicalize_symtab (abfd, sy);
1743   if (psc->symcount < 0)
1744     return NULL;
1745   return sy;
1746 }
1747
1748 static const char *
1749 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
1750 {
1751   int i;
1752
1753   if (psc->syms == 0)
1754     psc->syms = slurp_symtab (abfd, psc);
1755
1756   for (i = 0; i < psc->symcount; i++)
1757     {
1758       if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
1759         return psc->syms[i]->name;
1760     }
1761
1762   return NULL;
1763 }
1764
1765 static void
1766 cleanup_syms (sym_cache *psc)
1767 {
1768   psc->symcount = 0;
1769   free (psc->syms);
1770   psc->syms = NULL;
1771 }
1772
1773 /* This is the version for "compressed" pdata.  */
1774
1775 bfd_boolean
1776 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
1777 {
1778 # define PDATA_ROW_SIZE (2 * 4)
1779   FILE *file = (FILE *) vfile;
1780   bfd_byte *data = NULL;
1781   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1782   bfd_size_type datasize = 0;
1783   bfd_size_type i;
1784   bfd_size_type start, stop;
1785   int onaline = PDATA_ROW_SIZE;
1786   struct sym_cache sym_cache = {0, 0} ;
1787
1788   if (section == NULL
1789       || coff_section_data (abfd, section) == NULL
1790       || pei_section_data (abfd, section) == NULL)
1791     return TRUE;
1792
1793   stop = pei_section_data (abfd, section)->virt_size;
1794   if ((stop % onaline) != 0)
1795     fprintf (file,
1796              _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1797              (long) stop, onaline);
1798
1799   fprintf (file,
1800            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1801
1802   fprintf (file, _("\
1803  vma:\t\tBegin    Prolog   Function Flags    Exception EH\n\
1804      \t\tAddress  Length   Length   32b exc  Handler   Data\n"));
1805
1806   datasize = section->size;
1807   if (datasize == 0)
1808     return TRUE;
1809
1810   if (! bfd_malloc_and_get_section (abfd, section, &data))
1811     {
1812       if (data != NULL)
1813         free (data);
1814       return FALSE;
1815     }
1816
1817   start = 0;
1818
1819   for (i = start; i < stop; i += onaline)
1820     {
1821       bfd_vma begin_addr;
1822       bfd_vma other_data;
1823       bfd_vma prolog_length, function_length;
1824       int flag32bit, exception_flag;
1825       bfd_byte *tdata = 0;
1826       asection *tsection;
1827
1828       if (i + PDATA_ROW_SIZE > stop)
1829         break;
1830
1831       begin_addr = GET_PDATA_ENTRY (abfd, data + i     );
1832       other_data = GET_PDATA_ENTRY (abfd, data + i +  4);
1833
1834       if (begin_addr == 0 && other_data == 0)
1835         /* We are probably into the padding of the section now.  */
1836         break;
1837
1838       prolog_length = (other_data & 0x000000FF);
1839       function_length = (other_data & 0x3FFFFF00) >> 8;
1840       flag32bit = (int)((other_data & 0x40000000) >> 30);
1841       exception_flag = (int)((other_data & 0x80000000) >> 31);
1842
1843       fputc (' ', file);
1844       fprintf_vma (file, i + section->vma); fputc ('\t', file);
1845       fprintf_vma (file, begin_addr); fputc (' ', file);
1846       fprintf_vma (file, prolog_length); fputc (' ', file);
1847       fprintf_vma (file, function_length); fputc (' ', file);
1848       fprintf (file, "%2d  %2d   ", flag32bit, exception_flag);
1849
1850       /* Get the exception handler's address and the data passed from the
1851          .text section. This is really the data that belongs with the .pdata
1852          but got "compressed" out for the ARM and SH4 architectures.  */
1853       tsection = bfd_get_section_by_name (abfd, ".text");
1854       if (tsection && coff_section_data (abfd, tsection)
1855           && pei_section_data (abfd, tsection))
1856         {
1857           if (bfd_malloc_and_get_section (abfd, tsection, & tdata))
1858             {
1859               int xx = (begin_addr - 8) - tsection->vma;
1860
1861               tdata = bfd_malloc (8);
1862               if (bfd_get_section_contents (abfd, tsection, tdata, (bfd_vma) xx, 8))
1863                 {
1864                   bfd_vma eh, eh_data;
1865
1866                   eh = bfd_get_32 (abfd, tdata);
1867                   eh_data = bfd_get_32 (abfd, tdata + 4);
1868                   fprintf (file, "%08x  ", (unsigned int) eh);
1869                   fprintf (file, "%08x", (unsigned int) eh_data);
1870                   if (eh != 0)
1871                     {
1872                       const char *s = my_symbol_for_address (abfd, eh, &sym_cache);
1873
1874                       if (s)
1875                         fprintf (file, " (%s) ", s);
1876                     }
1877                 }
1878               free (tdata);
1879             }
1880           else
1881             {
1882               if (tdata)
1883                 free (tdata);
1884             }
1885         }
1886
1887       fprintf (file, "\n");
1888     }
1889
1890   free (data);
1891
1892   cleanup_syms (& sym_cache);
1893
1894   return TRUE;
1895 #undef PDATA_ROW_SIZE
1896 }
1897
1898 #ifdef COFF_WITH_pex64
1899 /* The PE+ x64 variant.  */
1900 bfd_boolean
1901 _bfd_pex64_print_pdata (bfd *abfd, void *vfile)
1902 {
1903 # define PDATA_ROW_SIZE (3 * 4)
1904   FILE *file = (FILE *) vfile;
1905   bfd_byte *data = NULL;
1906   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1907   bfd_size_type datasize = 0;
1908   bfd_size_type i;
1909   bfd_size_type start, stop;
1910   int onaline = PDATA_ROW_SIZE;
1911   struct sym_cache sym_cache = {0, 0};
1912
1913   if (section == NULL
1914       || coff_section_data (abfd, section) == NULL
1915       || pei_section_data (abfd, section) == NULL)
1916     return TRUE;
1917
1918   stop = pei_section_data (abfd, section)->virt_size;
1919   if ((stop % onaline) != 0)
1920     fprintf (file,
1921              _("warning: .pdata section size (%ld) is not a multiple of %d\n"),
1922              (long) stop, onaline);
1923
1924   fprintf (file,
1925            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1926
1927   fprintf (file, _("vma:\t\t\tBeginAddress\t EndAddress\t  UnwindData\n"));
1928
1929   datasize = section->size;
1930   if (datasize == 0)
1931     return TRUE;
1932
1933   if (!bfd_malloc_and_get_section (abfd, section, &data))
1934     {
1935       if (data != NULL)
1936         free (data);
1937       return FALSE;
1938     }
1939
1940   start = 0;
1941
1942   for (i = start; i < stop; i += onaline)
1943     {
1944       bfd_vma begin_addr;
1945       bfd_vma end_addr;
1946       bfd_vma unwind_data_addr;
1947
1948       if (i + PDATA_ROW_SIZE > stop)
1949         break;
1950
1951       begin_addr = bfd_get_32 (abfd, data + i);
1952       end_addr = bfd_get_32 (abfd, data + i + 4);
1953       unwind_data_addr = bfd_get_32 (abfd, data + i +  8);
1954
1955       if (begin_addr == 0 && end_addr == 0 && unwind_data_addr == 0)
1956         /* We are probably into the padding of the section now.  */
1957         break;
1958
1959       fputc (' ', file);
1960       fprintf_vma (file, i + section->vma);
1961       fprintf (file, ":\t");
1962       fprintf_vma (file, begin_addr);
1963       fputc (' ', file);
1964       fprintf_vma (file, end_addr);
1965       fputc (' ', file);
1966       fprintf_vma (file, unwind_data_addr);
1967
1968       fprintf (file, "\n");
1969     }
1970
1971   free (data);
1972
1973   cleanup_syms (&sym_cache);
1974
1975   return TRUE;
1976 #undef PDATA_ROW_SIZE
1977 }
1978 #endif
1979 \f
1980 #define IMAGE_REL_BASED_HIGHADJ 4
1981 static const char * const tbl[] =
1982 {
1983   "ABSOLUTE",
1984   "HIGH",
1985   "LOW",
1986   "HIGHLOW",
1987   "HIGHADJ",
1988   "MIPS_JMPADDR",
1989   "SECTION",
1990   "REL32",
1991   "RESERVED1",
1992   "MIPS_JMPADDR16",
1993   "DIR64",
1994   "HIGH3ADJ",
1995   "UNKNOWN",   /* MUST be last.  */
1996 };
1997
1998 static bfd_boolean
1999 pe_print_reloc (bfd * abfd, void * vfile)
2000 {
2001   FILE *file = (FILE *) vfile;
2002   bfd_byte *data = 0;
2003   asection *section = bfd_get_section_by_name (abfd, ".reloc");
2004   bfd_size_type datasize;
2005   bfd_size_type i;
2006   bfd_size_type start, stop;
2007
2008   if (section == NULL)
2009     return TRUE;
2010
2011   if (section->size == 0)
2012     return TRUE;
2013
2014   fprintf (file,
2015            _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2016
2017   datasize = section->size;
2018   if (! bfd_malloc_and_get_section (abfd, section, &data))
2019     {
2020       if (data != NULL)
2021         free (data);
2022       return FALSE;
2023     }
2024
2025   start = 0;
2026
2027   stop = section->size;
2028
2029   for (i = start; i < stop;)
2030     {
2031       int j;
2032       bfd_vma virtual_address;
2033       long number, size;
2034
2035       /* The .reloc section is a sequence of blocks, with a header consisting
2036          of two 32 bit quantities, followed by a number of 16 bit entries.  */
2037       virtual_address = bfd_get_32 (abfd, data+i);
2038       size = bfd_get_32 (abfd, data+i+4);
2039       number = (size - 8) / 2;
2040
2041       if (size == 0)
2042         break;
2043
2044       fprintf (file,
2045                _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2046                (unsigned long) virtual_address, size, (unsigned long) size, number);
2047
2048       for (j = 0; j < number; ++j)
2049         {
2050           unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
2051           unsigned int t = (e & 0xF000) >> 12;
2052           int off = e & 0x0FFF;
2053
2054           if (t >= sizeof (tbl) / sizeof (tbl[0]))
2055             t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
2056
2057           fprintf (file,
2058                    _("\treloc %4d offset %4x [%4lx] %s"),
2059                    j, off, (unsigned long) (off + virtual_address), tbl[t]);
2060
2061           /* HIGHADJ takes an argument, - the next record *is* the
2062              low 16 bits of addend.  */
2063           if (t == IMAGE_REL_BASED_HIGHADJ)
2064             {
2065               fprintf (file, " (%4x)",
2066                        ((unsigned int)
2067                         bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
2068               j++;
2069             }
2070
2071           fprintf (file, "\n");
2072         }
2073
2074       i += size;
2075     }
2076
2077   free (data);
2078
2079   return TRUE;
2080 }
2081
2082 /* Print out the program headers.  */
2083
2084 bfd_boolean
2085 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2086 {
2087   FILE *file = (FILE *) vfile;
2088   int j;
2089   pe_data_type *pe = pe_data (abfd);
2090   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2091   const char *subsystem_name = NULL;
2092   const char *name;
2093
2094   /* The MS dumpbin program reportedly ands with 0xff0f before
2095      printing the characteristics field.  Not sure why.  No reason to
2096      emulate it here.  */
2097   fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2098 #undef PF
2099 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2100   PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2101   PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2102   PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2103   PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2104   PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2105   PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2106   PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2107   PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2108   PF (IMAGE_FILE_SYSTEM, "system file");
2109   PF (IMAGE_FILE_DLL, "DLL");
2110   PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2111 #undef PF
2112
2113   /* ctime implies '\n'.  */
2114   {
2115     time_t t = pe->coff.timestamp;
2116     fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2117   }
2118
2119 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2120 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2121 #endif
2122 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2123 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2124 #endif
2125 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2126 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2127 #endif
2128
2129   switch (i->Magic)
2130     {
2131     case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2132       name = "PE32";
2133       break;
2134     case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2135       name = "PE32+";
2136       break;
2137     case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2138       name = "ROM";
2139       break;
2140     default:
2141       name = NULL;
2142       break;
2143     }
2144   fprintf (file, "Magic\t\t\t%04x", i->Magic);
2145   if (name)
2146     fprintf (file, "\t(%s)",name);
2147   fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2148   fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2149   fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2150   fprintf (file, "SizeOfInitializedData\t%08lx\n",
2151            (unsigned long) i->SizeOfInitializedData);
2152   fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2153            (unsigned long) i->SizeOfUninitializedData);
2154   fprintf (file, "AddressOfEntryPoint\t");
2155   fprintf_vma (file, i->AddressOfEntryPoint);
2156   fprintf (file, "\nBaseOfCode\t\t");
2157   fprintf_vma (file, i->BaseOfCode);
2158 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2159   /* PE32+ does not have BaseOfData member!  */
2160   fprintf (file, "\nBaseOfData\t\t");
2161   fprintf_vma (file, i->BaseOfData);
2162 #endif
2163
2164   fprintf (file, "\nImageBase\t\t");
2165   fprintf_vma (file, i->ImageBase);
2166   fprintf (file, "\nSectionAlignment\t");
2167   fprintf_vma (file, i->SectionAlignment);
2168   fprintf (file, "\nFileAlignment\t\t");
2169   fprintf_vma (file, i->FileAlignment);
2170   fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2171   fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2172   fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2173   fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2174   fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2175   fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2176   fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2177   fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2178   fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2179   fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2180
2181   switch (i->Subsystem)
2182     {
2183     case IMAGE_SUBSYSTEM_UNKNOWN:
2184       subsystem_name = "unspecified";
2185       break;
2186     case IMAGE_SUBSYSTEM_NATIVE:
2187       subsystem_name = "NT native";
2188       break;
2189     case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2190       subsystem_name = "Windows GUI";
2191       break;
2192     case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2193       subsystem_name = "Windows CUI";
2194       break;
2195     case IMAGE_SUBSYSTEM_POSIX_CUI:
2196       subsystem_name = "POSIX CUI";
2197       break;
2198     case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2199       subsystem_name = "Wince CUI";
2200       break;
2201     // These are from UEFI Platform Initialization Specification 1.1.
2202     case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2203       subsystem_name = "EFI application";
2204       break;
2205     case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2206       subsystem_name = "EFI boot service driver";
2207       break;
2208     case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2209       subsystem_name = "EFI runtime driver";
2210       break;
2211     case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2212       subsystem_name = "SAL runtime driver";
2213       break;
2214     // This is from revision 8.0 of the MS PE/COFF spec
2215     case IMAGE_SUBSYSTEM_XBOX:
2216       subsystem_name = "XBOX";
2217       break;
2218     // Added default case for clarity - subsystem_name is NULL anyway.
2219     default:
2220       subsystem_name = NULL;
2221     }
2222
2223   fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2224   if (subsystem_name)
2225     fprintf (file, "\t(%s)", subsystem_name);
2226   fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2227   fprintf (file, "SizeOfStackReserve\t");
2228   fprintf_vma (file, i->SizeOfStackReserve);
2229   fprintf (file, "\nSizeOfStackCommit\t");
2230   fprintf_vma (file, i->SizeOfStackCommit);
2231   fprintf (file, "\nSizeOfHeapReserve\t");
2232   fprintf_vma (file, i->SizeOfHeapReserve);
2233   fprintf (file, "\nSizeOfHeapCommit\t");
2234   fprintf_vma (file, i->SizeOfHeapCommit);
2235   fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2236   fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2237            (unsigned long) i->NumberOfRvaAndSizes);
2238
2239   fprintf (file, "\nThe Data Directory\n");
2240   for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2241     {
2242       fprintf (file, "Entry %1x ", j);
2243       fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
2244       fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2245       fprintf (file, "%s\n", dir_names[j]);
2246     }
2247
2248   pe_print_idata (abfd, vfile);
2249   pe_print_edata (abfd, vfile);
2250   if (bfd_coff_have_print_pdata (abfd))
2251     bfd_coff_print_pdata (abfd, vfile);
2252   else
2253     pe_print_pdata (abfd, vfile);
2254   pe_print_reloc (abfd, vfile);
2255
2256   return TRUE;
2257 }
2258
2259 /* Copy any private info we understand from the input bfd
2260    to the output bfd.  */
2261
2262 bfd_boolean
2263 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2264 {
2265   pe_data_type *ipe, *ope;
2266
2267   /* One day we may try to grok other private data.  */
2268   if (ibfd->xvec->flavour != bfd_target_coff_flavour
2269       || obfd->xvec->flavour != bfd_target_coff_flavour)
2270     return TRUE;
2271
2272   ipe = pe_data (ibfd);
2273   ope = pe_data (obfd);
2274
2275   ope->pe_opthdr = ipe->pe_opthdr;
2276   ope->dll = ipe->dll;
2277
2278   /* Don't copy input subsystem if output is different from input.  */
2279   if (obfd->xvec != ibfd->xvec)
2280     ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2281
2282   /* For strip: if we removed .reloc, we'll make a real mess of things
2283      if we don't remove this entry as well.  */
2284   if (! pe_data (obfd)->has_reloc_section)
2285     {
2286       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2287       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2288     }
2289   return TRUE;
2290 }
2291
2292 /* Copy private section data.  */
2293
2294 bfd_boolean
2295 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2296                                        asection *isec,
2297                                        bfd *obfd,
2298                                        asection *osec)
2299 {
2300   if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2301       || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
2302     return TRUE;
2303
2304   if (coff_section_data (ibfd, isec) != NULL
2305       && pei_section_data (ibfd, isec) != NULL)
2306     {
2307       if (coff_section_data (obfd, osec) == NULL)
2308         {
2309           bfd_size_type amt = sizeof (struct coff_section_tdata);
2310           osec->used_by_bfd = bfd_zalloc (obfd, amt);
2311           if (osec->used_by_bfd == NULL)
2312             return FALSE;
2313         }
2314
2315       if (pei_section_data (obfd, osec) == NULL)
2316         {
2317           bfd_size_type amt = sizeof (struct pei_section_tdata);
2318           coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
2319           if (coff_section_data (obfd, osec)->tdata == NULL)
2320             return FALSE;
2321         }
2322
2323       pei_section_data (obfd, osec)->virt_size =
2324         pei_section_data (ibfd, isec)->virt_size;
2325       pei_section_data (obfd, osec)->pe_flags =
2326         pei_section_data (ibfd, isec)->pe_flags;
2327     }
2328
2329   return TRUE;
2330 }
2331
2332 void
2333 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
2334 {
2335   coff_get_symbol_info (abfd, symbol, ret);
2336 }
2337
2338 /* Handle the .idata section and other things that need symbol table
2339    access.  */
2340
2341 bfd_boolean
2342 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
2343 {
2344   struct coff_link_hash_entry *h1;
2345   struct bfd_link_info *info = pfinfo->info;
2346   bfd_boolean result = TRUE;
2347
2348   /* There are a few fields that need to be filled in now while we
2349      have symbol table access.
2350
2351      The .idata subsections aren't directly available as sections, but
2352      they are in the symbol table, so get them from there.  */
2353
2354   /* The import directory.  This is the address of .idata$2, with size
2355      of .idata$2 + .idata$3.  */
2356   h1 = coff_link_hash_lookup (coff_hash_table (info),
2357                               ".idata$2", FALSE, FALSE, TRUE);
2358   if (h1 != NULL)
2359     {
2360       /* PR ld/2729: We cannot rely upon all the output sections having been
2361          created properly, so check before referencing them.  Issue a warning
2362          message for any sections tht could not be found.  */
2363       if ((h1->root.type == bfd_link_hash_defined
2364            || h1->root.type == bfd_link_hash_defweak)
2365           && h1->root.u.def.section != NULL
2366           && h1->root.u.def.section->output_section != NULL)
2367         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
2368           (h1->root.u.def.value
2369            + h1->root.u.def.section->output_section->vma
2370            + h1->root.u.def.section->output_offset);
2371       else
2372         {
2373           _bfd_error_handler
2374             (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
2375              abfd);
2376           result = FALSE;
2377         }
2378
2379       h1 = coff_link_hash_lookup (coff_hash_table (info),
2380                                   ".idata$4", FALSE, FALSE, TRUE);
2381       if (h1 != NULL
2382           && (h1->root.type == bfd_link_hash_defined
2383            || h1->root.type == bfd_link_hash_defweak)
2384           && h1->root.u.def.section != NULL
2385           && h1->root.u.def.section->output_section != NULL)
2386         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
2387           ((h1->root.u.def.value
2388             + h1->root.u.def.section->output_section->vma
2389             + h1->root.u.def.section->output_offset)
2390            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
2391       else
2392         {
2393           _bfd_error_handler
2394             (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
2395              abfd);
2396           result = FALSE;
2397         }
2398
2399       /* The import address table.  This is the size/address of
2400          .idata$5.  */
2401       h1 = coff_link_hash_lookup (coff_hash_table (info),
2402                                   ".idata$5", FALSE, FALSE, TRUE);
2403       if (h1 != NULL
2404           && (h1->root.type == bfd_link_hash_defined
2405            || h1->root.type == bfd_link_hash_defweak)
2406           && h1->root.u.def.section != NULL
2407           && h1->root.u.def.section->output_section != NULL)
2408         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
2409           (h1->root.u.def.value
2410            + h1->root.u.def.section->output_section->vma
2411            + h1->root.u.def.section->output_offset);
2412       else
2413         {
2414           _bfd_error_handler
2415             (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
2416              abfd);
2417           result = FALSE;
2418         }
2419
2420       h1 = coff_link_hash_lookup (coff_hash_table (info),
2421                                   ".idata$6", FALSE, FALSE, TRUE);
2422       if (h1 != NULL
2423           && (h1->root.type == bfd_link_hash_defined
2424            || h1->root.type == bfd_link_hash_defweak)
2425           && h1->root.u.def.section != NULL
2426           && h1->root.u.def.section->output_section != NULL)
2427         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
2428           ((h1->root.u.def.value
2429             + h1->root.u.def.section->output_section->vma
2430             + h1->root.u.def.section->output_offset)
2431            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
2432       else
2433         {
2434           _bfd_error_handler
2435             (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
2436              abfd);
2437           result = FALSE;
2438         }
2439     }
2440
2441   h1 = coff_link_hash_lookup (coff_hash_table (info),
2442                               "__tls_used", FALSE, FALSE, TRUE);
2443   if (h1 != NULL)
2444     {
2445       if ((h1->root.type == bfd_link_hash_defined
2446            || h1->root.type == bfd_link_hash_defweak)
2447           && h1->root.u.def.section != NULL
2448           && h1->root.u.def.section->output_section != NULL)
2449         pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
2450           (h1->root.u.def.value
2451            + h1->root.u.def.section->output_section->vma
2452            + h1->root.u.def.section->output_offset
2453            - pe_data (abfd)->pe_opthdr.ImageBase);
2454       else
2455         {
2456           _bfd_error_handler
2457             (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
2458              abfd);
2459           result = FALSE;
2460         }
2461
2462       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
2463     }
2464
2465   /* If we couldn't find idata$2, we either have an excessively
2466      trivial program or are in DEEP trouble; we have to assume trivial
2467      program....  */
2468   return result;
2469 }