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