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