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