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