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
   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     for (p = known_sections; p->section_name; p++)
 989       if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
 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           flags &= ~IMAGE_SCN_MEM_WRITE;
 995           flags |= p->must_have;
 996           break;
 997         }
 998
 999     H_PUT_32 (abfd, flags, scnhdr_ext->s_flags);
1000   }
1001
1002   if (coff_data (abfd)->link_info
1003       && ! coff_data (abfd)->link_info->relocatable
1004       && ! coff_data (abfd)->link_info->shared
1005       && strcmp (scnhdr_int->s_name, ".text") == 0)
1006     {
1007       /* By inference from looking at MS output, the 32 bit field
1008          which is the combination of the number_of_relocs and
1009          number_of_linenos is used for the line number count in
1010          executables.  A 16-bit field won't do for cc1.  The MS
1011          document says that the number of relocs is zero for
1012          executables, but the 17-th bit has been observed to be there.
1013          Overflow is not an issue: a 4G-line program will overflow a
1014          bunch of other fields long before this!  */
1015       H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
1016       H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
1017     }
1018   else
1019     {
1020       if (scnhdr_int->s_nlnno <= 0xffff)
1021         H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
1022       else
1023         {
1024           (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
1025                                  bfd_get_filename (abfd),
1026                                  scnhdr_int->s_nlnno);
1027           bfd_set_error (bfd_error_file_truncated);
1028           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1029           ret = 0;
1030         }
1031
1032       /* Although we could encode 0xffff relocs here, we do not, to be
1033          consistent with other parts of bfd. Also it lets us warn, as
1034          we should never see 0xffff here w/o having the overflow flag
1035          set.  */
1036       if (scnhdr_int->s_nreloc < 0xffff)
1037         H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1038       else
1039         {
1040           /* PE can deal with large #s of relocs, but not here.  */
1041           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1042           scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1043           H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1044 #if 0
1045           (*_bfd_error_handler) (_("%s: reloc overflow 1: 0x%lx > 0xffff"),
1046                                  bfd_get_filename (abfd),
1047                                  scnhdr_int->s_nreloc);
1048           bfd_set_error (bfd_error_file_truncated);
1049           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1050           ret = 0;
1051 #endif
1052         }
1053     }
1054   return ret;
1055 }
1056
1057 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1058   {
1059     N_("Export Directory [.edata (or where ever we found it)]"),
1060     N_("Import Directory [parts of .idata]"),
1061     N_("Resource Directory [.rsrc]"),
1062     N_("Exception Directory [.pdata]"),
1063     N_("Security Directory"),
1064     N_("Base Relocation Directory [.reloc]"),
1065     N_("Debug Directory"),
1066     N_("Description Directory"),
1067     N_("Special Directory"),
1068     N_("Thread Storage Directory [.tls]"),
1069     N_("Load Configuration Directory"),
1070     N_("Bound Import Directory"),
1071     N_("Import Address Table Directory"),
1072     N_("Delay Import Directory"),
1073     N_("Reserved"),
1074     N_("Reserved")
1075   };
1076
1077 #ifdef POWERPC_LE_PE
1078 /* The code for the PPC really falls in the "architecture dependent"
1079    category.  However, it's not clear that anyone will ever care, so
1080    we're ignoring the issue for now; if/when PPC matters, some of this
1081    may need to go into peicode.h, or arguments passed to enable the
1082    PPC- specific code.  */
1083 #endif
1084
1085 static bfd_boolean
1086 pe_print_idata (abfd, vfile)
1087      bfd *abfd;
1088      PTR vfile;
1089 {
1090   FILE *file = (FILE *) vfile;
1091   bfd_byte *data;
1092   asection *section;
1093   bfd_signed_vma adj;
1094
1095 #ifdef POWERPC_LE_PE
1096   asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1097 #endif
1098
1099   bfd_size_type datasize = 0;
1100   bfd_size_type dataoff;
1101   bfd_size_type i;
1102   bfd_size_type amt;
1103   int onaline = 20;
1104
1105   pe_data_type *pe = pe_data (abfd);
1106   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1107
1108   bfd_vma addr;
1109
1110   addr = extra->DataDirectory[1].VirtualAddress;
1111
1112   if (addr == 0 && extra->DataDirectory[1].Size == 0)
1113     {
1114       /* Maybe the extra header isn't there.  Look for the section.  */
1115       section = bfd_get_section_by_name (abfd, ".idata");
1116       if (section == NULL)
1117         return TRUE;
1118
1119       addr = section->vma;
1120       datasize = bfd_section_size (abfd, section);
1121       if (datasize == 0)
1122         return TRUE;
1123     }
1124   else
1125     {
1126       addr += extra->ImageBase;
1127       for (section = abfd->sections; section != NULL; section = section->next)
1128         {
1129           datasize = bfd_section_size (abfd, section);
1130           if (addr >= section->vma && addr < section->vma + datasize)
1131             break;
1132         }
1133
1134       if (section == NULL)
1135         {
1136           fprintf (file,
1137                    _("\nThere is an import table, but the section containing it could not be found\n"));
1138           return TRUE;
1139         }
1140     }
1141
1142   fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1143            section->name, (unsigned long) addr);
1144
1145   dataoff = addr - section->vma;
1146   datasize -= dataoff;
1147
1148 #ifdef POWERPC_LE_PE
1149   if (rel_section != 0 && bfd_section_size (abfd, rel_section) != 0)
1150     {
1151       /* The toc address can be found by taking the starting address,
1152          which on the PPC locates a function descriptor. The
1153          descriptor consists of the function code starting address
1154          followed by the address of the toc. The starting address we
1155          get from the bfd, and the descriptor is supposed to be in the
1156          .reldata section.  */
1157
1158       bfd_vma loadable_toc_address;
1159       bfd_vma toc_address;
1160       bfd_vma start_address;
1161       bfd_byte *data = 0;
1162       int offset;
1163
1164       amt = bfd_section_size (abfd, rel_section);
1165       data = (bfd_byte *) bfd_malloc (amt);
1166       if (data == NULL && amt != 0)
1167         return FALSE;
1168
1169       bfd_get_section_contents (abfd, rel_section, (PTR) data, (bfd_vma) 0,
1170                                 amt);
1171
1172       offset = abfd->start_address - rel_section->vma;
1173
1174       start_address = bfd_get_32 (abfd, data + offset);
1175       loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1176       toc_address = loadable_toc_address - 32768;
1177
1178       fprintf (file,
1179                _("\nFunction descriptor located at the start address: %04lx\n"),
1180                (unsigned long int) (abfd->start_address));
1181       fprintf (file,
1182                _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1183                start_address, loadable_toc_address, toc_address);
1184     }
1185   else
1186     {
1187       fprintf (file,
1188                _("\nNo reldata section! Function descriptor not decoded.\n"));
1189     }
1190 #endif
1191
1192   fprintf (file,
1193            _("\nThe Import Tables (interpreted %s section contents)\n"),
1194            section->name);
1195   fprintf (file,
1196            _("\
1197  vma:            Hint    Time      Forward  DLL       First\n\
1198                  Table   Stamp     Chain    Name      Thunk\n"));
1199
1200   amt = dataoff + datasize;
1201   data = (bfd_byte *) bfd_malloc (amt);
1202   if (data == NULL)
1203     return FALSE;
1204
1205   /* Read the whole section.  Some of the fields might be before dataoff.  */
1206   if (! bfd_get_section_contents (abfd, section, (PTR) data, (bfd_vma) 0, amt))
1207     return FALSE;
1208
1209   adj = section->vma - extra->ImageBase;
1210
1211   /* Print all image import descriptors.  */
1212   for (i = 0; i < datasize; i += onaline)
1213     {
1214       bfd_vma hint_addr;
1215       bfd_vma time_stamp;
1216       bfd_vma forward_chain;
1217       bfd_vma dll_name;
1218       bfd_vma first_thunk;
1219       int idx = 0;
1220       bfd_size_type j;
1221       char *dll;
1222
1223       /* Print (i + extra->DataDirectory[1].VirtualAddress).  */
1224       fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
1225 #if 0
1226       if (i + 20 > datasize)
1227         /* Check stuff.  */
1228         ;
1229 #endif
1230       hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1231       time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1232       forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1233       dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1234       first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1235
1236       fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1237                (unsigned long) hint_addr,
1238                (unsigned long) time_stamp,
1239                (unsigned long) forward_chain,
1240                (unsigned long) dll_name,
1241                (unsigned long) first_thunk);
1242
1243       if (hint_addr == 0 && first_thunk == 0)
1244         break;
1245
1246       dll = (char *) data + dll_name - adj;
1247       fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1248
1249       if (hint_addr != 0)
1250         {
1251           bfd_byte *ft_data;
1252           asection *ft_section;
1253           bfd_vma ft_addr;
1254           bfd_size_type ft_datasize;
1255           int ft_idx;
1256           int ft_allocated = 0;
1257
1258           fprintf (file, _("\tvma:  Hint/Ord Member-Name Bound-To\n"));
1259
1260           idx = hint_addr - adj;
1261
1262           ft_addr = first_thunk + extra->ImageBase;
1263           ft_data = data;
1264           ft_idx = first_thunk - adj;
1265           ft_allocated = 0;
1266
1267           if (first_thunk != hint_addr)
1268             {
1269               /* Find the section which contains the first thunk.  */
1270               for (ft_section = abfd->sections;
1271                    ft_section != NULL;
1272                    ft_section = ft_section->next)
1273                 {
1274                   ft_datasize = bfd_section_size (abfd, ft_section);
1275                   if (ft_addr >= ft_section->vma
1276                       && ft_addr < ft_section->vma + ft_datasize)
1277                     break;
1278                 }
1279
1280               if (ft_section == NULL)
1281                 {
1282                   fprintf (file,
1283                        _("\nThere is a first thunk, but the section containing it could not be found\n"));
1284                   continue;
1285                 }
1286
1287               /* Now check to see if this section is the same as our current
1288                  section.  If it is not then we will have to load its data in.  */
1289               if (ft_section == section)
1290                 {
1291                   ft_data = data;
1292                   ft_idx = first_thunk - adj;
1293                 }
1294               else
1295                 {
1296                   ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1297                   ft_data = (bfd_byte *) bfd_malloc (datasize);
1298                   if (ft_data == NULL)
1299                     continue;
1300
1301                   /* Read datasize bfd_bytes starting at offset ft_idx.  */
1302                   if (! bfd_get_section_contents (abfd, ft_section,
1303                                                   (PTR) ft_data,
1304                                                   (bfd_vma) ft_idx,
1305                                                   datasize))
1306                     {
1307                       free (ft_data);
1308                       continue;
1309                     }
1310
1311                   ft_idx = 0;
1312                   ft_allocated = 1;
1313                 }
1314             }
1315
1316           /* Print HintName vector entries.  */
1317           for (j = 0; j < datasize; j += 4)
1318             {
1319               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1320
1321               /* Print single IMAGE_IMPORT_BY_NAME vector.  */
1322               if (member == 0)
1323                 break;
1324
1325               if (member & 0x80000000)
1326                 fprintf (file, "\t%04lx\t %4lu  <none>",
1327                          member, member & 0x7fffffff);
1328               else
1329                 {
1330                   int ordinal;
1331                   char *member_name;
1332
1333                   ordinal = bfd_get_16 (abfd, data + member - adj);
1334                   member_name = (char *) data + member - adj + 2;
1335                   fprintf (file, "\t%04lx\t %4d  %s",
1336                            member, ordinal, member_name);
1337                 }
1338
1339               /* If the time stamp is not zero, the import address
1340                  table holds actual addresses.  */
1341               if (time_stamp != 0
1342                   && first_thunk != 0
1343                   && first_thunk != hint_addr)
1344                 fprintf (file, "\t%04lx",
1345                          (long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1346
1347               fprintf (file, "\n");
1348             }
1349
1350           if (ft_allocated)
1351             free (ft_data);
1352         }
1353
1354       fprintf (file, "\n");
1355     }
1356
1357   free (data);
1358
1359   return TRUE;
1360 }
1361
1362 static bfd_boolean
1363 pe_print_edata (abfd, vfile)
1364      bfd *abfd;
1365      PTR vfile;
1366 {
1367   FILE *file = (FILE *) vfile;
1368   bfd_byte *data;
1369   asection *section;
1370   bfd_size_type datasize = 0;
1371   bfd_size_type dataoff;
1372   bfd_size_type i;
1373   bfd_signed_vma adj;
1374   struct EDT_type
1375   {
1376     long export_flags;          /* reserved - should be zero */
1377     long time_stamp;
1378     short major_ver;
1379     short minor_ver;
1380     bfd_vma name;               /* rva - relative to image base */
1381     long base;                  /* ordinal base */
1382     unsigned long num_functions;/* Number in the export address table */
1383     unsigned long num_names;    /* Number in the name pointer table */
1384     bfd_vma eat_addr;           /* rva to the export address table */
1385     bfd_vma npt_addr;           /* rva to the Export Name Pointer Table */
1386     bfd_vma ot_addr;            /* rva to the Ordinal Table */
1387   } edt;
1388
1389   pe_data_type *pe = pe_data (abfd);
1390   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1391
1392   bfd_vma addr;
1393
1394   addr = extra->DataDirectory[0].VirtualAddress;
1395
1396   if (addr == 0 && extra->DataDirectory[0].Size == 0)
1397     {
1398       /* Maybe the extra header isn't there.  Look for the section.  */
1399       section = bfd_get_section_by_name (abfd, ".edata");
1400       if (section == NULL)
1401         return TRUE;
1402
1403       addr = section->vma;
1404       datasize = bfd_section_size (abfd, section);
1405       if (datasize == 0)
1406         return TRUE;
1407     }
1408   else
1409     {
1410       addr += extra->ImageBase;
1411
1412       for (section = abfd->sections; section != NULL; section = section->next)
1413         {
1414           datasize = bfd_section_size (abfd, section);
1415
1416           if (addr >= section->vma && addr < section->vma + datasize)
1417             break;
1418         }
1419
1420       if (section == NULL)
1421         {
1422           fprintf (file,
1423                    _("\nThere is an export table, but the section containing it could not be found\n"));
1424           return TRUE;
1425         }
1426     }
1427
1428   fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1429            section->name, (unsigned long) addr);
1430
1431   dataoff = addr - section->vma;
1432   datasize -= dataoff;
1433
1434   data = (bfd_byte *) bfd_malloc (datasize);
1435   if (data == NULL)
1436     return FALSE;
1437
1438   if (! bfd_get_section_contents (abfd, section, (PTR) data,
1439                                   (file_ptr) dataoff, datasize))
1440     return FALSE;
1441
1442   /* Go get Export Directory Table.  */
1443   edt.export_flags   = bfd_get_32 (abfd, data +  0);
1444   edt.time_stamp     = bfd_get_32 (abfd, data +  4);
1445   edt.major_ver      = bfd_get_16 (abfd, data +  8);
1446   edt.minor_ver      = bfd_get_16 (abfd, data + 10);
1447   edt.name           = bfd_get_32 (abfd, data + 12);
1448   edt.base           = bfd_get_32 (abfd, data + 16);
1449   edt.num_functions  = bfd_get_32 (abfd, data + 20);
1450   edt.num_names      = bfd_get_32 (abfd, data + 24);
1451   edt.eat_addr       = bfd_get_32 (abfd, data + 28);
1452   edt.npt_addr       = bfd_get_32 (abfd, data + 32);
1453   edt.ot_addr        = bfd_get_32 (abfd, data + 36);
1454
1455   adj = section->vma - extra->ImageBase + dataoff;
1456
1457   /* Dump the EDT first.  */
1458   fprintf (file,
1459            _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1460            section->name);
1461
1462   fprintf (file,
1463            _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1464
1465   fprintf (file,
1466            _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1467
1468   fprintf (file,
1469            _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1470
1471   fprintf (file,
1472            _("Name \t\t\t\t"));
1473   fprintf_vma (file, edt.name);
1474   fprintf (file,
1475            " %s\n", data + edt.name - adj);
1476
1477   fprintf (file,
1478            _("Ordinal Base \t\t\t%ld\n"), edt.base);
1479
1480   fprintf (file,
1481            _("Number in:\n"));
1482
1483   fprintf (file,
1484            _("\tExport Address Table \t\t%08lx\n"),
1485            edt.num_functions);
1486
1487   fprintf (file,
1488            _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1489
1490   fprintf (file,
1491            _("Table Addresses\n"));
1492
1493   fprintf (file,
1494            _("\tExport Address Table \t\t"));
1495   fprintf_vma (file, edt.eat_addr);
1496   fprintf (file, "\n");
1497
1498   fprintf (file,
1499            _("\tName Pointer Table \t\t"));
1500   fprintf_vma (file, edt.npt_addr);
1501   fprintf (file, "\n");
1502
1503   fprintf (file,
1504            _("\tOrdinal Table \t\t\t"));
1505   fprintf_vma (file, edt.ot_addr);
1506   fprintf (file, "\n");
1507
1508   /* The next table to find is the Export Address Table. It's basically
1509      a list of pointers that either locate a function in this dll, or
1510      forward the call to another dll. Something like:
1511       typedef union
1512       {
1513         long export_rva;
1514         long forwarder_rva;
1515       } export_address_table_entry;
1516   */
1517
1518   fprintf (file,
1519           _("\nExport Address Table -- Ordinal Base %ld\n"),
1520           edt.base);
1521
1522   for (i = 0; i < edt.num_functions; ++i)
1523     {
1524       bfd_vma eat_member = bfd_get_32 (abfd,
1525                                        data + edt.eat_addr + (i * 4) - adj);
1526       if (eat_member == 0)
1527         continue;
1528
1529       if (eat_member - adj <= datasize)
1530         {
1531           /* This rva is to a name (forwarding function) in our section.  */
1532           /* Should locate a function descriptor.  */
1533           fprintf (file,
1534                    "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1535                    (long) i,
1536                    (long) (i + edt.base),
1537                    (unsigned long) eat_member,
1538                    _("Forwarder RVA"),
1539                    data + eat_member - adj);
1540         }
1541       else
1542         {
1543           /* Should locate a function descriptor in the reldata section.  */
1544           fprintf (file,
1545                    "\t[%4ld] +base[%4ld] %04lx %s\n",
1546                    (long) i,
1547                    (long) (i + edt.base),
1548                    (unsigned long) eat_member,
1549                    _("Export RVA"));
1550         }
1551     }
1552
1553   /* The Export Name Pointer Table is paired with the Export Ordinal Table.  */
1554   /* Dump them in parallel for clarity.  */
1555   fprintf (file,
1556            _("\n[Ordinal/Name Pointer] Table\n"));
1557
1558   for (i = 0; i < edt.num_names; ++i)
1559     {
1560       bfd_vma name_ptr = bfd_get_32 (abfd,
1561                                     data +
1562                                     edt.npt_addr
1563                                     + (i*4) - adj);
1564
1565       char *name = (char *) data + name_ptr - adj;
1566
1567       bfd_vma ord = bfd_get_16 (abfd,
1568                                     data +
1569                                     edt.ot_addr
1570                                     + (i*2) - adj);
1571       fprintf (file,
1572               "\t[%4ld] %s\n", (long) ord, name);
1573     }
1574
1575   free (data);
1576
1577   return TRUE;
1578 }
1579
1580 /* This really is architecture dependent.  On IA-64, a .pdata entry
1581    consists of three dwords containing relative virtual addresses that
1582    specify the start and end address of the code range the entry
1583    covers and the address of the corresponding unwind info data.  */
1584
1585 static bfd_boolean
1586 pe_print_pdata (abfd, vfile)
1587      bfd *abfd;
1588      PTR vfile;
1589 {
1590 #ifdef COFF_WITH_pep
1591 # define PDATA_ROW_SIZE (3*8)
1592 #else
1593 # define PDATA_ROW_SIZE (5*4)
1594 #endif
1595   FILE *file = (FILE *) vfile;
1596   bfd_byte *data = 0;
1597   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1598   bfd_size_type datasize = 0;
1599   bfd_size_type i;
1600   bfd_size_type start, stop;
1601   int onaline = PDATA_ROW_SIZE;
1602
1603   if (section == NULL
1604       || coff_section_data (abfd, section) == NULL
1605       || pei_section_data (abfd, section) == NULL)
1606     return TRUE;
1607
1608   stop = pei_section_data (abfd, section)->virt_size;
1609   if ((stop % onaline) != 0)
1610     fprintf (file,
1611              _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1612              (long) stop, onaline);
1613
1614   fprintf (file,
1615            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1616 #ifdef COFF_WITH_pep
1617   fprintf (file,
1618            _(" vma:\t\t\tBegin Address    End Address      Unwind Info\n"));
1619 #else
1620   fprintf (file, _("\
1621  vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n\
1622      \t\tAddress  Address  Handler  Data     Address    Mask\n"));
1623 #endif
1624
1625   datasize = bfd_section_size (abfd, section);
1626   if (datasize == 0)
1627     return TRUE;
1628
1629   data = (bfd_byte *) bfd_malloc (datasize);
1630   if (data == NULL && datasize != 0)
1631     return FALSE;
1632
1633   bfd_get_section_contents (abfd, section, (PTR) data, (bfd_vma) 0,
1634                             datasize);
1635
1636   start = 0;
1637
1638   for (i = start; i < stop; i += onaline)
1639     {
1640       bfd_vma begin_addr;
1641       bfd_vma end_addr;
1642       bfd_vma eh_handler;
1643       bfd_vma eh_data;
1644       bfd_vma prolog_end_addr;
1645       int em_data;
1646
1647       if (i + PDATA_ROW_SIZE > stop)
1648         break;
1649
1650       begin_addr      = GET_PDATA_ENTRY (abfd, data + i     );
1651       end_addr        = GET_PDATA_ENTRY (abfd, data + i +  4);
1652       eh_handler      = GET_PDATA_ENTRY (abfd, data + i +  8);
1653       eh_data         = GET_PDATA_ENTRY (abfd, data + i + 12);
1654       prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1655
1656       if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1657           && eh_data == 0 && prolog_end_addr == 0)
1658         /* We are probably into the padding of the section now.  */
1659         break;
1660
1661       em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1662       eh_handler &= ~(bfd_vma) 0x3;
1663       prolog_end_addr &= ~(bfd_vma) 0x3;
1664
1665       fputc (' ', file);
1666       fprintf_vma (file, i + section->vma); fputc ('\t', file);
1667       fprintf_vma (file, begin_addr); fputc (' ', file);
1668       fprintf_vma (file, end_addr); fputc (' ', file);
1669       fprintf_vma (file, eh_handler);
1670 #ifndef COFF_WITH_pep
1671       fputc (' ', file);
1672       fprintf_vma (file, eh_data); fputc (' ', file);
1673       fprintf_vma (file, prolog_end_addr);
1674       fprintf (file, "   %x", em_data);
1675 #endif
1676
1677 #ifdef POWERPC_LE_PE
1678       if (eh_handler == 0 && eh_data != 0)
1679         {
1680           /* Special bits here, although the meaning may be a little
1681              mysterious. The only one I know for sure is 0x03.  */
1682           /* Code Significance                           */
1683           /* 0x00 None                                   */
1684           /* 0x01 Register Save Millicode                */
1685           /* 0x02 Register Restore Millicode             */
1686           /* 0x03 Glue Code Sequence                     */
1687           switch (eh_data)
1688             {
1689             case 0x01:
1690               fprintf (file, _(" Register save millicode"));
1691               break;
1692             case 0x02:
1693               fprintf (file, _(" Register restore millicode"));
1694               break;
1695             case 0x03:
1696               fprintf (file, _(" Glue code sequence"));
1697               break;
1698             default:
1699               break;
1700             }
1701         }
1702 #endif
1703       fprintf (file, "\n");
1704     }
1705
1706   free (data);
1707
1708   return TRUE;
1709 }
1710
1711 #define IMAGE_REL_BASED_HIGHADJ 4
1712 static const char * const tbl[] =
1713   {
1714     "ABSOLUTE",
1715     "HIGH",
1716     "LOW",
1717     "HIGHLOW",
1718     "HIGHADJ",
1719     "MIPS_JMPADDR",
1720     "SECTION",
1721     "REL32",
1722     "RESERVED1",
1723     "MIPS_JMPADDR16",
1724     "DIR64",
1725     "HIGH3ADJ"
1726     "UNKNOWN",   /* MUST be last */
1727   };
1728
1729 static bfd_boolean
1730 pe_print_reloc (abfd, vfile)
1731      bfd *abfd;
1732      PTR vfile;
1733 {
1734   FILE *file = (FILE *) vfile;
1735   bfd_byte *data = 0;
1736   asection *section = bfd_get_section_by_name (abfd, ".reloc");
1737   bfd_size_type datasize;
1738   bfd_size_type i;
1739   bfd_size_type start, stop;
1740
1741   if (section == NULL)
1742     return TRUE;
1743
1744   if (bfd_section_size (abfd, section) == 0)
1745     return TRUE;
1746
1747   fprintf (file,
1748            _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1749
1750   datasize = bfd_section_size (abfd, section);
1751   data = (bfd_byte *) bfd_malloc (datasize);
1752   if (data == NULL && datasize != 0)
1753     return FALSE;
1754
1755   bfd_get_section_contents (abfd, section, (PTR) data, (bfd_vma) 0,
1756                             datasize);
1757
1758   start = 0;
1759
1760   stop = bfd_section_size (abfd, section);
1761
1762   for (i = start; i < stop;)
1763     {
1764       int j;
1765       bfd_vma virtual_address;
1766       long number, size;
1767
1768       /* The .reloc section is a sequence of blocks, with a header consisting
1769          of two 32 bit quantities, followed by a number of 16 bit entries.  */
1770       virtual_address = bfd_get_32 (abfd, data+i);
1771       size = bfd_get_32 (abfd, data+i+4);
1772       number = (size - 8) / 2;
1773
1774       if (size == 0)
1775         break;
1776
1777       fprintf (file,
1778                _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1779                (unsigned long) virtual_address, size, size, number);
1780
1781       for (j = 0; j < number; ++j)
1782         {
1783           unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1784           unsigned int t = (e & 0xF000) >> 12;
1785           int off = e & 0x0FFF;
1786
1787           if (t >= sizeof (tbl) / sizeof (tbl[0]))
1788             t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1789
1790           fprintf (file,
1791                    _("\treloc %4d offset %4x [%4lx] %s"),
1792                    j, off, (long) (off + virtual_address), tbl[t]);
1793
1794           /* HIGHADJ takes an argument, - the next record *is* the
1795              low 16 bits of addend.  */
1796           if (t == IMAGE_REL_BASED_HIGHADJ)
1797             {
1798               fprintf (file, " (%4x)",
1799                        ((unsigned int)
1800                         bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1801               j++;
1802             }
1803
1804           fprintf (file, "\n");
1805         }
1806
1807       i += size;
1808     }
1809
1810   free (data);
1811
1812   return TRUE;
1813 }
1814
1815 /* Print out the program headers.  */
1816
1817 bfd_boolean
1818 _bfd_XX_print_private_bfd_data_common (abfd, vfile)
1819      bfd *abfd;
1820      PTR vfile;
1821 {
1822   FILE *file = (FILE *) vfile;
1823   int j;
1824   pe_data_type *pe = pe_data (abfd);
1825   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
1826   const char *subsystem_name = NULL;
1827
1828   /* The MS dumpbin program reportedly ands with 0xff0f before
1829      printing the characteristics field.  Not sure why.  No reason to
1830      emulate it here.  */
1831   fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
1832 #undef PF
1833 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
1834   PF (F_RELFLG, "relocations stripped");
1835   PF (F_EXEC, "executable");
1836   PF (F_LNNO, "line numbers stripped");
1837   PF (F_LSYMS, "symbols stripped");
1838   PF (0x80, "little endian");
1839   PF (F_AR32WR, "32 bit words");
1840   PF (0x200, "debugging information removed");
1841   PF (0x1000, "system file");
1842   PF (F_DLL, "DLL");
1843   PF (0x8000, "big endian");
1844 #undef PF
1845
1846   /* ctime implies '\n'.  */
1847   {
1848     time_t t = pe->coff.timestamp;
1849     fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
1850   }
1851   fprintf (file, "\nImageBase\t\t");
1852   fprintf_vma (file, i->ImageBase);
1853   fprintf (file, "\nSectionAlignment\t");
1854   fprintf_vma (file, i->SectionAlignment);
1855   fprintf (file, "\nFileAlignment\t\t");
1856   fprintf_vma (file, i->FileAlignment);
1857   fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1858   fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1859   fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
1860   fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
1861   fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1862   fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1863   fprintf (file, "Win32Version\t\t%08lx\n", i->Reserved1);
1864   fprintf (file, "SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1865   fprintf (file, "SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1866   fprintf (file, "CheckSum\t\t%08lx\n", i->CheckSum);
1867
1868   switch (i->Subsystem)
1869     {
1870     case IMAGE_SUBSYSTEM_UNKNOWN:
1871       subsystem_name = "unspecified";
1872       break;
1873     case IMAGE_SUBSYSTEM_NATIVE:
1874       subsystem_name = "NT native";
1875       break;
1876     case IMAGE_SUBSYSTEM_WINDOWS_GUI:
1877       subsystem_name = "Windows GUI";
1878       break;
1879     case IMAGE_SUBSYSTEM_WINDOWS_CUI:
1880       subsystem_name = "Windows CUI";
1881       break;
1882     case IMAGE_SUBSYSTEM_POSIX_CUI:
1883       subsystem_name = "POSIX CUI";
1884       break;
1885     case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
1886       subsystem_name = "Wince CUI";
1887       break;
1888     case IMAGE_SUBSYSTEM_EFI_APPLICATION:
1889       subsystem_name = "EFI application";
1890       break;
1891     case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
1892       subsystem_name = "EFI boot service driver";
1893       break;
1894     case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
1895       subsystem_name = "EFI runtime driver";
1896       break;
1897     }
1898
1899   fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
1900   if (subsystem_name)
1901     fprintf (file, "\t(%s)", subsystem_name);
1902   fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
1903   fprintf (file, "SizeOfStackReserve\t");
1904   fprintf_vma (file, i->SizeOfStackReserve);
1905   fprintf (file, "\nSizeOfStackCommit\t");
1906   fprintf_vma (file, i->SizeOfStackCommit);
1907   fprintf (file, "\nSizeOfHeapReserve\t");
1908   fprintf_vma (file, i->SizeOfHeapReserve);
1909   fprintf (file, "\nSizeOfHeapCommit\t");
1910   fprintf_vma (file, i->SizeOfHeapCommit);
1911   fprintf (file, "\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
1912   fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1913
1914   fprintf (file, "\nThe Data Directory\n");
1915   for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1916     {
1917       fprintf (file, "Entry %1x ", j);
1918       fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1919       fprintf (file, " %08lx ", i->DataDirectory[j].Size);
1920       fprintf (file, "%s\n", dir_names[j]);
1921     }
1922
1923   pe_print_idata (abfd, vfile);
1924   pe_print_edata (abfd, vfile);
1925   pe_print_pdata (abfd, vfile);
1926   pe_print_reloc (abfd, vfile);
1927
1928   return TRUE;
1929 }
1930
1931 /* Copy any private info we understand from the input bfd
1932    to the output bfd.  */
1933
1934 bfd_boolean
1935 _bfd_XX_bfd_copy_private_bfd_data_common (ibfd, obfd)
1936      bfd *ibfd, *obfd;
1937 {
1938   /* One day we may try to grok other private data.  */
1939   if (ibfd->xvec->flavour != bfd_target_coff_flavour
1940       || obfd->xvec->flavour != bfd_target_coff_flavour)
1941     return TRUE;
1942
1943   pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr;
1944   pe_data (obfd)->dll = pe_data (ibfd)->dll;
1945
1946   /* For strip: if we removed .reloc, we'll make a real mess of things
1947      if we don't remove this entry as well.  */
1948   if (! pe_data (obfd)->has_reloc_section)
1949     {
1950       pe_data (obfd)->pe_opthdr.DataDirectory[5].VirtualAddress = 0;
1951       pe_data (obfd)->pe_opthdr.DataDirectory[5].Size = 0;
1952     }
1953   return TRUE;
1954 }
1955
1956 /* Copy private section data.  */
1957
1958 bfd_boolean
1959 _bfd_XX_bfd_copy_private_section_data (ibfd, isec, obfd, osec)
1960      bfd *ibfd;
1961      asection *isec;
1962      bfd *obfd;
1963      asection *osec;
1964 {
1965   if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
1966       || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
1967     return TRUE;
1968
1969   if (coff_section_data (ibfd, isec) != NULL
1970       && pei_section_data (ibfd, isec) != NULL)
1971     {
1972       if (coff_section_data (obfd, osec) == NULL)
1973         {
1974           bfd_size_type amt = sizeof (struct coff_section_tdata);
1975           osec->used_by_bfd = (PTR) bfd_zalloc (obfd, amt);
1976           if (osec->used_by_bfd == NULL)
1977             return FALSE;
1978         }
1979
1980       if (pei_section_data (obfd, osec) == NULL)
1981         {
1982           bfd_size_type amt = sizeof (struct pei_section_tdata);
1983           coff_section_data (obfd, osec)->tdata = (PTR) bfd_zalloc (obfd, amt);
1984           if (coff_section_data (obfd, osec)->tdata == NULL)
1985             return FALSE;
1986         }
1987
1988       pei_section_data (obfd, osec)->virt_size =
1989         pei_section_data (ibfd, isec)->virt_size;
1990       pei_section_data (obfd, osec)->pe_flags =
1991         pei_section_data (ibfd, isec)->pe_flags;
1992     }
1993
1994   return TRUE;
1995 }
1996
1997 void
1998 _bfd_XX_get_symbol_info (abfd, symbol, ret)
1999      bfd *abfd;
2000      asymbol *symbol;
2001      symbol_info *ret;
2002 {
2003   coff_get_symbol_info (abfd, symbol, ret);
2004 #if 0 /* This code no longer appears to be necessary.
2005          ImageBase has already been added in by coff_swap_scnhdr_in.  */
2006   if (pe_data (abfd) != NULL
2007       && ((symbol->flags & BSF_DEBUGGING) == 0
2008           || (symbol->flags & BSF_DEBUGGING_RELOC) != 0)
2009       && ! bfd_is_abs_section (symbol->section))
2010     ret->value += pe_data (abfd)->pe_opthdr.ImageBase;
2011 #endif
2012 }
2013
2014 /* Handle the .idata section and other things that need symbol table
2015    access.  */
2016
2017 bfd_boolean
2018 _bfd_XXi_final_link_postscript (abfd, pfinfo)
2019      bfd *abfd;
2020      struct coff_final_link_info *pfinfo;
2021 {
2022   struct coff_link_hash_entry *h1;
2023   struct bfd_link_info *info = pfinfo->info;
2024
2025   /* There are a few fields that need to be filled in now while we
2026      have symbol table access.
2027
2028      The .idata subsections aren't directly available as sections, but
2029      they are in the symbol table, so get them from there.  */
2030
2031   /* The import directory.  This is the address of .idata$2, with size
2032      of .idata$2 + .idata$3.  */
2033   h1 = coff_link_hash_lookup (coff_hash_table (info),
2034                               ".idata$2", FALSE, FALSE, TRUE);
2035   if (h1 != NULL)
2036     {
2037       pe_data (abfd)->pe_opthdr.DataDirectory[1].VirtualAddress =
2038         (h1->root.u.def.value
2039          + h1->root.u.def.section->output_section->vma
2040          + h1->root.u.def.section->output_offset);
2041       h1 = coff_link_hash_lookup (coff_hash_table (info),
2042                                   ".idata$4", FALSE, FALSE, TRUE);
2043       pe_data (abfd)->pe_opthdr.DataDirectory[1].Size =
2044         ((h1->root.u.def.value
2045           + h1->root.u.def.section->output_section->vma
2046           + h1->root.u.def.section->output_offset)
2047          - pe_data (abfd)->pe_opthdr.DataDirectory[1].VirtualAddress);
2048
2049       /* The import address table.  This is the size/address of
2050          .idata$5.  */
2051       h1 = coff_link_hash_lookup (coff_hash_table (info),
2052                                   ".idata$5", FALSE, FALSE, TRUE);
2053       pe_data (abfd)->pe_opthdr.DataDirectory[12].VirtualAddress =
2054         (h1->root.u.def.value
2055          + h1->root.u.def.section->output_section->vma
2056          + h1->root.u.def.section->output_offset);
2057       h1 = coff_link_hash_lookup (coff_hash_table (info),
2058                                   ".idata$6", FALSE, FALSE, TRUE);
2059       pe_data (abfd)->pe_opthdr.DataDirectory[12].Size =
2060         ((h1->root.u.def.value
2061           + h1->root.u.def.section->output_section->vma
2062           + h1->root.u.def.section->output_offset)
2063          - pe_data (abfd)->pe_opthdr.DataDirectory[12].VirtualAddress);
2064     }
2065
2066   h1 = coff_link_hash_lookup (coff_hash_table (info),
2067                               "__tls_used", FALSE, FALSE, TRUE);
2068   if (h1 != NULL)
2069     {
2070       pe_data (abfd)->pe_opthdr.DataDirectory[9].VirtualAddress =
2071         (h1->root.u.def.value
2072          + h1->root.u.def.section->output_section->vma
2073          + h1->root.u.def.section->output_offset
2074          - pe_data (abfd)->pe_opthdr.ImageBase);
2075       pe_data (abfd)->pe_opthdr.DataDirectory[9].Size = 0x18;
2076     }
2077
2078   /* If we couldn't find idata$2, we either have an excessively
2079      trivial program or are in DEEP trouble; we have to assume trivial
2080      program....  */
2081   return TRUE;
2082 }