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 < a->NumberOfRvaAndSizes; 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   add_data_entry (abfd, extra, 0, ".edata", ib);
 595   add_data_entry (abfd, extra, 2, ".rsrc", ib);
 596   add_data_entry (abfd, extra, 3, ".pdata", ib);
 597
 598   /* In theory we do not need to call add_data_entry for .idata$2 or
 599      .idata$5.  It will be done in bfd_coff_final_link where all the
 600      required information is available.  If however, we are not going
 601      to perform a final link, eg because we have been invoked by objcopy
 602      or strip, then we need to make sure that these Data Directory
 603      entries are initialised properly.
 604
 605      So - we copy the input values into the output values, and then, if
 606      a final link is going to be performed, it can overwrite them.  */
 607   extra->DataDirectory[PE_IMPORT_TABLE]  = idata2;
 608   extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
 609   extra->DataDirectory[PE_TLS_TABLE] = tls;
 610
 611   if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
 612     /* Until other .idata fixes are made (pending patch), the entry for
 613        .idata is needed for backwards compatibility.  FIXME.  */
 614     add_data_entry (abfd, extra, 1, ".idata", ib);
 615
 616   /* For some reason, the virtual size (which is what's set by
 617      add_data_entry) for .reloc is not the same as the size recorded
 618      in this slot by MSVC; it doesn't seem to cause problems (so far),
 619      but since it's the best we've got, use it.  It does do the right
 620      thing for .pdata.  */
 621   if (pe->has_reloc_section)
 622     add_data_entry (abfd, extra, 5, ".reloc", ib);
 623
 624   {
 625     asection *sec;
 626     bfd_vma hsize = 0;
 627     bfd_vma dsize = 0;
 628     bfd_vma isize = 0;
 629     bfd_vma tsize = 0;
 630
 631     for (sec = abfd->sections; sec; sec = sec->next)
 632       {
 633         int rounded = FA (sec->size);
 634
 635         /* The first non-zero section filepos is the header size.
 636            Sections without contents will have a filepos of 0.  */
 637         if (hsize == 0)
 638           hsize = sec->filepos;
 639         if (sec->flags & SEC_DATA)
 640           dsize += rounded;
 641         if (sec->flags & SEC_CODE)
 642           tsize += rounded;
 643         /* The image size is the total VIRTUAL size (which is what is
 644            in the virt_size field).  Files have been seen (from MSVC
 645            5.0 link.exe) where the file size of the .data segment is
 646            quite small compared to the virtual size.  Without this
 647            fix, strip munges the file.
 648
 649            FIXME: We need to handle holes between sections, which may
 650            happpen when we covert from another format.  We just use
 651            the virtual address and virtual size of the last section
 652            for the image size.  */
 653         if (coff_section_data (abfd, sec) != NULL
 654             && pei_section_data (abfd, sec) != NULL)
 655           isize = (sec->vma - extra->ImageBase
 656                    + SA (FA (pei_section_data (abfd, sec)->virt_size)));
 657       }
 658
 659     aouthdr_in->dsize = dsize;
 660     aouthdr_in->tsize = tsize;
 661     extra->SizeOfHeaders = hsize;
 662     extra->SizeOfImage = isize;
 663   }
 664
 665   H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
 666
 667 /* e.g. 219510000 is linker version 2.19  */
 668 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
 669
 670   /* This piece of magic sets the "linker version" field to
 671      LINKER_VERSION.  */
 672   H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
 673             aouthdr_out->standard.vstamp);
 674
 675   PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
 676   PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
 677   PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
 678   PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
 679   PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
 680                           aouthdr_out->standard.text_start);
 681
 682 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 683   /* PE32+ does not have data_start member!  */
 684   PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
 685                           aouthdr_out->standard.data_start);
 686 #endif
 687
 688   PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
 689   H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
 690   H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
 691   H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
 692             aouthdr_out->MajorOperatingSystemVersion);
 693   H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
 694             aouthdr_out->MinorOperatingSystemVersion);
 695   H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
 696   H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
 697   H_PUT_16 (abfd, extra->MajorSubsystemVersion,
 698             aouthdr_out->MajorSubsystemVersion);
 699   H_PUT_16 (abfd, extra->MinorSubsystemVersion,
 700             aouthdr_out->MinorSubsystemVersion);
 701   H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
 702   H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
 703   H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
 704   H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
 705   H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
 706   H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
 707   PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
 708                                     aouthdr_out->SizeOfStackReserve);
 709   PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
 710                                    aouthdr_out->SizeOfStackCommit);
 711   PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
 712                                    aouthdr_out->SizeOfHeapReserve);
 713   PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
 714                                   aouthdr_out->SizeOfHeapCommit);
 715   H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
 716   H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
 717             aouthdr_out->NumberOfRvaAndSizes);
 718   {
 719     int idx;
 720
 721     for (idx = 0; idx < 16; idx++)
 722       {
 723         H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
 724                   aouthdr_out->DataDirectory[idx][0]);
 725         H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
 726                   aouthdr_out->DataDirectory[idx][1]);
 727       }
 728   }
 729
 730   return AOUTSZ;
 731 }
 732
 733 unsigned int
 734 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
 735 {
 736   int idx;
 737   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 738   struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
 739
 740   if (pe_data (abfd)->has_reloc_section
 741       || pe_data (abfd)->dont_strip_reloc)
 742     filehdr_in->f_flags &= ~F_RELFLG;
 743
 744   if (pe_data (abfd)->dll)
 745     filehdr_in->f_flags |= F_DLL;
 746
 747   filehdr_in->pe.e_magic    = DOSMAGIC;
 748   filehdr_in->pe.e_cblp     = 0x90;
 749   filehdr_in->pe.e_cp       = 0x3;
 750   filehdr_in->pe.e_crlc     = 0x0;
 751   filehdr_in->pe.e_cparhdr  = 0x4;
 752   filehdr_in->pe.e_minalloc = 0x0;
 753   filehdr_in->pe.e_maxalloc = 0xffff;
 754   filehdr_in->pe.e_ss       = 0x0;
 755   filehdr_in->pe.e_sp       = 0xb8;
 756   filehdr_in->pe.e_csum     = 0x0;
 757   filehdr_in->pe.e_ip       = 0x0;
 758   filehdr_in->pe.e_cs       = 0x0;
 759   filehdr_in->pe.e_lfarlc   = 0x40;
 760   filehdr_in->pe.e_ovno     = 0x0;
 761
 762   for (idx = 0; idx < 4; idx++)
 763     filehdr_in->pe.e_res[idx] = 0x0;
 764
 765   filehdr_in->pe.e_oemid   = 0x0;
 766   filehdr_in->pe.e_oeminfo = 0x0;
 767
 768   for (idx = 0; idx < 10; idx++)
 769     filehdr_in->pe.e_res2[idx] = 0x0;
 770
 771   filehdr_in->pe.e_lfanew = 0x80;
 772
 773   /* This next collection of data are mostly just characters.  It
 774      appears to be constant within the headers put on NT exes.  */
 775   filehdr_in->pe.dos_message[0]  = 0x0eba1f0e;
 776   filehdr_in->pe.dos_message[1]  = 0xcd09b400;
 777   filehdr_in->pe.dos_message[2]  = 0x4c01b821;
 778   filehdr_in->pe.dos_message[3]  = 0x685421cd;
 779   filehdr_in->pe.dos_message[4]  = 0x70207369;
 780   filehdr_in->pe.dos_message[5]  = 0x72676f72;
 781   filehdr_in->pe.dos_message[6]  = 0x63206d61;
 782   filehdr_in->pe.dos_message[7]  = 0x6f6e6e61;
 783   filehdr_in->pe.dos_message[8]  = 0x65622074;
 784   filehdr_in->pe.dos_message[9]  = 0x6e757220;
 785   filehdr_in->pe.dos_message[10] = 0x206e6920;
 786   filehdr_in->pe.dos_message[11] = 0x20534f44;
 787   filehdr_in->pe.dos_message[12] = 0x65646f6d;
 788   filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
 789   filehdr_in->pe.dos_message[14] = 0x24;
 790   filehdr_in->pe.dos_message[15] = 0x0;
 791   filehdr_in->pe.nt_signature = NT_SIGNATURE;
 792
 793   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
 794   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 795
 796   H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
 797   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
 798                       filehdr_out->f_symptr);
 799   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 800   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 801   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 802
 803   /* Put in extra dos header stuff.  This data remains essentially
 804      constant, it just has to be tacked on to the beginning of all exes
 805      for NT.  */
 806   H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
 807   H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
 808   H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
 809   H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
 810   H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
 811   H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
 812   H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
 813   H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
 814   H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
 815   H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
 816   H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
 817   H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
 818   H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
 819   H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
 820
 821   for (idx = 0; idx < 4; idx++)
 822     H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
 823
 824   H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
 825   H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
 826
 827   for (idx = 0; idx < 10; idx++)
 828     H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
 829
 830   H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
 831
 832   for (idx = 0; idx < 16; idx++)
 833     H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
 834               filehdr_out->dos_message[idx]);
 835
 836   /* Also put in the NT signature.  */
 837   H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
 838
 839   return FILHSZ;
 840 }
 841
 842 unsigned int
 843 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
 844 {
 845   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 846   FILHDR *filehdr_out = (FILHDR *) out;
 847
 848   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
 849   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 850   H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
 851   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
 852   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 853   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 854   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 855
 856   return FILHSZ;
 857 }
 858
 859 unsigned int
 860 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
 861 {
 862   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 863   SCNHDR *scnhdr_ext = (SCNHDR *) out;
 864   unsigned int ret = SCNHSZ;
 865   bfd_vma ps;
 866   bfd_vma ss;
 867
 868   memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
 869
 870   PUT_SCNHDR_VADDR (abfd,
 871                     ((scnhdr_int->s_vaddr
 872                       - pe_data (abfd)->pe_opthdr.ImageBase)
 873                      & 0xffffffff),
 874                     scnhdr_ext->s_vaddr);
 875
 876   /* NT wants the size data to be rounded up to the next
 877      NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
 878      sometimes).  */
 879   if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
 880     {
 881       if (bfd_pei_p (abfd))
 882         {
 883           ps = scnhdr_int->s_size;
 884           ss = 0;
 885         }
 886       else
 887        {
 888          ps = 0;
 889          ss = scnhdr_int->s_size;
 890        }
 891     }
 892   else
 893     {
 894       if (bfd_pei_p (abfd))
 895         ps = scnhdr_int->s_paddr;
 896       else
 897         ps = 0;
 898
 899       ss = scnhdr_int->s_size;
 900     }
 901
 902   PUT_SCNHDR_SIZE (abfd, ss,
 903                    scnhdr_ext->s_size);
 904
 905   /* s_paddr in PE is really the virtual size.  */
 906   PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
 907
 908   PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
 909                      scnhdr_ext->s_scnptr);
 910   PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
 911                      scnhdr_ext->s_relptr);
 912   PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
 913                       scnhdr_ext->s_lnnoptr);
 914
 915   {
 916     /* Extra flags must be set when dealing with PE.  All sections should also
 917        have the IMAGE_SCN_MEM_READ (0x40000000) flag set.  In addition, the
 918        .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
 919        sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
 920        (this is especially important when dealing with the .idata section since
 921        the addresses for routines from .dlls must be overwritten).  If .reloc
 922        section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
 923        (0x02000000).  Also, the resource data should also be read and
 924        writable.  */
 925
 926     /* FIXME: Alignment is also encoded in this field, at least on PPC and
 927        ARM-WINCE.  Although - how do we get the original alignment field
 928        back ?  */
 929
 930     typedef struct
 931     {
 932       const char *      section_name;
 933       unsigned long     must_have;
 934     }
 935     pe_required_section_flags;
 936
 937     pe_required_section_flags known_sections [] =
 938       {
 939         { ".arch",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
 940         { ".bss",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 941         { ".data",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 942         { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
 943         { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 944         { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
 945         { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
 946         { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
 947         { ".rsrc",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 948         { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
 949         { ".tls",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 950         { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
 951         { NULL, 0}
 952       };
 953
 954     pe_required_section_flags * p;
 955
 956     /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
 957        we know exactly what this specific section wants so we remove it
 958        and then allow the must_have field to add it back in if necessary.
 959        However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
 960        default WP_TEXT file flag has been cleared.  WP_TEXT may be cleared
 961        by ld --enable-auto-import (if auto-import is actually needed),
 962        by ld --omagic, or by obcopy --writable-text.  */
 963
 964     for (p = known_sections; p->section_name; p++)
 965       if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
 966         {
 967           if (strcmp (scnhdr_int->s_name, ".text")
 968               || (bfd_get_file_flags (abfd) & WP_TEXT))
 969             scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
 970           scnhdr_int->s_flags |= p->must_have;
 971           break;
 972         }
 973
 974     H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
 975   }
 976
 977   if (coff_data (abfd)->link_info
 978       && ! coff_data (abfd)->link_info->relocatable
 979       && ! coff_data (abfd)->link_info->shared
 980       && strcmp (scnhdr_int->s_name, ".text") == 0)
 981     {
 982       /* By inference from looking at MS output, the 32 bit field
 983          which is the combination of the number_of_relocs and
 984          number_of_linenos is used for the line number count in
 985          executables.  A 16-bit field won't do for cc1.  The MS
 986          document says that the number of relocs is zero for
 987          executables, but the 17-th bit has been observed to be there.
 988          Overflow is not an issue: a 4G-line program will overflow a
 989          bunch of other fields long before this!  */
 990       H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
 991       H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
 992     }
 993   else
 994     {
 995       if (scnhdr_int->s_nlnno <= 0xffff)
 996         H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
 997       else
 998         {
 999           (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
1000                                  bfd_get_filename (abfd),
1001                                  scnhdr_int->s_nlnno);
1002           bfd_set_error (bfd_error_file_truncated);
1003           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1004           ret = 0;
1005         }
1006
1007       /* Although we could encode 0xffff relocs here, we do not, to be
1008          consistent with other parts of bfd. Also it lets us warn, as
1009          we should never see 0xffff here w/o having the overflow flag
1010          set.  */
1011       if (scnhdr_int->s_nreloc < 0xffff)
1012         H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1013       else
1014         {
1015           /* PE can deal with large #s of relocs, but not here.  */
1016           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1017           scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1018           H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1019         }
1020     }
1021   return ret;
1022 }
1023
1024 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1025 {
1026   N_("Export Directory [.edata (or where ever we found it)]"),
1027   N_("Import Directory [parts of .idata]"),
1028   N_("Resource Directory [.rsrc]"),
1029   N_("Exception Directory [.pdata]"),
1030   N_("Security Directory"),
1031   N_("Base Relocation Directory [.reloc]"),
1032   N_("Debug Directory"),
1033   N_("Description Directory"),
1034   N_("Special Directory"),
1035   N_("Thread Storage Directory [.tls]"),
1036   N_("Load Configuration Directory"),
1037   N_("Bound Import Directory"),
1038   N_("Import Address Table Directory"),
1039   N_("Delay Import Directory"),
1040   N_("CLR Runtime Header"),
1041   N_("Reserved")
1042 };
1043
1044 #ifdef POWERPC_LE_PE
1045 /* The code for the PPC really falls in the "architecture dependent"
1046    category.  However, it's not clear that anyone will ever care, so
1047    we're ignoring the issue for now; if/when PPC matters, some of this
1048    may need to go into peicode.h, or arguments passed to enable the
1049    PPC- specific code.  */
1050 #endif
1051
1052 static bfd_boolean
1053 pe_print_idata (bfd * abfd, void * vfile)
1054 {
1055   FILE *file = (FILE *) vfile;
1056   bfd_byte *data;
1057   asection *section;
1058   bfd_signed_vma adj;
1059
1060 #ifdef POWERPC_LE_PE
1061   asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1062 #endif
1063
1064   bfd_size_type datasize = 0;
1065   bfd_size_type dataoff;
1066   bfd_size_type i;
1067   int onaline = 20;
1068
1069   pe_data_type *pe = pe_data (abfd);
1070   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1071
1072   bfd_vma addr;
1073
1074   addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1075
1076   if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1077     {
1078       /* Maybe the extra header isn't there.  Look for the section.  */
1079       section = bfd_get_section_by_name (abfd, ".idata");
1080       if (section == NULL)
1081         return TRUE;
1082
1083       addr = section->vma;
1084       datasize = section->size;
1085       if (datasize == 0)
1086         return TRUE;
1087     }
1088   else
1089     {
1090       addr += extra->ImageBase;
1091       for (section = abfd->sections; section != NULL; section = section->next)
1092         {
1093           datasize = section->size;
1094           if (addr >= section->vma && addr < section->vma + datasize)
1095             break;
1096         }
1097
1098       if (section == NULL)
1099         {
1100           fprintf (file,
1101                    _("\nThere is an import table, but the section containing it could not be found\n"));
1102           return TRUE;
1103         }
1104     }
1105
1106   fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1107            section->name, (unsigned long) addr);
1108
1109   dataoff = addr - section->vma;
1110
1111 #ifdef POWERPC_LE_PE
1112   if (rel_section != 0 && rel_section->size != 0)
1113     {
1114       /* The toc address can be found by taking the starting address,
1115          which on the PPC locates a function descriptor. The
1116          descriptor consists of the function code starting address
1117          followed by the address of the toc. The starting address we
1118          get from the bfd, and the descriptor is supposed to be in the
1119          .reldata section.  */
1120
1121       bfd_vma loadable_toc_address;
1122       bfd_vma toc_address;
1123       bfd_vma start_address;
1124       bfd_byte *data;
1125       bfd_vma offset;
1126
1127       if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1128         {
1129           if (data != NULL)
1130             free (data);
1131           return FALSE;
1132         }
1133
1134       offset = abfd->start_address - rel_section->vma;
1135
1136       if (offset >= rel_section->size || offset + 8 > rel_section->size)
1137         {
1138           if (data != NULL)
1139             free (data);
1140           return FALSE;
1141         }
1142
1143       start_address = bfd_get_32 (abfd, data + offset);
1144       loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1145       toc_address = loadable_toc_address - 32768;
1146
1147       fprintf (file,
1148                _("\nFunction descriptor located at the start address: %04lx\n"),
1149                (unsigned long int) (abfd->start_address));
1150       fprintf (file,
1151                _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1152                start_address, loadable_toc_address, toc_address);
1153       if (data != NULL)
1154         free (data);
1155     }
1156   else
1157     {
1158       fprintf (file,
1159                _("\nNo reldata section! Function descriptor not decoded.\n"));
1160     }
1161 #endif
1162
1163   fprintf (file,
1164            _("\nThe Import Tables (interpreted %s section contents)\n"),
1165            section->name);
1166   fprintf (file,
1167            _("\
1168  vma:            Hint    Time      Forward  DLL       First\n\
1169                  Table   Stamp     Chain    Name      Thunk\n"));
1170
1171   /* Read the whole section.  Some of the fields might be before dataoff.  */
1172   if (!bfd_malloc_and_get_section (abfd, section, &data))
1173     {
1174       if (data != NULL)
1175         free (data);
1176       return FALSE;
1177     }
1178
1179   adj = section->vma - extra->ImageBase;
1180
1181   /* Print all image import descriptors.  */
1182   for (i = dataoff; i + onaline <= datasize; i += onaline)
1183     {
1184       bfd_vma hint_addr;
1185       bfd_vma time_stamp;
1186       bfd_vma forward_chain;
1187       bfd_vma dll_name;
1188       bfd_vma first_thunk;
1189       int idx = 0;
1190       bfd_size_type j;
1191       char *dll;
1192
1193       /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress).  */
1194       fprintf (file, " %08lx\t", (unsigned long) (i + adj));
1195       hint_addr = bfd_get_32 (abfd, data + i);
1196       time_stamp = bfd_get_32 (abfd, data + i + 4);
1197       forward_chain = bfd_get_32 (abfd, data + i + 8);
1198       dll_name = bfd_get_32 (abfd, data + i + 12);
1199       first_thunk = bfd_get_32 (abfd, data + i + 16);
1200
1201       fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1202                (unsigned long) hint_addr,
1203                (unsigned long) time_stamp,
1204                (unsigned long) forward_chain,
1205                (unsigned long) dll_name,
1206                (unsigned long) first_thunk);
1207
1208       if (hint_addr == 0 && first_thunk == 0)
1209         break;
1210
1211       if (dll_name - adj >= section->size)
1212         break;
1213
1214       dll = (char *) data + dll_name - adj;
1215       fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1216
1217       if (hint_addr != 0)
1218         {
1219           bfd_byte *ft_data;
1220           asection *ft_section;
1221           bfd_vma ft_addr;
1222           bfd_size_type ft_datasize;
1223           int ft_idx;
1224           int ft_allocated;
1225
1226           fprintf (file, _("\tvma:  Hint/Ord Member-Name Bound-To\n"));
1227
1228           idx = hint_addr - adj;
1229
1230           ft_addr = first_thunk + extra->ImageBase;
1231           ft_idx = first_thunk - adj;
1232           ft_data = data + ft_idx;
1233           ft_datasize = datasize - ft_idx;
1234           ft_allocated = 0;
1235
1236           if (first_thunk != hint_addr)
1237             {
1238               /* Find the section which contains the first thunk.  */
1239               for (ft_section = abfd->sections;
1240                    ft_section != NULL;
1241                    ft_section = ft_section->next)
1242                 {
1243                   if (ft_addr >= ft_section->vma
1244                       && ft_addr < ft_section->vma + ft_section->size)
1245                     break;
1246                 }
1247
1248               if (ft_section == NULL)
1249                 {
1250                   fprintf (file,
1251                        _("\nThere is a first thunk, but the section containing it could not be found\n"));
1252                   continue;
1253                 }
1254
1255               /* Now check to see if this section is the same as our current
1256                  section.  If it is not then we will have to load its data in.  */
1257               if (ft_section != section)
1258                 {
1259                   ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1260                   ft_datasize = ft_section->size - ft_idx;
1261                   ft_data = (bfd_byte *) bfd_malloc (ft_datasize);
1262                   if (ft_data == NULL)
1263                     continue;
1264
1265                   /* Read ft_datasize bytes starting at offset ft_idx.  */
1266                   if (!bfd_get_section_contents (abfd, ft_section, ft_data,
1267                                                  (bfd_vma) ft_idx, ft_datasize))
1268                     {
1269                       free (ft_data);
1270                       continue;
1271                     }
1272                   ft_allocated = 1;
1273                 }
1274             }
1275
1276           /* Print HintName vector entries.  */
1277 #ifdef COFF_WITH_pex64
1278           for (j = 0; idx + j + 8 <= datasize; j += 8)
1279             {
1280               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1281               unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1282
1283               if (!member && !member_high)
1284                 break;
1285
1286               if (member_high & 0x80000000)
1287                 fprintf (file, "\t%lx%08lx\t %4lx%08lx  <none>",
1288                          member_high,member, member_high & 0x7fffffff, member);
1289               else
1290                 {
1291                   int ordinal;
1292                   char *member_name;
1293
1294                   ordinal = bfd_get_16 (abfd, data + member - adj);
1295                   member_name = (char *) data + member - adj + 2;
1296                   fprintf (file, "\t%04lx\t %4d  %s",member, ordinal, member_name);
1297                 }
1298
1299               /* If the time stamp is not zero, the import address
1300                  table holds actual addresses.  */
1301               if (time_stamp != 0
1302                   && first_thunk != 0
1303                   && first_thunk != hint_addr
1304                   && j + 4 <= ft_datasize)
1305                 fprintf (file, "\t%04lx",
1306                          (unsigned long) bfd_get_32 (abfd, ft_data + j));
1307               fprintf (file, "\n");
1308             }
1309 #else
1310           for (j = 0; idx + j + 4 <= datasize; j += 4)
1311             {
1312               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1313
1314               /* Print single IMAGE_IMPORT_BY_NAME vector.  */
1315               if (member == 0)
1316                 break;
1317
1318               if (member & 0x80000000)
1319                 fprintf (file, "\t%04lx\t %4lu  <none>",
1320                          member, member & 0x7fffffff);
1321               else
1322                 {
1323                   int ordinal;
1324                   char *member_name;
1325
1326                   ordinal = bfd_get_16 (abfd, data + member - adj);
1327                   member_name = (char *) data + member - adj + 2;
1328                   fprintf (file, "\t%04lx\t %4d  %s",
1329                            member, ordinal, member_name);
1330                 }
1331
1332               /* If the time stamp is not zero, the import address
1333                  table holds actual addresses.  */
1334               if (time_stamp != 0
1335                   && first_thunk != 0
1336                   && first_thunk != hint_addr
1337                   && j + 4 <= ft_datasize)
1338                 fprintf (file, "\t%04lx",
1339                          (unsigned long) bfd_get_32 (abfd, ft_data + j));
1340
1341               fprintf (file, "\n");
1342             }
1343 #endif
1344           if (ft_allocated)
1345             free (ft_data);
1346         }
1347
1348       fprintf (file, "\n");
1349     }
1350
1351   free (data);
1352
1353   return TRUE;
1354 }
1355
1356 static bfd_boolean
1357 pe_print_edata (bfd * abfd, void * vfile)
1358 {
1359   FILE *file = (FILE *) vfile;
1360   bfd_byte *data;
1361   asection *section;
1362   bfd_size_type datasize = 0;
1363   bfd_size_type dataoff;
1364   bfd_size_type i;
1365   bfd_signed_vma adj;
1366   struct EDT_type
1367   {
1368     long export_flags;          /* Reserved - should be zero.  */
1369     long time_stamp;
1370     short major_ver;
1371     short minor_ver;
1372     bfd_vma name;               /* RVA - relative to image base.  */
1373     long base;                  /* Ordinal base.  */
1374     unsigned long num_functions;/* Number in the export address table.  */
1375     unsigned long num_names;    /* Number in the name pointer table.  */
1376     bfd_vma eat_addr;           /* RVA to the export address table.  */
1377     bfd_vma npt_addr;           /* RVA to the Export Name Pointer Table.  */
1378     bfd_vma ot_addr;            /* RVA to the Ordinal Table.  */
1379   } edt;
1380
1381   pe_data_type *pe = pe_data (abfd);
1382   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1383
1384   bfd_vma addr;
1385
1386   addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1387
1388   if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1389     {
1390       /* Maybe the extra header isn't there.  Look for the section.  */
1391       section = bfd_get_section_by_name (abfd, ".edata");
1392       if (section == NULL)
1393         return TRUE;
1394
1395       addr = section->vma;
1396       dataoff = 0;
1397       datasize = section->size;
1398       if (datasize == 0)
1399         return TRUE;
1400     }
1401   else
1402     {
1403       addr += extra->ImageBase;
1404
1405       for (section = abfd->sections; section != NULL; section = section->next)
1406         if (addr >= section->vma && addr < section->vma + section->size)
1407           break;
1408
1409       if (section == NULL)
1410         {
1411           fprintf (file,
1412                    _("\nThere is an export table, but the section containing it could not be found\n"));
1413           return TRUE;
1414         }
1415
1416       dataoff = addr - section->vma;
1417       datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1418       if (datasize > section->size - dataoff)
1419         {
1420           fprintf (file,
1421                    _("\nThere is an export table in %s, but it does not fit into that section\n"),
1422                    section->name);
1423           return TRUE;
1424         }
1425     }
1426
1427   fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1428            section->name, (unsigned long) addr);
1429
1430   data = (bfd_byte *) bfd_malloc (datasize);
1431   if (data == NULL)
1432     return FALSE;
1433
1434   if (! bfd_get_section_contents (abfd, section, data,
1435                                   (file_ptr) dataoff, datasize))
1436     return FALSE;
1437
1438   /* Go get Export Directory Table.  */
1439   edt.export_flags   = bfd_get_32 (abfd, data +  0);
1440   edt.time_stamp     = bfd_get_32 (abfd, data +  4);
1441   edt.major_ver      = bfd_get_16 (abfd, data +  8);
1442   edt.minor_ver      = bfd_get_16 (abfd, data + 10);
1443   edt.name           = bfd_get_32 (abfd, data + 12);
1444   edt.base           = bfd_get_32 (abfd, data + 16);
1445   edt.num_functions  = bfd_get_32 (abfd, data + 20);
1446   edt.num_names      = bfd_get_32 (abfd, data + 24);
1447   edt.eat_addr       = bfd_get_32 (abfd, data + 28);
1448   edt.npt_addr       = bfd_get_32 (abfd, data + 32);
1449   edt.ot_addr        = bfd_get_32 (abfd, data + 36);
1450
1451   adj = section->vma - extra->ImageBase + dataoff;
1452
1453   /* Dump the EDT first.  */
1454   fprintf (file,
1455            _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1456            section->name);
1457
1458   fprintf (file,
1459            _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1460
1461   fprintf (file,
1462            _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1463
1464   fprintf (file,
1465            _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1466
1467   fprintf (file,
1468            _("Name \t\t\t\t"));
1469   bfd_fprintf_vma (abfd, file, edt.name);
1470   fprintf (file,
1471            " %s\n", data + edt.name - adj);
1472
1473   fprintf (file,
1474            _("Ordinal Base \t\t\t%ld\n"), edt.base);
1475
1476   fprintf (file,
1477            _("Number in:\n"));
1478
1479   fprintf (file,
1480            _("\tExport Address Table \t\t%08lx\n"),
1481            edt.num_functions);
1482
1483   fprintf (file,
1484            _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1485
1486   fprintf (file,
1487            _("Table Addresses\n"));
1488
1489   fprintf (file,
1490            _("\tExport Address Table \t\t"));
1491   bfd_fprintf_vma (abfd, file, edt.eat_addr);
1492   fprintf (file, "\n");
1493
1494   fprintf (file,
1495            _("\tName Pointer Table \t\t"));
1496   bfd_fprintf_vma (abfd, file, edt.npt_addr);
1497   fprintf (file, "\n");
1498
1499   fprintf (file,
1500            _("\tOrdinal Table \t\t\t"));
1501   bfd_fprintf_vma (abfd, file, edt.ot_addr);
1502   fprintf (file, "\n");
1503
1504   /* The next table to find is the Export Address Table. It's basically
1505      a list of pointers that either locate a function in this dll, or
1506      forward the call to another dll. Something like:
1507       typedef union
1508       {
1509         long export_rva;
1510         long forwarder_rva;
1511       } export_address_table_entry;  */
1512
1513   fprintf (file,
1514           _("\nExport Address Table -- Ordinal Base %ld\n"),
1515           edt.base);
1516
1517   for (i = 0; i < edt.num_functions; ++i)
1518     {
1519       bfd_vma eat_member = bfd_get_32 (abfd,
1520                                        data + edt.eat_addr + (i * 4) - adj);
1521       if (eat_member == 0)
1522         continue;
1523
1524       if (eat_member - adj <= datasize)
1525         {
1526           /* This rva is to a name (forwarding function) in our section.  */
1527           /* Should locate a function descriptor.  */
1528           fprintf (file,
1529                    "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1530                    (long) i,
1531                    (long) (i + edt.base),
1532                    (unsigned long) eat_member,
1533                    _("Forwarder RVA"),
1534                    data + eat_member - adj);
1535         }
1536       else
1537         {
1538           /* Should locate a function descriptor in the reldata section.  */
1539           fprintf (file,
1540                    "\t[%4ld] +base[%4ld] %04lx %s\n",
1541                    (long) i,
1542                    (long) (i + edt.base),
1543                    (unsigned long) eat_member,
1544                    _("Export RVA"));
1545         }
1546     }
1547
1548   /* The Export Name Pointer Table is paired with the Export Ordinal Table.  */
1549   /* Dump them in parallel for clarity.  */
1550   fprintf (file,
1551            _("\n[Ordinal/Name Pointer] Table\n"));
1552
1553   for (i = 0; i < edt.num_names; ++i)
1554     {
1555       bfd_vma name_ptr = bfd_get_32 (abfd,
1556                                     data +
1557                                     edt.npt_addr
1558                                     + (i*4) - adj);
1559
1560       char *name = (char *) data + name_ptr - adj;
1561
1562       bfd_vma ord = bfd_get_16 (abfd,
1563                                     data +
1564                                     edt.ot_addr
1565                                     + (i*2) - adj);
1566       fprintf (file,
1567               "\t[%4ld] %s\n", (long) ord, name);
1568     }
1569
1570   free (data);
1571
1572   return TRUE;
1573 }
1574
1575 /* This really is architecture dependent.  On IA-64, a .pdata entry
1576    consists of three dwords containing relative virtual addresses that
1577    specify the start and end address of the code range the entry
1578    covers and the address of the corresponding unwind info data.
1579
1580    On ARM and SH-4, a compressed PDATA structure is used :
1581    _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1582    _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1583    See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1584
1585    This is the version for uncompressed data.  */
1586
1587 static bfd_boolean
1588 pe_print_pdata (bfd * abfd, void * vfile)
1589 {
1590 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1591 # define PDATA_ROW_SIZE (3 * 8)
1592 #else
1593 # define PDATA_ROW_SIZE (5 * 4)
1594 #endif
1595   FILE *file = (FILE *) vfile;
1596   bfd_byte *data = 0;
1597   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1598   bfd_size_type datasize = 0;
1599   bfd_size_type i;
1600   bfd_size_type start, stop;
1601   int onaline = PDATA_ROW_SIZE;
1602
1603   if (section == NULL
1604       || coff_section_data (abfd, section) == NULL
1605       || pei_section_data (abfd, section) == NULL)
1606     return TRUE;
1607
1608   stop = pei_section_data (abfd, section)->virt_size;
1609   if ((stop % onaline) != 0)
1610     fprintf (file,
1611              _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1612              (long) stop, onaline);
1613
1614   fprintf (file,
1615            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1616 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1617   fprintf (file,
1618            _(" vma:\t\t\tBegin Address    End Address      Unwind Info\n"));
1619 #else
1620   fprintf (file, _("\
1621  vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n\
1622      \t\tAddress  Address  Handler  Data     Address    Mask\n"));
1623 #endif
1624
1625   datasize = section->size;
1626   if (datasize == 0)
1627     return TRUE;
1628
1629   if (! bfd_malloc_and_get_section (abfd, section, &data))
1630     {
1631       if (data != NULL)
1632         free (data);
1633       return FALSE;
1634     }
1635
1636   start = 0;
1637
1638   for (i = start; i < stop; i += onaline)
1639     {
1640       bfd_vma begin_addr;
1641       bfd_vma end_addr;
1642       bfd_vma eh_handler;
1643       bfd_vma eh_data;
1644       bfd_vma prolog_end_addr;
1645 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1646       int em_data;
1647 #endif
1648
1649       if (i + PDATA_ROW_SIZE > stop)
1650         break;
1651
1652       begin_addr      = GET_PDATA_ENTRY (abfd, data + i     );
1653       end_addr        = GET_PDATA_ENTRY (abfd, data + i +  4);
1654       eh_handler      = GET_PDATA_ENTRY (abfd, data + i +  8);
1655       eh_data         = GET_PDATA_ENTRY (abfd, data + i + 12);
1656       prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1657
1658       if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1659           && eh_data == 0 && prolog_end_addr == 0)
1660         /* We are probably into the padding of the section now.  */
1661         break;
1662
1663 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1664       em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1665 #endif
1666       eh_handler &= ~(bfd_vma) 0x3;
1667       prolog_end_addr &= ~(bfd_vma) 0x3;
1668
1669       fputc (' ', file);
1670       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1671       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1672       bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1673       bfd_fprintf_vma (abfd, file, eh_handler);
1674 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1675       fputc (' ', file);
1676       bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1677       bfd_fprintf_vma (abfd, file, prolog_end_addr);
1678       fprintf (file, "   %x", em_data);
1679 #endif
1680
1681 #ifdef POWERPC_LE_PE
1682       if (eh_handler == 0 && eh_data != 0)
1683         {
1684           /* Special bits here, although the meaning may be a little
1685              mysterious. The only one I know for sure is 0x03
1686              Code Significance
1687              0x00 None
1688              0x01 Register Save Millicode
1689              0x02 Register Restore Millicode
1690              0x03 Glue Code Sequence.  */
1691           switch (eh_data)
1692             {
1693             case 0x01:
1694               fprintf (file, _(" Register save millicode"));
1695               break;
1696             case 0x02:
1697               fprintf (file, _(" Register restore millicode"));
1698               break;
1699             case 0x03:
1700               fprintf (file, _(" Glue code sequence"));
1701               break;
1702             default:
1703               break;
1704             }
1705         }
1706 #endif
1707       fprintf (file, "\n");
1708     }
1709
1710   free (data);
1711
1712   return TRUE;
1713 #undef PDATA_ROW_SIZE
1714 }
1715
1716 typedef struct sym_cache
1717 {
1718   int        symcount;
1719   asymbol ** syms;
1720 } sym_cache;
1721
1722 static asymbol **
1723 slurp_symtab (bfd *abfd, sym_cache *psc)
1724 {
1725   asymbol ** sy = NULL;
1726   long storage;
1727
1728   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1729     {
1730       psc->symcount = 0;
1731       return NULL;
1732     }
1733
1734   storage = bfd_get_symtab_upper_bound (abfd);
1735   if (storage < 0)
1736     return NULL;
1737   if (storage)
1738     sy = (asymbol **) bfd_malloc (storage);
1739
1740   psc->symcount = bfd_canonicalize_symtab (abfd, sy);
1741   if (psc->symcount < 0)
1742     return NULL;
1743   return sy;
1744 }
1745
1746 static const char *
1747 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
1748 {
1749   int i;
1750
1751   if (psc->syms == 0)
1752     psc->syms = slurp_symtab (abfd, psc);
1753
1754   for (i = 0; i < psc->symcount; i++)
1755     {
1756       if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
1757         return psc->syms[i]->name;
1758     }
1759
1760   return NULL;
1761 }
1762
1763 static void
1764 cleanup_syms (sym_cache *psc)
1765 {
1766   psc->symcount = 0;
1767   free (psc->syms);
1768   psc->syms = NULL;
1769 }
1770
1771 /* This is the version for "compressed" pdata.  */
1772
1773 bfd_boolean
1774 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
1775 {
1776 # define PDATA_ROW_SIZE (2 * 4)
1777   FILE *file = (FILE *) vfile;
1778   bfd_byte *data = NULL;
1779   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1780   bfd_size_type datasize = 0;
1781   bfd_size_type i;
1782   bfd_size_type start, stop;
1783   int onaline = PDATA_ROW_SIZE;
1784   struct sym_cache cache = {0, 0} ;
1785
1786   if (section == NULL
1787       || coff_section_data (abfd, section) == NULL
1788       || pei_section_data (abfd, section) == NULL)
1789     return TRUE;
1790
1791   stop = pei_section_data (abfd, section)->virt_size;
1792   if ((stop % onaline) != 0)
1793     fprintf (file,
1794              _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1795              (long) stop, onaline);
1796
1797   fprintf (file,
1798            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1799
1800   fprintf (file, _("\
1801  vma:\t\tBegin    Prolog   Function Flags    Exception EH\n\
1802      \t\tAddress  Length   Length   32b exc  Handler   Data\n"));
1803
1804   datasize = section->size;
1805   if (datasize == 0)
1806     return TRUE;
1807
1808   if (! bfd_malloc_and_get_section (abfd, section, &data))
1809     {
1810       if (data != NULL)
1811         free (data);
1812       return FALSE;
1813     }
1814
1815   start = 0;
1816
1817   for (i = start; i < stop; i += onaline)
1818     {
1819       bfd_vma begin_addr;
1820       bfd_vma other_data;
1821       bfd_vma prolog_length, function_length;
1822       int flag32bit, exception_flag;
1823       asection *tsection;
1824
1825       if (i + PDATA_ROW_SIZE > stop)
1826         break;
1827
1828       begin_addr = GET_PDATA_ENTRY (abfd, data + i     );
1829       other_data = GET_PDATA_ENTRY (abfd, data + i +  4);
1830
1831       if (begin_addr == 0 && other_data == 0)
1832         /* We are probably into the padding of the section now.  */
1833         break;
1834
1835       prolog_length = (other_data & 0x000000FF);
1836       function_length = (other_data & 0x3FFFFF00) >> 8;
1837       flag32bit = (int)((other_data & 0x40000000) >> 30);
1838       exception_flag = (int)((other_data & 0x80000000) >> 31);
1839
1840       fputc (' ', file);
1841       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1842       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1843       bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
1844       bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
1845       fprintf (file, "%2d  %2d   ", flag32bit, exception_flag);
1846
1847       /* Get the exception handler's address and the data passed from the
1848          .text section. This is really the data that belongs with the .pdata
1849          but got "compressed" out for the ARM and SH4 architectures.  */
1850       tsection = bfd_get_section_by_name (abfd, ".text");
1851       if (tsection && coff_section_data (abfd, tsection)
1852           && pei_section_data (abfd, tsection))
1853         {
1854           bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
1855           bfd_byte *tdata;
1856
1857           tdata = (bfd_byte *) bfd_malloc (8);
1858           if (tdata)
1859             {
1860               if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
1861                 {
1862                   bfd_vma eh, eh_data;
1863
1864                   eh = bfd_get_32 (abfd, tdata);
1865                   eh_data = bfd_get_32 (abfd, tdata + 4);
1866                   fprintf (file, "%08x  ", (unsigned int) eh);
1867                   fprintf (file, "%08x", (unsigned int) eh_data);
1868                   if (eh != 0)
1869                     {
1870                       const char *s = my_symbol_for_address (abfd, eh, &cache);
1871
1872                       if (s)
1873                         fprintf (file, " (%s) ", s);
1874                     }
1875                 }
1876               free (tdata);
1877             }
1878         }
1879
1880       fprintf (file, "\n");
1881     }
1882
1883   free (data);
1884
1885   cleanup_syms (& cache);
1886
1887   return TRUE;
1888 #undef PDATA_ROW_SIZE
1889 }
1890
1891 \f
1892 #define IMAGE_REL_BASED_HIGHADJ 4
1893 static const char * const tbl[] =
1894 {
1895   "ABSOLUTE",
1896   "HIGH",
1897   "LOW",
1898   "HIGHLOW",
1899   "HIGHADJ",
1900   "MIPS_JMPADDR",
1901   "SECTION",
1902   "REL32",
1903   "RESERVED1",
1904   "MIPS_JMPADDR16",
1905   "DIR64",
1906   "HIGH3ADJ",
1907   "UNKNOWN",   /* MUST be last.  */
1908 };
1909
1910 static bfd_boolean
1911 pe_print_reloc (bfd * abfd, void * vfile)
1912 {
1913   FILE *file = (FILE *) vfile;
1914   bfd_byte *data = 0;
1915   asection *section = bfd_get_section_by_name (abfd, ".reloc");
1916   bfd_size_type i;
1917   bfd_size_type start, stop;
1918
1919   if (section == NULL)
1920     return TRUE;
1921
1922   if (section->size == 0)
1923     return TRUE;
1924
1925   fprintf (file,
1926            _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1927
1928   if (! bfd_malloc_and_get_section (abfd, section, &data))
1929     {
1930       if (data != NULL)
1931         free (data);
1932       return FALSE;
1933     }
1934
1935   start = 0;
1936
1937   stop = section->size;
1938
1939   for (i = start; i < stop;)
1940     {
1941       int j;
1942       bfd_vma virtual_address;
1943       long number, size;
1944
1945       /* The .reloc section is a sequence of blocks, with a header consisting
1946          of two 32 bit quantities, followed by a number of 16 bit entries.  */
1947       virtual_address = bfd_get_32 (abfd, data+i);
1948       size = bfd_get_32 (abfd, data+i+4);
1949       number = (size - 8) / 2;
1950
1951       if (size == 0)
1952         break;
1953
1954       fprintf (file,
1955                _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1956                (unsigned long) virtual_address, size, (unsigned long) size, number);
1957
1958       for (j = 0; j < number; ++j)
1959         {
1960           unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1961           unsigned int t = (e & 0xF000) >> 12;
1962           int off = e & 0x0FFF;
1963
1964           if (t >= sizeof (tbl) / sizeof (tbl[0]))
1965             t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1966
1967           fprintf (file,
1968                    _("\treloc %4d offset %4x [%4lx] %s"),
1969                    j, off, (unsigned long) (off + virtual_address), tbl[t]);
1970
1971           /* HIGHADJ takes an argument, - the next record *is* the
1972              low 16 bits of addend.  */
1973           if (t == IMAGE_REL_BASED_HIGHADJ)
1974             {
1975               fprintf (file, " (%4x)",
1976                        ((unsigned int)
1977                         bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1978               j++;
1979             }
1980
1981           fprintf (file, "\n");
1982         }
1983
1984       i += size;
1985     }
1986
1987   free (data);
1988
1989   return TRUE;
1990 }
1991
1992 /* Print out the program headers.  */
1993
1994 bfd_boolean
1995 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
1996 {
1997   FILE *file = (FILE *) vfile;
1998   int j;
1999   pe_data_type *pe = pe_data (abfd);
2000   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2001   const char *subsystem_name = NULL;
2002   const char *name;
2003
2004   /* The MS dumpbin program reportedly ands with 0xff0f before
2005      printing the characteristics field.  Not sure why.  No reason to
2006      emulate it here.  */
2007   fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2008 #undef PF
2009 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2010   PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2011   PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2012   PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2013   PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2014   PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2015   PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2016   PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2017   PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2018   PF (IMAGE_FILE_SYSTEM, "system file");
2019   PF (IMAGE_FILE_DLL, "DLL");
2020   PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2021 #undef PF
2022
2023   /* ctime implies '\n'.  */
2024   {
2025     time_t t = pe->coff.timestamp;
2026     fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2027   }
2028
2029 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2030 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2031 #endif
2032 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2033 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2034 #endif
2035 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2036 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2037 #endif
2038
2039   switch (i->Magic)
2040     {
2041     case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2042       name = "PE32";
2043       break;
2044     case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2045       name = "PE32+";
2046       break;
2047     case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2048       name = "ROM";
2049       break;
2050     default:
2051       name = NULL;
2052       break;
2053     }
2054   fprintf (file, "Magic\t\t\t%04x", i->Magic);
2055   if (name)
2056     fprintf (file, "\t(%s)",name);
2057   fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2058   fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2059   fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2060   fprintf (file, "SizeOfInitializedData\t%08lx\n",
2061            (unsigned long) i->SizeOfInitializedData);
2062   fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2063            (unsigned long) i->SizeOfUninitializedData);
2064   fprintf (file, "AddressOfEntryPoint\t");
2065   bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2066   fprintf (file, "\nBaseOfCode\t\t");
2067   bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2068 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2069   /* PE32+ does not have BaseOfData member!  */
2070   fprintf (file, "\nBaseOfData\t\t");
2071   bfd_fprintf_vma (abfd, file, i->BaseOfData);
2072 #endif
2073
2074   fprintf (file, "\nImageBase\t\t");
2075   bfd_fprintf_vma (abfd, file, i->ImageBase);
2076   fprintf (file, "\nSectionAlignment\t");
2077   bfd_fprintf_vma (abfd, file, i->SectionAlignment);
2078   fprintf (file, "\nFileAlignment\t\t");
2079   bfd_fprintf_vma (abfd, file, i->FileAlignment);
2080   fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2081   fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2082   fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2083   fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2084   fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2085   fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2086   fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2087   fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2088   fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2089   fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2090
2091   switch (i->Subsystem)
2092     {
2093     case IMAGE_SUBSYSTEM_UNKNOWN:
2094       subsystem_name = "unspecified";
2095       break;
2096     case IMAGE_SUBSYSTEM_NATIVE:
2097       subsystem_name = "NT native";
2098       break;
2099     case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2100       subsystem_name = "Windows GUI";
2101       break;
2102     case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2103       subsystem_name = "Windows CUI";
2104       break;
2105     case IMAGE_SUBSYSTEM_POSIX_CUI:
2106       subsystem_name = "POSIX CUI";
2107       break;
2108     case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2109       subsystem_name = "Wince CUI";
2110       break;
2111     // These are from UEFI Platform Initialization Specification 1.1.
2112     case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2113       subsystem_name = "EFI application";
2114       break;
2115     case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2116       subsystem_name = "EFI boot service driver";
2117       break;
2118     case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2119       subsystem_name = "EFI runtime driver";
2120       break;
2121     case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2122       subsystem_name = "SAL runtime driver";
2123       break;
2124     // This is from revision 8.0 of the MS PE/COFF spec
2125     case IMAGE_SUBSYSTEM_XBOX:
2126       subsystem_name = "XBOX";
2127       break;
2128     // Added default case for clarity - subsystem_name is NULL anyway.
2129     default:
2130       subsystem_name = NULL;
2131     }
2132
2133   fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2134   if (subsystem_name)
2135     fprintf (file, "\t(%s)", subsystem_name);
2136   fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2137   fprintf (file, "SizeOfStackReserve\t");
2138   bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
2139   fprintf (file, "\nSizeOfStackCommit\t");
2140   bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
2141   fprintf (file, "\nSizeOfHeapReserve\t");
2142   bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
2143   fprintf (file, "\nSizeOfHeapCommit\t");
2144   bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
2145   fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2146   fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2147            (unsigned long) i->NumberOfRvaAndSizes);
2148
2149   fprintf (file, "\nThe Data Directory\n");
2150   for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2151     {
2152       fprintf (file, "Entry %1x ", j);
2153       bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
2154       fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2155       fprintf (file, "%s\n", dir_names[j]);
2156     }
2157
2158   pe_print_idata (abfd, vfile);
2159   pe_print_edata (abfd, vfile);
2160   if (bfd_coff_have_print_pdata (abfd))
2161     bfd_coff_print_pdata (abfd, vfile);
2162   else
2163     pe_print_pdata (abfd, vfile);
2164   pe_print_reloc (abfd, vfile);
2165
2166   return TRUE;
2167 }
2168
2169 /* Copy any private info we understand from the input bfd
2170    to the output bfd.  */
2171
2172 bfd_boolean
2173 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2174 {
2175   pe_data_type *ipe, *ope;
2176
2177   /* One day we may try to grok other private data.  */
2178   if (ibfd->xvec->flavour != bfd_target_coff_flavour
2179       || obfd->xvec->flavour != bfd_target_coff_flavour)
2180     return TRUE;
2181
2182   ipe = pe_data (ibfd);
2183   ope = pe_data (obfd);
2184
2185   /* pe_opthdr is copied in copy_object.  */
2186   ope->dll = ipe->dll;
2187
2188   /* Don't copy input subsystem if output is different from input.  */
2189   if (obfd->xvec != ibfd->xvec)
2190     ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2191
2192   /* For strip: if we removed .reloc, we'll make a real mess of things
2193      if we don't remove this entry as well.  */
2194   if (! pe_data (obfd)->has_reloc_section)
2195     {
2196       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2197       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2198     }
2199
2200   /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2201      But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2202      won't be added.  */
2203   if (! pe_data (ibfd)->has_reloc_section
2204       && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
2205     pe_data (obfd)->dont_strip_reloc = 1;
2206
2207   return TRUE;
2208 }
2209
2210 /* Copy private section data.  */
2211
2212 bfd_boolean
2213 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2214                                        asection *isec,
2215                                        bfd *obfd,
2216                                        asection *osec)
2217 {
2218   if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2219       || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
2220     return TRUE;
2221
2222   if (coff_section_data (ibfd, isec) != NULL
2223       && pei_section_data (ibfd, isec) != NULL)
2224     {
2225       if (coff_section_data (obfd, osec) == NULL)
2226         {
2227           bfd_size_type amt = sizeof (struct coff_section_tdata);
2228           osec->used_by_bfd = bfd_zalloc (obfd, amt);
2229           if (osec->used_by_bfd == NULL)
2230             return FALSE;
2231         }
2232
2233       if (pei_section_data (obfd, osec) == NULL)
2234         {
2235           bfd_size_type amt = sizeof (struct pei_section_tdata);
2236           coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
2237           if (coff_section_data (obfd, osec)->tdata == NULL)
2238             return FALSE;
2239         }
2240
2241       pei_section_data (obfd, osec)->virt_size =
2242         pei_section_data (ibfd, isec)->virt_size;
2243       pei_section_data (obfd, osec)->pe_flags =
2244         pei_section_data (ibfd, isec)->pe_flags;
2245     }
2246
2247   return TRUE;
2248 }
2249
2250 void
2251 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
2252 {
2253   coff_get_symbol_info (abfd, symbol, ret);
2254 }
2255
2256 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
2257 static int
2258 sort_x64_pdata (const void *l, const void *r)
2259 {
2260   const char *lp = (const char *) l;
2261   const char *rp = (const char *) r;
2262   bfd_vma vl, vr;
2263   vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
2264   if (vl != vr)
2265     return (vl < vr ? -1 : 1);
2266   /* We compare just begin address.  */
2267   return 0;
2268 }
2269 #endif
2270
2271 /* Handle the .idata section and other things that need symbol table
2272    access.  */
2273
2274 bfd_boolean
2275 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
2276 {
2277   struct coff_link_hash_entry *h1;
2278   struct bfd_link_info *info = pfinfo->info;
2279   bfd_boolean result = TRUE;
2280
2281   /* There are a few fields that need to be filled in now while we
2282      have symbol table access.
2283
2284      The .idata subsections aren't directly available as sections, but
2285      they are in the symbol table, so get them from there.  */
2286
2287   /* The import directory.  This is the address of .idata$2, with size
2288      of .idata$2 + .idata$3.  */
2289   h1 = coff_link_hash_lookup (coff_hash_table (info),
2290                               ".idata$2", FALSE, FALSE, TRUE);
2291   if (h1 != NULL)
2292     {
2293       /* PR ld/2729: We cannot rely upon all the output sections having been
2294          created properly, so check before referencing them.  Issue a warning
2295          message for any sections tht could not be found.  */
2296       if ((h1->root.type == bfd_link_hash_defined
2297            || h1->root.type == bfd_link_hash_defweak)
2298           && h1->root.u.def.section != NULL
2299           && h1->root.u.def.section->output_section != NULL)
2300         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
2301           (h1->root.u.def.value
2302            + h1->root.u.def.section->output_section->vma
2303            + h1->root.u.def.section->output_offset);
2304       else
2305         {
2306           _bfd_error_handler
2307             (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
2308              abfd);
2309           result = FALSE;
2310         }
2311
2312       h1 = coff_link_hash_lookup (coff_hash_table (info),
2313                                   ".idata$4", FALSE, FALSE, TRUE);
2314       if (h1 != NULL
2315           && (h1->root.type == bfd_link_hash_defined
2316            || h1->root.type == bfd_link_hash_defweak)
2317           && h1->root.u.def.section != NULL
2318           && h1->root.u.def.section->output_section != NULL)
2319         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
2320           ((h1->root.u.def.value
2321             + h1->root.u.def.section->output_section->vma
2322             + h1->root.u.def.section->output_offset)
2323            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
2324       else
2325         {
2326           _bfd_error_handler
2327             (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
2328              abfd);
2329           result = FALSE;
2330         }
2331
2332       /* The import address table.  This is the size/address of
2333          .idata$5.  */
2334       h1 = coff_link_hash_lookup (coff_hash_table (info),
2335                                   ".idata$5", FALSE, FALSE, TRUE);
2336       if (h1 != NULL
2337           && (h1->root.type == bfd_link_hash_defined
2338            || h1->root.type == bfd_link_hash_defweak)
2339           && h1->root.u.def.section != NULL
2340           && h1->root.u.def.section->output_section != NULL)
2341         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
2342           (h1->root.u.def.value
2343            + h1->root.u.def.section->output_section->vma
2344            + h1->root.u.def.section->output_offset);
2345       else
2346         {
2347           _bfd_error_handler
2348             (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
2349              abfd);
2350           result = FALSE;
2351         }
2352
2353       h1 = coff_link_hash_lookup (coff_hash_table (info),
2354                                   ".idata$6", FALSE, FALSE, TRUE);
2355       if (h1 != NULL
2356           && (h1->root.type == bfd_link_hash_defined
2357            || h1->root.type == bfd_link_hash_defweak)
2358           && h1->root.u.def.section != NULL
2359           && h1->root.u.def.section->output_section != NULL)
2360         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
2361           ((h1->root.u.def.value
2362             + h1->root.u.def.section->output_section->vma
2363             + h1->root.u.def.section->output_offset)
2364            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
2365       else
2366         {
2367           _bfd_error_handler
2368             (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
2369              abfd);
2370           result = FALSE;
2371         }
2372     }
2373   else
2374     {
2375       h1 = coff_link_hash_lookup (coff_hash_table (info),
2376                                   "__IAT_start__", FALSE, FALSE, TRUE);
2377       if (h1 != NULL
2378           && (h1->root.type == bfd_link_hash_defined
2379            || h1->root.type == bfd_link_hash_defweak)
2380           && h1->root.u.def.section != NULL
2381           && h1->root.u.def.section->output_section != NULL)
2382         {
2383           bfd_vma iat_va;
2384
2385           iat_va =
2386             (h1->root.u.def.value
2387              + h1->root.u.def.section->output_section->vma
2388              + h1->root.u.def.section->output_offset);
2389
2390           h1 = coff_link_hash_lookup (coff_hash_table (info),
2391                                       "__IAT_end__", FALSE, FALSE, TRUE);
2392           if (h1 != NULL
2393               && (h1->root.type == bfd_link_hash_defined
2394                || h1->root.type == bfd_link_hash_defweak)
2395               && h1->root.u.def.section != NULL
2396               && h1->root.u.def.section->output_section != NULL)
2397             {
2398               pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
2399                 ((h1->root.u.def.value
2400                   + h1->root.u.def.section->output_section->vma
2401                   + h1->root.u.def.section->output_offset)
2402                  - iat_va);
2403               if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
2404                 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
2405                   iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
2406             }
2407           else
2408             {
2409               _bfd_error_handler
2410                 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
2411                    " because .idata$6 is missing"), abfd);
2412               result = FALSE;
2413             }
2414         }
2415     }
2416
2417   h1 = coff_link_hash_lookup (coff_hash_table (info),
2418                               (bfd_get_symbol_leading_char(abfd) != 0
2419                                ? "__tls_used" : "_tls_used"),
2420                               FALSE, FALSE, TRUE);
2421   if (h1 != NULL)
2422     {
2423       if ((h1->root.type == bfd_link_hash_defined
2424            || h1->root.type == bfd_link_hash_defweak)
2425           && h1->root.u.def.section != NULL
2426           && h1->root.u.def.section->output_section != NULL)
2427         pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
2428           (h1->root.u.def.value
2429            + h1->root.u.def.section->output_section->vma
2430            + h1->root.u.def.section->output_offset
2431            - pe_data (abfd)->pe_opthdr.ImageBase);
2432       else
2433         {
2434           _bfd_error_handler
2435             (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
2436              abfd);
2437           result = FALSE;
2438         }
2439      /* According to PECOFF sepcifications by Microsoft version 8.2
2440         the TLS data directory consists of 4 pointers, followed
2441         by two 4-byte integer. This implies that the total size
2442         is different for 32-bit and 64-bit executables.  */
2443 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2444       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
2445 #else
2446       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
2447 #endif
2448     }
2449
2450 /* If there is a .pdata section and we have linked pdata finally, we
2451      need to sort the entries ascending.  */
2452 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
2453   {
2454     asection *sec = bfd_get_section_by_name (abfd, ".pdata");
2455
2456     if (sec)
2457       {
2458         bfd_size_type x = sec->rawsize;
2459         bfd_byte *tmp_data = NULL;
2460
2461         if (x)
2462           tmp_data = bfd_malloc (x);
2463
2464         if (tmp_data != NULL)
2465           {
2466             if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
2467               {
2468                 qsort (tmp_data,
2469                        (size_t) (x / 12),
2470                        12, sort_x64_pdata);
2471                 bfd_set_section_contents (pfinfo->output_bfd, sec,
2472                                           tmp_data, 0, x);
2473               }
2474             free (tmp_data);
2475           }
2476       }
2477   }
2478 #endif
2479
2480   /* If we couldn't find idata$2, we either have an excessively
2481      trivial program or are in DEEP trouble; we have to assume trivial
2482      program....  */
2483   return result;
2484 }