bfd/peXXigen.c

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