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  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
  66 /* NOTE: it's strange to be including an architecture specific header
  67    in what's supposed to be general (to PE/PEI) code.  However, that's
  68    where the definitions are, and they don't vary per architecture
  69    within PE/PEI, so we get them from there.  FIXME: The lack of
  70    variance is an assumption which may prove to be incorrect if new
  71    PE/PEI targets are created.  */
  72 #if defined COFF_WITH_pex64
  73 # include "coff/x86_64.h"
  74 #elif defined COFF_WITH_pep
  75 # include "coff/ia64.h"
  76 #else
  77 # include "coff/i386.h"
  78 #endif
  79
  80 #include "coff/pe.h"
  81 #include "libcoff.h"
  82 #include "libpei.h"
  83
  84 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
  85 # undef AOUTSZ
  86 # define AOUTSZ         PEPAOUTSZ
  87 # define PEAOUTHDR      PEPAOUTHDR
  88 #endif
  89
  90 /* FIXME: This file has various tests of POWERPC_LE_PE.  Those tests
  91    worked when the code was in peicode.h, but no longer work now that
  92    the code is in peigen.c.  PowerPC NT is said to be dead.  If
  93    anybody wants to revive the code, you will have to figure out how
  94    to handle those issues.  */
  95 \f
  96 void
  97 _bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1)
  98 {
  99   SYMENT *ext = (SYMENT *) ext1;
 100   struct internal_syment *in = (struct internal_syment *) in1;
 101
 102   if (ext->e.e_name[0] == 0)
 103     {
 104       in->_n._n_n._n_zeroes = 0;
 105       in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
 106     }
 107   else
 108     memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
 109
 110   in->n_value = H_GET_32 (abfd, ext->e_value);
 111   in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
 112
 113   if (sizeof (ext->e_type) == 2)
 114     in->n_type = H_GET_16 (abfd, ext->e_type);
 115   else
 116     in->n_type = H_GET_32 (abfd, ext->e_type);
 117
 118   in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
 119   in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
 120
 121 #ifndef STRICT_PE_FORMAT
 122   /* This is for Gnu-created DLLs.  */
 123
 124   /* The section symbols for the .idata$ sections have class 0x68
 125      (C_SECTION), which MS documentation indicates is a section
 126      symbol.  Unfortunately, the value field in the symbol is simply a
 127      copy of the .idata section's flags rather than something useful.
 128      When these symbols are encountered, change the value to 0 so that
 129      they will be handled somewhat correctly in the bfd code.  */
 130   if (in->n_sclass == C_SECTION)
 131     {
 132       char namebuf[SYMNMLEN + 1];
 133       const char *name = NULL;
 134
 135       in->n_value = 0x0;
 136
 137       /* Create synthetic empty sections as needed.  DJ */
 138       if (in->n_scnum == 0)
 139         {
 140           asection *sec;
 141
 142           name = _bfd_coff_internal_syment_name (abfd, in, namebuf);
 143           if (name == NULL)
 144             /* FIXME: Return error.  */
 145             abort ();
 146           sec = bfd_get_section_by_name (abfd, name);
 147           if (sec != NULL)
 148             in->n_scnum = sec->target_index;
 149         }
 150
 151       if (in->n_scnum == 0)
 152         {
 153           int unused_section_number = 0;
 154           asection *sec;
 155           flagword flags;
 156
 157           for (sec = abfd->sections; sec; sec = sec->next)
 158             if (unused_section_number <= sec->target_index)
 159               unused_section_number = sec->target_index + 1;
 160
 161           if (name == namebuf)
 162             {
 163               name = (const char *) bfd_alloc (abfd, strlen (namebuf) + 1);
 164               if (name == NULL)
 165                 /* FIXME: Return error.  */
 166                 abort ();
 167               strcpy ((char *) name, namebuf);
 168             }
 169           flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
 170           sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
 171           if (sec == NULL)
 172             /* FIXME: Return error.  */
 173             abort ();
 174
 175           sec->vma = 0;
 176           sec->lma = 0;
 177           sec->size = 0;
 178           sec->filepos = 0;
 179           sec->rel_filepos = 0;
 180           sec->reloc_count = 0;
 181           sec->line_filepos = 0;
 182           sec->lineno_count = 0;
 183           sec->userdata = NULL;
 184           sec->next = NULL;
 185           sec->alignment_power = 2;
 186
 187           sec->target_index = unused_section_number;
 188
 189           in->n_scnum = unused_section_number;
 190         }
 191       in->n_sclass = C_STAT;
 192     }
 193 #endif
 194
 195 #ifdef coff_swap_sym_in_hook
 196   /* This won't work in peigen.c, but since it's for PPC PE, it's not
 197      worth fixing.  */
 198   coff_swap_sym_in_hook (abfd, ext1, in1);
 199 #endif
 200 }
 201
 202 unsigned int
 203 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
 204 {
 205   struct internal_syment *in = (struct internal_syment *) inp;
 206   SYMENT *ext = (SYMENT *) extp;
 207
 208   if (in->_n._n_name[0] == 0)
 209     {
 210       H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
 211       H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
 212     }
 213   else
 214     memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
 215
 216   H_PUT_32 (abfd, in->n_value, ext->e_value);
 217   H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
 218
 219   if (sizeof (ext->e_type) == 2)
 220     H_PUT_16 (abfd, in->n_type, ext->e_type);
 221   else
 222     H_PUT_32 (abfd, in->n_type, ext->e_type);
 223
 224   H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
 225   H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
 226
 227   return SYMESZ;
 228 }
 229
 230 void
 231 _bfd_XXi_swap_aux_in (bfd *     abfd,
 232                       void *    ext1,
 233                       int       type,
 234                       int       in_class,
 235                       int       indx ATTRIBUTE_UNUSED,
 236                       int       numaux ATTRIBUTE_UNUSED,
 237                       void *    in1)
 238 {
 239   AUXENT *ext = (AUXENT *) ext1;
 240   union internal_auxent *in = (union internal_auxent *) in1;
 241
 242   switch (in_class)
 243     {
 244     case C_FILE:
 245       if (ext->x_file.x_fname[0] == 0)
 246         {
 247           in->x_file.x_n.x_zeroes = 0;
 248           in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
 249         }
 250       else
 251         memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
 252       return;
 253
 254     case C_STAT:
 255     case C_LEAFSTAT:
 256     case C_HIDDEN:
 257       if (type == T_NULL)
 258         {
 259           in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
 260           in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
 261           in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
 262           in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
 263           in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
 264           in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
 265           return;
 266         }
 267       break;
 268     }
 269
 270   in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
 271   in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
 272
 273   if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
 274       || ISTAG (in_class))
 275     {
 276       in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
 277       in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
 278     }
 279   else
 280     {
 281       in->x_sym.x_fcnary.x_ary.x_dimen[0] =
 282         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 283       in->x_sym.x_fcnary.x_ary.x_dimen[1] =
 284         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 285       in->x_sym.x_fcnary.x_ary.x_dimen[2] =
 286         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 287       in->x_sym.x_fcnary.x_ary.x_dimen[3] =
 288         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 289     }
 290
 291   if (ISFCN (type))
 292     {
 293       in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
 294     }
 295   else
 296     {
 297       in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
 298       in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
 299     }
 300 }
 301
 302 unsigned int
 303 _bfd_XXi_swap_aux_out (bfd *  abfd,
 304                        void * inp,
 305                        int    type,
 306                        int    in_class,
 307                        int    indx ATTRIBUTE_UNUSED,
 308                        int    numaux ATTRIBUTE_UNUSED,
 309                        void * extp)
 310 {
 311   union internal_auxent *in = (union internal_auxent *) inp;
 312   AUXENT *ext = (AUXENT *) extp;
 313
 314   memset (ext, 0, AUXESZ);
 315
 316   switch (in_class)
 317     {
 318     case C_FILE:
 319       if (in->x_file.x_fname[0] == 0)
 320         {
 321           H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
 322           H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
 323         }
 324       else
 325         memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
 326
 327       return AUXESZ;
 328
 329     case C_STAT:
 330     case C_LEAFSTAT:
 331     case C_HIDDEN:
 332       if (type == T_NULL)
 333         {
 334           PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
 335           PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
 336           PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
 337           H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
 338           H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
 339           H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
 340           return AUXESZ;
 341         }
 342       break;
 343     }
 344
 345   H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
 346   H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
 347
 348   if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
 349       || ISTAG (in_class))
 350     {
 351       PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,  ext);
 352       PUT_FCN_ENDNDX  (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
 353     }
 354   else
 355     {
 356       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
 357                 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 358       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
 359                 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 360       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
 361                 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 362       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
 363                 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 364     }
 365
 366   if (ISFCN (type))
 367     H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
 368   else
 369     {
 370       PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
 371       PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
 372     }
 373
 374   return AUXESZ;
 375 }
 376
 377 void
 378 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
 379 {
 380   LINENO *ext = (LINENO *) ext1;
 381   struct internal_lineno *in = (struct internal_lineno *) in1;
 382
 383   in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
 384   in->l_lnno = GET_LINENO_LNNO (abfd, ext);
 385 }
 386
 387 unsigned int
 388 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
 389 {
 390   struct internal_lineno *in = (struct internal_lineno *) inp;
 391   struct external_lineno *ext = (struct external_lineno *) outp;
 392   H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
 393
 394   PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
 395   return LINESZ;
 396 }
 397
 398 void
 399 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
 400                           void * aouthdr_ext1,
 401                           void * aouthdr_int1)
 402 {
 403   PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
 404   AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
 405   struct internal_aouthdr *aouthdr_int
 406     = (struct internal_aouthdr *) aouthdr_int1;
 407   struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
 408
 409   aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
 410   aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
 411   aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
 412   aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
 413   aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
 414   aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
 415   aouthdr_int->text_start =
 416     GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
 417 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 418   /* PE32+ does not have data_start member!  */
 419   aouthdr_int->data_start =
 420     GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
 421   a->BaseOfData = aouthdr_int->data_start;
 422 #endif
 423
 424   a->Magic = aouthdr_int->magic;
 425   a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
 426   a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
 427   a->SizeOfCode = aouthdr_int->tsize ;
 428   a->SizeOfInitializedData = aouthdr_int->dsize ;
 429   a->SizeOfUninitializedData = aouthdr_int->bsize ;
 430   a->AddressOfEntryPoint = aouthdr_int->entry;
 431   a->BaseOfCode = aouthdr_int->text_start;
 432   a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
 433   a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
 434   a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
 435   a->MajorOperatingSystemVersion =
 436     H_GET_16 (abfd, src->MajorOperatingSystemVersion);
 437   a->MinorOperatingSystemVersion =
 438     H_GET_16 (abfd, src->MinorOperatingSystemVersion);
 439   a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
 440   a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
 441   a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
 442   a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
 443   a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
 444   a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
 445   a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
 446   a->CheckSum = H_GET_32 (abfd, src->CheckSum);
 447   a->Subsystem = H_GET_16 (abfd, src->Subsystem);
 448   a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
 449   a->SizeOfStackReserve =
 450     GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
 451   a->SizeOfStackCommit =
 452     GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
 453   a->SizeOfHeapReserve =
 454     GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
 455   a->SizeOfHeapCommit =
 456     GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
 457   a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
 458   a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
 459
 460   {
 461     int idx;
 462
 463     for (idx = 0; idx < 16; idx++)
 464       {
 465         /* If data directory is empty, rva also should be 0.  */
 466         int size =
 467           H_GET_32 (abfd, src->DataDirectory[idx][1]);
 468
 469         a->DataDirectory[idx].Size = size;
 470
 471         if (size)
 472           a->DataDirectory[idx].VirtualAddress =
 473             H_GET_32 (abfd, src->DataDirectory[idx][0]);
 474         else
 475           a->DataDirectory[idx].VirtualAddress = 0;
 476       }
 477   }
 478
 479   if (aouthdr_int->entry)
 480     {
 481       aouthdr_int->entry += a->ImageBase;
 482 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 483       aouthdr_int->entry &= 0xffffffff;
 484 #endif
 485     }
 486
 487   if (aouthdr_int->tsize)
 488     {
 489       aouthdr_int->text_start += a->ImageBase;
 490 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 491       aouthdr_int->text_start &= 0xffffffff;
 492 #endif
 493     }
 494
 495 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 496   /* PE32+ does not have data_start member!  */
 497   if (aouthdr_int->dsize)
 498     {
 499       aouthdr_int->data_start += a->ImageBase;
 500       aouthdr_int->data_start &= 0xffffffff;
 501     }
 502 #endif
 503
 504 #ifdef POWERPC_LE_PE
 505   /* These three fields are normally set up by ppc_relocate_section.
 506      In the case of reading a file in, we can pick them up from the
 507      DataDirectory.  */
 508   first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
 509   thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
 510   import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
 511 #endif
 512 }
 513
 514 /* A support function for below.  */
 515
 516 static void
 517 add_data_entry (bfd * abfd,
 518                 struct internal_extra_pe_aouthdr *aout,
 519                 int idx,
 520                 char *name,
 521                 bfd_vma base)
 522 {
 523   asection *sec = bfd_get_section_by_name (abfd, name);
 524
 525   /* Add import directory information if it exists.  */
 526   if ((sec != NULL)
 527       && (coff_section_data (abfd, sec) != NULL)
 528       && (pei_section_data (abfd, sec) != NULL))
 529     {
 530       /* If data directory is empty, rva also should be 0.  */
 531       int size = pei_section_data (abfd, sec)->virt_size;
 532       aout->DataDirectory[idx].Size = size;
 533
 534       if (size)
 535         {
 536           aout->DataDirectory[idx].VirtualAddress =
 537             (sec->vma - base) & 0xffffffff;
 538           sec->flags |= SEC_DATA;
 539         }
 540     }
 541 }
 542
 543 unsigned int
 544 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
 545 {
 546   struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
 547   pe_data_type *pe = pe_data (abfd);
 548   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
 549   PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
 550   bfd_vma sa, fa, ib;
 551   IMAGE_DATA_DIRECTORY idata2, idata5, tls;
 552
 553   sa = extra->SectionAlignment;
 554   fa = extra->FileAlignment;
 555   ib = extra->ImageBase;
 556
 557   idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
 558   idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
 559   tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
 560
 561   if (aouthdr_in->tsize)
 562     {
 563       aouthdr_in->text_start -= ib;
 564 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 565       aouthdr_in->text_start &= 0xffffffff;
 566 #endif
 567     }
 568
 569   if (aouthdr_in->dsize)
 570     {
 571       aouthdr_in->data_start -= ib;
 572 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 573       aouthdr_in->data_start &= 0xffffffff;
 574 #endif
 575     }
 576
 577   if (aouthdr_in->entry)
 578     {
 579       aouthdr_in->entry -= ib;
 580 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 581       aouthdr_in->entry &= 0xffffffff;
 582 #endif
 583     }
 584
 585 #define FA(x) (((x) + fa -1 ) & (- fa))
 586 #define SA(x) (((x) + sa -1 ) & (- sa))
 587
 588   /* We like to have the sizes aligned.  */
 589   aouthdr_in->bsize = FA (aouthdr_in->bsize);
 590
 591   extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
 592
 593   /* First null out all data directory entries.  */
 594   memset (extra->DataDirectory, 0, sizeof (extra->DataDirectory));
 595
 596   add_data_entry (abfd, extra, 0, ".edata", ib);
 597   add_data_entry (abfd, extra, 2, ".rsrc", ib);
 598   add_data_entry (abfd, extra, 3, ".pdata", ib);
 599
 600   /* In theory we do not need to call add_data_entry for .idata$2 or
 601      .idata$5.  It will be done in bfd_coff_final_link where all the
 602      required information is available.  If however, we are not going
 603      to perform a final link, eg because we have been invoked by objcopy
 604      or strip, then we need to make sure that these Data Directory
 605      entries are initialised properly.
 606
 607      So - we copy the input values into the output values, and then, if
 608      a final link is going to be performed, it can overwrite them.  */
 609   extra->DataDirectory[PE_IMPORT_TABLE]  = idata2;
 610   extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
 611   extra->DataDirectory[PE_TLS_TABLE] = tls;
 612
 613   if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
 614     /* Until other .idata fixes are made (pending patch), the entry for
 615        .idata is needed for backwards compatibility.  FIXME.  */
 616     add_data_entry (abfd, extra, 1, ".idata", ib);
 617
 618   /* For some reason, the virtual size (which is what's set by
 619      add_data_entry) for .reloc is not the same as the size recorded
 620      in this slot by MSVC; it doesn't seem to cause problems (so far),
 621      but since it's the best we've got, use it.  It does do the right
 622      thing for .pdata.  */
 623   if (pe->has_reloc_section)
 624     add_data_entry (abfd, extra, 5, ".reloc", ib);
 625
 626   {
 627     asection *sec;
 628     bfd_vma hsize = 0;
 629     bfd_vma dsize = 0;
 630     bfd_vma isize = 0;
 631     bfd_vma tsize = 0;
 632
 633     for (sec = abfd->sections; sec; sec = sec->next)
 634       {
 635         int rounded = FA (sec->size);
 636
 637         /* The first non-zero section filepos is the header size.
 638            Sections without contents will have a filepos of 0.  */
 639         if (hsize == 0)
 640           hsize = sec->filepos;
 641         if (sec->flags & SEC_DATA)
 642           dsize += rounded;
 643         if (sec->flags & SEC_CODE)
 644           tsize += rounded;
 645         /* The image size is the total VIRTUAL size (which is what is
 646            in the virt_size field).  Files have been seen (from MSVC
 647            5.0 link.exe) where the file size of the .data segment is
 648            quite small compared to the virtual size.  Without this
 649            fix, strip munges the file.
 650
 651            FIXME: We need to handle holes between sections, which may
 652            happpen when we covert from another format.  We just use
 653            the virtual address and virtual size of the last section
 654            for the image size.  */
 655         if (coff_section_data (abfd, sec) != NULL
 656             && pei_section_data (abfd, sec) != NULL)
 657           isize = (sec->vma - extra->ImageBase
 658                    + SA (FA (pei_section_data (abfd, sec)->virt_size)));
 659       }
 660
 661     aouthdr_in->dsize = dsize;
 662     aouthdr_in->tsize = tsize;
 663     extra->SizeOfHeaders = hsize;
 664     extra->SizeOfImage = isize;
 665   }
 666
 667   H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
 668
 669 #define LINKER_VERSION 256 /* That is, 2.56 */
 670
 671   /* This piece of magic sets the "linker version" field to
 672      LINKER_VERSION.  */
 673   H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
 674             aouthdr_out->standard.vstamp);
 675
 676   PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
 677   PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
 678   PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
 679   PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
 680   PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
 681                           aouthdr_out->standard.text_start);
 682
 683 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 684   /* PE32+ does not have data_start member!  */
 685   PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
 686                           aouthdr_out->standard.data_start);
 687 #endif
 688
 689   PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
 690   H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
 691   H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
 692   H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
 693             aouthdr_out->MajorOperatingSystemVersion);
 694   H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
 695             aouthdr_out->MinorOperatingSystemVersion);
 696   H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
 697   H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
 698   H_PUT_16 (abfd, extra->MajorSubsystemVersion,
 699             aouthdr_out->MajorSubsystemVersion);
 700   H_PUT_16 (abfd, extra->MinorSubsystemVersion,
 701             aouthdr_out->MinorSubsystemVersion);
 702   H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
 703   H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
 704   H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
 705   H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
 706   H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
 707   H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
 708   PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
 709                                     aouthdr_out->SizeOfStackReserve);
 710   PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
 711                                    aouthdr_out->SizeOfStackCommit);
 712   PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
 713                                    aouthdr_out->SizeOfHeapReserve);
 714   PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
 715                                   aouthdr_out->SizeOfHeapCommit);
 716   H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
 717   H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
 718             aouthdr_out->NumberOfRvaAndSizes);
 719   {
 720     int idx;
 721
 722     for (idx = 0; idx < 16; idx++)
 723       {
 724         H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
 725                   aouthdr_out->DataDirectory[idx][0]);
 726         H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
 727                   aouthdr_out->DataDirectory[idx][1]);
 728       }
 729   }
 730
 731   return AOUTSZ;
 732 }
 733
 734 unsigned int
 735 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
 736 {
 737   int idx;
 738   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 739   struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
 740
 741   if (pe_data (abfd)->has_reloc_section)
 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   datasize -= dataoff;
1111
1112 #ifdef POWERPC_LE_PE
1113   if (rel_section != 0 && rel_section->size != 0)
1114     {
1115       /* The toc address can be found by taking the starting address,
1116          which on the PPC locates a function descriptor. The
1117          descriptor consists of the function code starting address
1118          followed by the address of the toc. The starting address we
1119          get from the bfd, and the descriptor is supposed to be in the
1120          .reldata section.  */
1121
1122       bfd_vma loadable_toc_address;
1123       bfd_vma toc_address;
1124       bfd_vma start_address;
1125       bfd_byte *data;
1126       bfd_vma offset;
1127
1128       if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1129         {
1130           if (data != NULL)
1131             free (data);
1132           return FALSE;
1133         }
1134
1135       offset = abfd->start_address - rel_section->vma;
1136
1137       if (offset >= rel_section->size || offset + 8 > rel_section->size)
1138         {
1139           if (data != NULL)
1140             free (data);
1141           return FALSE;
1142         }
1143
1144       start_address = bfd_get_32 (abfd, data + offset);
1145       loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1146       toc_address = loadable_toc_address - 32768;
1147
1148       fprintf (file,
1149                _("\nFunction descriptor located at the start address: %04lx\n"),
1150                (unsigned long int) (abfd->start_address));
1151       fprintf (file,
1152                _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1153                start_address, loadable_toc_address, toc_address);
1154       if (data != NULL)
1155         free (data);
1156     }
1157   else
1158     {
1159       fprintf (file,
1160                _("\nNo reldata section! Function descriptor not decoded.\n"));
1161     }
1162 #endif
1163
1164   fprintf (file,
1165            _("\nThe Import Tables (interpreted %s section contents)\n"),
1166            section->name);
1167   fprintf (file,
1168            _("\
1169  vma:            Hint    Time      Forward  DLL       First\n\
1170                  Table   Stamp     Chain    Name      Thunk\n"));
1171
1172   /* Read the whole section.  Some of the fields might be before dataoff.  */
1173   if (!bfd_malloc_and_get_section (abfd, section, &data))
1174     {
1175       if (data != NULL)
1176         free (data);
1177       return FALSE;
1178     }
1179
1180   adj = section->vma - extra->ImageBase;
1181
1182   /* Print all image import descriptors.  */
1183   for (i = 0; i < datasize; i += onaline)
1184     {
1185       bfd_vma hint_addr;
1186       bfd_vma time_stamp;
1187       bfd_vma forward_chain;
1188       bfd_vma dll_name;
1189       bfd_vma first_thunk;
1190       int idx = 0;
1191       bfd_size_type j;
1192       char *dll;
1193
1194       /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress).  */
1195       fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
1196       hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1197       time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1198       forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1199       dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1200       first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1201
1202       fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1203                (unsigned long) hint_addr,
1204                (unsigned long) time_stamp,
1205                (unsigned long) forward_chain,
1206                (unsigned long) dll_name,
1207                (unsigned long) first_thunk);
1208
1209       if (hint_addr == 0 && first_thunk == 0)
1210         break;
1211
1212       if (dll_name - adj >= section->size)
1213         break;
1214
1215       dll = (char *) data + dll_name - adj;
1216       fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1217
1218       if (hint_addr != 0)
1219         {
1220           bfd_byte *ft_data;
1221           asection *ft_section;
1222           bfd_vma ft_addr;
1223           bfd_size_type ft_datasize;
1224           int ft_idx;
1225           int ft_allocated = 0;
1226
1227           fprintf (file, _("\tvma:  Hint/Ord Member-Name Bound-To\n"));
1228
1229           idx = hint_addr - adj;
1230
1231           ft_addr = first_thunk + extra->ImageBase;
1232           ft_data = data;
1233           ft_idx = first_thunk - adj;
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                   ft_datasize = ft_section->size;
1244                   if (ft_addr >= ft_section->vma
1245                       && ft_addr < ft_section->vma + ft_datasize)
1246                     break;
1247                 }
1248
1249               if (ft_section == NULL)
1250                 {
1251                   fprintf (file,
1252                        _("\nThere is a first thunk, but the section containing it could not be found\n"));
1253                   continue;
1254                 }
1255
1256               /* Now check to see if this section is the same as our current
1257                  section.  If it is not then we will have to load its data in.  */
1258               if (ft_section == section)
1259                 {
1260                   ft_data = data;
1261                   ft_idx = first_thunk - adj;
1262                 }
1263               else
1264                 {
1265                   ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1266                   ft_data = (bfd_byte *) bfd_malloc (datasize);
1267                   if (ft_data == NULL)
1268                     continue;
1269
1270                   /* Read datasize bfd_bytes starting at offset ft_idx.  */
1271                   if (! bfd_get_section_contents
1272                       (abfd, ft_section, ft_data, (bfd_vma) ft_idx, datasize))
1273                     {
1274                       free (ft_data);
1275                       continue;
1276                     }
1277
1278                   ft_idx = 0;
1279                   ft_allocated = 1;
1280                 }
1281             }
1282
1283           /* Print HintName vector entries.  */
1284 #ifdef COFF_WITH_pex64
1285           for (j = 0; j < datasize; j += 8)
1286             {
1287               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1288               unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1289
1290               if (!member && !member_high)
1291                 break;
1292
1293               if (member_high & 0x80000000)
1294                 fprintf (file, "\t%lx%08lx\t %4lx%08lx  <none>",
1295                          member_high,member, member_high & 0x7fffffff, member);
1296               else
1297                 {
1298                   int ordinal;
1299                   char *member_name;
1300
1301                   ordinal = bfd_get_16 (abfd, data + member - adj);
1302                   member_name = (char *) data + member - adj + 2;
1303                   fprintf (file, "\t%04lx\t %4d  %s",member, ordinal, member_name);
1304                 }
1305
1306               /* If the time stamp is not zero, the import address
1307                  table holds actual addresses.  */
1308               if (time_stamp != 0
1309                   && first_thunk != 0
1310                   && first_thunk != hint_addr)
1311                 fprintf (file, "\t%04lx",
1312                          (unsigned long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1313               fprintf (file, "\n");
1314             }
1315 #else
1316           for (j = 0; j < datasize; j += 4)
1317             {
1318               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1319
1320               /* Print single IMAGE_IMPORT_BY_NAME vector.  */
1321               if (member == 0)
1322                 break;
1323
1324               if (member & 0x80000000)
1325                 fprintf (file, "\t%04lx\t %4lu  <none>",
1326                          member, member & 0x7fffffff);
1327               else
1328                 {
1329                   int ordinal;
1330                   char *member_name;
1331
1332                   ordinal = bfd_get_16 (abfd, data + member - adj);
1333                   member_name = (char *) data + member - adj + 2;
1334                   fprintf (file, "\t%04lx\t %4d  %s",
1335                            member, ordinal, member_name);
1336                 }
1337
1338               /* If the time stamp is not zero, the import address
1339                  table holds actual addresses.  */
1340               if (time_stamp != 0
1341                   && first_thunk != 0
1342                   && first_thunk != hint_addr)
1343                 fprintf (file, "\t%04lx",
1344                          (unsigned long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1345
1346               fprintf (file, "\n");
1347             }
1348 #endif
1349           if (ft_allocated)
1350             free (ft_data);
1351         }
1352
1353       fprintf (file, "\n");
1354     }
1355
1356   free (data);
1357
1358   return TRUE;
1359 }
1360
1361 static bfd_boolean
1362 pe_print_edata (bfd * abfd, void * vfile)
1363 {
1364   FILE *file = (FILE *) vfile;
1365   bfd_byte *data;
1366   asection *section;
1367   bfd_size_type datasize = 0;
1368   bfd_size_type dataoff;
1369   bfd_size_type i;
1370   bfd_signed_vma adj;
1371   struct EDT_type
1372   {
1373     long export_flags;          /* Reserved - should be zero.  */
1374     long time_stamp;
1375     short major_ver;
1376     short minor_ver;
1377     bfd_vma name;               /* RVA - relative to image base.  */
1378     long base;                  /* Ordinal base.  */
1379     unsigned long num_functions;/* Number in the export address table.  */
1380     unsigned long num_names;    /* Number in the name pointer table.  */
1381     bfd_vma eat_addr;           /* RVA to the export address table.  */
1382     bfd_vma npt_addr;           /* RVA to the Export Name Pointer Table.  */
1383     bfd_vma ot_addr;            /* RVA to the Ordinal Table.  */
1384   } edt;
1385
1386   pe_data_type *pe = pe_data (abfd);
1387   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1388
1389   bfd_vma addr;
1390
1391   addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1392
1393   if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1394     {
1395       /* Maybe the extra header isn't there.  Look for the section.  */
1396       section = bfd_get_section_by_name (abfd, ".edata");
1397       if (section == NULL)
1398         return TRUE;
1399
1400       addr = section->vma;
1401       dataoff = 0;
1402       datasize = section->size;
1403       if (datasize == 0)
1404         return TRUE;
1405     }
1406   else
1407     {
1408       addr += extra->ImageBase;
1409
1410       for (section = abfd->sections; section != NULL; section = section->next)
1411         if (addr >= section->vma && addr < section->vma + section->size)
1412           break;
1413
1414       if (section == NULL)
1415         {
1416           fprintf (file,
1417                    _("\nThere is an export table, but the section containing it could not be found\n"));
1418           return TRUE;
1419         }
1420
1421       dataoff = addr - section->vma;
1422       datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1423       if (datasize > section->size - dataoff)
1424         {
1425           fprintf (file,
1426                    _("\nThere is an export table in %s, but it does not fit into that section\n"),
1427                    section->name);
1428           return TRUE;
1429         }
1430     }
1431
1432   fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1433            section->name, (unsigned long) addr);
1434
1435   data = (bfd_byte *) bfd_malloc (datasize);
1436   if (data == NULL)
1437     return FALSE;
1438
1439   if (! bfd_get_section_contents (abfd, section, data,
1440                                   (file_ptr) dataoff, datasize))
1441     return FALSE;
1442
1443   /* Go get Export Directory Table.  */
1444   edt.export_flags   = bfd_get_32 (abfd, data +  0);
1445   edt.time_stamp     = bfd_get_32 (abfd, data +  4);
1446   edt.major_ver      = bfd_get_16 (abfd, data +  8);
1447   edt.minor_ver      = bfd_get_16 (abfd, data + 10);
1448   edt.name           = bfd_get_32 (abfd, data + 12);
1449   edt.base           = bfd_get_32 (abfd, data + 16);
1450   edt.num_functions  = bfd_get_32 (abfd, data + 20);
1451   edt.num_names      = bfd_get_32 (abfd, data + 24);
1452   edt.eat_addr       = bfd_get_32 (abfd, data + 28);
1453   edt.npt_addr       = bfd_get_32 (abfd, data + 32);
1454   edt.ot_addr        = bfd_get_32 (abfd, data + 36);
1455
1456   adj = section->vma - extra->ImageBase + dataoff;
1457
1458   /* Dump the EDT first.  */
1459   fprintf (file,
1460            _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1461            section->name);
1462
1463   fprintf (file,
1464            _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1465
1466   fprintf (file,
1467            _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1468
1469   fprintf (file,
1470            _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1471
1472   fprintf (file,
1473            _("Name \t\t\t\t"));
1474   bfd_fprintf_vma (abfd, file, edt.name);
1475   fprintf (file,
1476            " %s\n", data + edt.name - adj);
1477
1478   fprintf (file,
1479            _("Ordinal Base \t\t\t%ld\n"), edt.base);
1480
1481   fprintf (file,
1482            _("Number in:\n"));
1483
1484   fprintf (file,
1485            _("\tExport Address Table \t\t%08lx\n"),
1486            edt.num_functions);
1487
1488   fprintf (file,
1489            _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1490
1491   fprintf (file,
1492            _("Table Addresses\n"));
1493
1494   fprintf (file,
1495            _("\tExport Address Table \t\t"));
1496   bfd_fprintf_vma (abfd, file, edt.eat_addr);
1497   fprintf (file, "\n");
1498
1499   fprintf (file,
1500            _("\tName Pointer Table \t\t"));
1501   bfd_fprintf_vma (abfd, file, edt.npt_addr);
1502   fprintf (file, "\n");
1503
1504   fprintf (file,
1505            _("\tOrdinal Table \t\t\t"));
1506   bfd_fprintf_vma (abfd, file, edt.ot_addr);
1507   fprintf (file, "\n");
1508
1509   /* The next table to find is the Export Address Table. It's basically
1510      a list of pointers that either locate a function in this dll, or
1511      forward the call to another dll. Something like:
1512       typedef union
1513       {
1514         long export_rva;
1515         long forwarder_rva;
1516       } export_address_table_entry;  */
1517
1518   fprintf (file,
1519           _("\nExport Address Table -- Ordinal Base %ld\n"),
1520           edt.base);
1521
1522   for (i = 0; i < edt.num_functions; ++i)
1523     {
1524       bfd_vma eat_member = bfd_get_32 (abfd,
1525                                        data + edt.eat_addr + (i * 4) - adj);
1526       if (eat_member == 0)
1527         continue;
1528
1529       if (eat_member - adj <= datasize)
1530         {
1531           /* This rva is to a name (forwarding function) in our section.  */
1532           /* Should locate a function descriptor.  */
1533           fprintf (file,
1534                    "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1535                    (long) i,
1536                    (long) (i + edt.base),
1537                    (unsigned long) eat_member,
1538                    _("Forwarder RVA"),
1539                    data + eat_member - adj);
1540         }
1541       else
1542         {
1543           /* Should locate a function descriptor in the reldata section.  */
1544           fprintf (file,
1545                    "\t[%4ld] +base[%4ld] %04lx %s\n",
1546                    (long) i,
1547                    (long) (i + edt.base),
1548                    (unsigned long) eat_member,
1549                    _("Export RVA"));
1550         }
1551     }
1552
1553   /* The Export Name Pointer Table is paired with the Export Ordinal Table.  */
1554   /* Dump them in parallel for clarity.  */
1555   fprintf (file,
1556            _("\n[Ordinal/Name Pointer] Table\n"));
1557
1558   for (i = 0; i < edt.num_names; ++i)
1559     {
1560       bfd_vma name_ptr = bfd_get_32 (abfd,
1561                                     data +
1562                                     edt.npt_addr
1563                                     + (i*4) - adj);
1564
1565       char *name = (char *) data + name_ptr - adj;
1566
1567       bfd_vma ord = bfd_get_16 (abfd,
1568                                     data +
1569                                     edt.ot_addr
1570                                     + (i*2) - adj);
1571       fprintf (file,
1572               "\t[%4ld] %s\n", (long) ord, name);
1573     }
1574
1575   free (data);
1576
1577   return TRUE;
1578 }
1579
1580 /* This really is architecture dependent.  On IA-64, a .pdata entry
1581    consists of three dwords containing relative virtual addresses that
1582    specify the start and end address of the code range the entry
1583    covers and the address of the corresponding unwind info data.
1584
1585    On ARM and SH-4, a compressed PDATA structure is used :
1586    _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1587    _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1588    See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1589
1590    This is the version for uncompressed data.  */
1591
1592 static bfd_boolean
1593 pe_print_pdata (bfd * abfd, void * vfile)
1594 {
1595 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1596 # define PDATA_ROW_SIZE (3 * 8)
1597 #else
1598 # define PDATA_ROW_SIZE (5 * 4)
1599 #endif
1600   FILE *file = (FILE *) vfile;
1601   bfd_byte *data = 0;
1602   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1603   bfd_size_type datasize = 0;
1604   bfd_size_type i;
1605   bfd_size_type start, stop;
1606   int onaline = PDATA_ROW_SIZE;
1607
1608   if (section == NULL
1609       || coff_section_data (abfd, section) == NULL
1610       || pei_section_data (abfd, section) == NULL)
1611     return TRUE;
1612
1613   stop = pei_section_data (abfd, section)->virt_size;
1614   if ((stop % onaline) != 0)
1615     fprintf (file,
1616              _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1617              (long) stop, onaline);
1618
1619   fprintf (file,
1620            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1621 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1622   fprintf (file,
1623            _(" vma:\t\t\tBegin Address    End Address      Unwind Info\n"));
1624 #else
1625   fprintf (file, _("\
1626  vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n\
1627      \t\tAddress  Address  Handler  Data     Address    Mask\n"));
1628 #endif
1629
1630   datasize = section->size;
1631   if (datasize == 0)
1632     return TRUE;
1633
1634   if (! bfd_malloc_and_get_section (abfd, section, &data))
1635     {
1636       if (data != NULL)
1637         free (data);
1638       return FALSE;
1639     }
1640
1641   start = 0;
1642
1643   for (i = start; i < stop; i += onaline)
1644     {
1645       bfd_vma begin_addr;
1646       bfd_vma end_addr;
1647       bfd_vma eh_handler;
1648       bfd_vma eh_data;
1649       bfd_vma prolog_end_addr;
1650       int em_data;
1651
1652       if (i + PDATA_ROW_SIZE > stop)
1653         break;
1654
1655       begin_addr      = GET_PDATA_ENTRY (abfd, data + i     );
1656       end_addr        = GET_PDATA_ENTRY (abfd, data + i +  4);
1657       eh_handler      = GET_PDATA_ENTRY (abfd, data + i +  8);
1658       eh_data         = GET_PDATA_ENTRY (abfd, data + i + 12);
1659       prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1660
1661       if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1662           && eh_data == 0 && prolog_end_addr == 0)
1663         /* We are probably into the padding of the section now.  */
1664         break;
1665
1666       em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1667       eh_handler &= ~(bfd_vma) 0x3;
1668       prolog_end_addr &= ~(bfd_vma) 0x3;
1669
1670       fputc (' ', file);
1671       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1672       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1673       bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1674       bfd_fprintf_vma (abfd, file, eh_handler);
1675 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1676       fputc (' ', file);
1677       bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1678       bfd_fprintf_vma (abfd, file, prolog_end_addr);
1679       fprintf (file, "   %x", em_data);
1680 #endif
1681
1682 #ifdef POWERPC_LE_PE
1683       if (eh_handler == 0 && eh_data != 0)
1684         {
1685           /* Special bits here, although the meaning may be a little
1686              mysterious. The only one I know for sure is 0x03
1687              Code Significance
1688              0x00 None
1689              0x01 Register Save Millicode
1690              0x02 Register Restore Millicode
1691              0x03 Glue Code Sequence.  */
1692           switch (eh_data)
1693             {
1694             case 0x01:
1695               fprintf (file, _(" Register save millicode"));
1696               break;
1697             case 0x02:
1698               fprintf (file, _(" Register restore millicode"));
1699               break;
1700             case 0x03:
1701               fprintf (file, _(" Glue code sequence"));
1702               break;
1703             default:
1704               break;
1705             }
1706         }
1707 #endif
1708       fprintf (file, "\n");
1709     }
1710
1711   free (data);
1712
1713   return TRUE;
1714 #undef PDATA_ROW_SIZE
1715 }
1716
1717 typedef struct sym_cache
1718 {
1719   int        symcount;
1720   asymbol ** syms;
1721 } sym_cache;
1722
1723 static asymbol **
1724 slurp_symtab (bfd *abfd, sym_cache *psc)
1725 {
1726   asymbol ** sy = NULL;
1727   long storage;
1728
1729   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1730     {
1731       psc->symcount = 0;
1732       return NULL;
1733     }
1734
1735   storage = bfd_get_symtab_upper_bound (abfd);
1736   if (storage < 0)
1737     return NULL;
1738   if (storage)
1739     sy = (asymbol **) bfd_malloc (storage);
1740
1741   psc->symcount = bfd_canonicalize_symtab (abfd, sy);
1742   if (psc->symcount < 0)
1743     return NULL;
1744   return sy;
1745 }
1746
1747 static const char *
1748 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
1749 {
1750   int i;
1751
1752   if (psc->syms == 0)
1753     psc->syms = slurp_symtab (abfd, psc);
1754
1755   for (i = 0; i < psc->symcount; i++)
1756     {
1757       if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
1758         return psc->syms[i]->name;
1759     }
1760
1761   return NULL;
1762 }
1763
1764 static void
1765 cleanup_syms (sym_cache *psc)
1766 {
1767   psc->symcount = 0;
1768   free (psc->syms);
1769   psc->syms = NULL;
1770 }
1771
1772 /* This is the version for "compressed" pdata.  */
1773
1774 bfd_boolean
1775 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
1776 {
1777 # define PDATA_ROW_SIZE (2 * 4)
1778   FILE *file = (FILE *) vfile;
1779   bfd_byte *data = NULL;
1780   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1781   bfd_size_type datasize = 0;
1782   bfd_size_type i;
1783   bfd_size_type start, stop;
1784   int onaline = PDATA_ROW_SIZE;
1785   struct sym_cache sym_cache = {0, 0} ;
1786
1787   if (section == NULL
1788       || coff_section_data (abfd, section) == NULL
1789       || pei_section_data (abfd, section) == NULL)
1790     return TRUE;
1791
1792   stop = pei_section_data (abfd, section)->virt_size;
1793   if ((stop % onaline) != 0)
1794     fprintf (file,
1795              _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1796              (long) stop, onaline);
1797
1798   fprintf (file,
1799            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1800
1801   fprintf (file, _("\
1802  vma:\t\tBegin    Prolog   Function Flags    Exception EH\n\
1803      \t\tAddress  Length   Length   32b exc  Handler   Data\n"));
1804
1805   datasize = section->size;
1806   if (datasize == 0)
1807     return TRUE;
1808
1809   if (! bfd_malloc_and_get_section (abfd, section, &data))
1810     {
1811       if (data != NULL)
1812         free (data);
1813       return FALSE;
1814     }
1815
1816   start = 0;
1817
1818   for (i = start; i < stop; i += onaline)
1819     {
1820       bfd_vma begin_addr;
1821       bfd_vma other_data;
1822       bfd_vma prolog_length, function_length;
1823       int flag32bit, exception_flag;
1824       bfd_byte *tdata = 0;
1825       asection *tsection;
1826
1827       if (i + PDATA_ROW_SIZE > stop)
1828         break;
1829
1830       begin_addr = GET_PDATA_ENTRY (abfd, data + i     );
1831       other_data = GET_PDATA_ENTRY (abfd, data + i +  4);
1832
1833       if (begin_addr == 0 && other_data == 0)
1834         /* We are probably into the padding of the section now.  */
1835         break;
1836
1837       prolog_length = (other_data & 0x000000FF);
1838       function_length = (other_data & 0x3FFFFF00) >> 8;
1839       flag32bit = (int)((other_data & 0x40000000) >> 30);
1840       exception_flag = (int)((other_data & 0x80000000) >> 31);
1841
1842       fputc (' ', file);
1843       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1844       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1845       bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
1846       bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
1847       fprintf (file, "%2d  %2d   ", flag32bit, exception_flag);
1848
1849       /* Get the exception handler's address and the data passed from the
1850          .text section. This is really the data that belongs with the .pdata
1851          but got "compressed" out for the ARM and SH4 architectures.  */
1852       tsection = bfd_get_section_by_name (abfd, ".text");
1853       if (tsection && coff_section_data (abfd, tsection)
1854           && pei_section_data (abfd, tsection))
1855         {
1856           if (bfd_malloc_and_get_section (abfd, tsection, & tdata))
1857             {
1858               int xx = (begin_addr - 8) - tsection->vma;
1859
1860               tdata = (bfd_byte *) bfd_malloc (8);
1861               if (bfd_get_section_contents (abfd, tsection, tdata, (bfd_vma) xx, 8))
1862                 {
1863                   bfd_vma eh, eh_data;
1864
1865                   eh = bfd_get_32 (abfd, tdata);
1866                   eh_data = bfd_get_32 (abfd, tdata + 4);
1867                   fprintf (file, "%08x  ", (unsigned int) eh);
1868                   fprintf (file, "%08x", (unsigned int) eh_data);
1869                   if (eh != 0)
1870                     {
1871                       const char *s = my_symbol_for_address (abfd, eh, &sym_cache);
1872
1873                       if (s)
1874                         fprintf (file, " (%s) ", s);
1875                     }
1876                 }
1877               free (tdata);
1878             }
1879           else
1880             {
1881               if (tdata)
1882                 free (tdata);
1883             }
1884         }
1885
1886       fprintf (file, "\n");
1887     }
1888
1889   free (data);
1890
1891   cleanup_syms (& sym_cache);
1892
1893   return TRUE;
1894 #undef PDATA_ROW_SIZE
1895 }
1896
1897 \f
1898 #define IMAGE_REL_BASED_HIGHADJ 4
1899 static const char * const tbl[] =
1900 {
1901   "ABSOLUTE",
1902   "HIGH",
1903   "LOW",
1904   "HIGHLOW",
1905   "HIGHADJ",
1906   "MIPS_JMPADDR",
1907   "SECTION",
1908   "REL32",
1909   "RESERVED1",
1910   "MIPS_JMPADDR16",
1911   "DIR64",
1912   "HIGH3ADJ",
1913   "UNKNOWN",   /* MUST be last.  */
1914 };
1915
1916 static bfd_boolean
1917 pe_print_reloc (bfd * abfd, void * vfile)
1918 {
1919   FILE *file = (FILE *) vfile;
1920   bfd_byte *data = 0;
1921   asection *section = bfd_get_section_by_name (abfd, ".reloc");
1922   bfd_size_type datasize;
1923   bfd_size_type i;
1924   bfd_size_type start, stop;
1925
1926   if (section == NULL)
1927     return TRUE;
1928
1929   if (section->size == 0)
1930     return TRUE;
1931
1932   fprintf (file,
1933            _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1934
1935   datasize = section->size;
1936   if (! bfd_malloc_and_get_section (abfd, section, &data))
1937     {
1938       if (data != NULL)
1939         free (data);
1940       return FALSE;
1941     }
1942
1943   start = 0;
1944
1945   stop = section->size;
1946
1947   for (i = start; i < stop;)
1948     {
1949       int j;
1950       bfd_vma virtual_address;
1951       long number, size;
1952
1953       /* The .reloc section is a sequence of blocks, with a header consisting
1954          of two 32 bit quantities, followed by a number of 16 bit entries.  */
1955       virtual_address = bfd_get_32 (abfd, data+i);
1956       size = bfd_get_32 (abfd, data+i+4);
1957       number = (size - 8) / 2;
1958
1959       if (size == 0)
1960         break;
1961
1962       fprintf (file,
1963                _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1964                (unsigned long) virtual_address, size, (unsigned long) size, number);
1965
1966       for (j = 0; j < number; ++j)
1967         {
1968           unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1969           unsigned int t = (e & 0xF000) >> 12;
1970           int off = e & 0x0FFF;
1971
1972           if (t >= sizeof (tbl) / sizeof (tbl[0]))
1973             t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1974
1975           fprintf (file,
1976                    _("\treloc %4d offset %4x [%4lx] %s"),
1977                    j, off, (unsigned long) (off + virtual_address), tbl[t]);
1978
1979           /* HIGHADJ takes an argument, - the next record *is* the
1980              low 16 bits of addend.  */
1981           if (t == IMAGE_REL_BASED_HIGHADJ)
1982             {
1983               fprintf (file, " (%4x)",
1984                        ((unsigned int)
1985                         bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1986               j++;
1987             }
1988
1989           fprintf (file, "\n");
1990         }
1991
1992       i += size;
1993     }
1994
1995   free (data);
1996
1997   return TRUE;
1998 }
1999
2000 /* Print out the program headers.  */
2001
2002 bfd_boolean
2003 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2004 {
2005   FILE *file = (FILE *) vfile;
2006   int j;
2007   pe_data_type *pe = pe_data (abfd);
2008   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2009   const char *subsystem_name = NULL;
2010   const char *name;
2011
2012   /* The MS dumpbin program reportedly ands with 0xff0f before
2013      printing the characteristics field.  Not sure why.  No reason to
2014      emulate it here.  */
2015   fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2016 #undef PF
2017 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2018   PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2019   PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2020   PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2021   PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2022   PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2023   PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2024   PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2025   PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2026   PF (IMAGE_FILE_SYSTEM, "system file");
2027   PF (IMAGE_FILE_DLL, "DLL");
2028   PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2029 #undef PF
2030
2031   /* ctime implies '\n'.  */
2032   {
2033     time_t t = pe->coff.timestamp;
2034     fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2035   }
2036
2037 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2038 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2039 #endif
2040 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2041 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2042 #endif
2043 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2044 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2045 #endif
2046
2047   switch (i->Magic)
2048     {
2049     case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2050       name = "PE32";
2051       break;
2052     case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2053       name = "PE32+";
2054       break;
2055     case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2056       name = "ROM";
2057       break;
2058     default:
2059       name = NULL;
2060       break;
2061     }
2062   fprintf (file, "Magic\t\t\t%04x", i->Magic);
2063   if (name)
2064     fprintf (file, "\t(%s)",name);
2065   fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2066   fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2067   fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2068   fprintf (file, "SizeOfInitializedData\t%08lx\n",
2069            (unsigned long) i->SizeOfInitializedData);
2070   fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2071            (unsigned long) i->SizeOfUninitializedData);
2072   fprintf (file, "AddressOfEntryPoint\t");
2073   bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2074   fprintf (file, "\nBaseOfCode\t\t");
2075   bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2076 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2077   /* PE32+ does not have BaseOfData member!  */
2078   fprintf (file, "\nBaseOfData\t\t");
2079   bfd_fprintf_vma (abfd, file, i->BaseOfData);
2080 #endif
2081
2082   fprintf (file, "\nImageBase\t\t");
2083   bfd_fprintf_vma (abfd, file, i->ImageBase);
2084   fprintf (file, "\nSectionAlignment\t");
2085   bfd_fprintf_vma (abfd, file, i->SectionAlignment);
2086   fprintf (file, "\nFileAlignment\t\t");
2087   bfd_fprintf_vma (abfd, file, i->FileAlignment);
2088   fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2089   fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2090   fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2091   fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2092   fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2093   fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2094   fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2095   fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2096   fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2097   fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2098
2099   switch (i->Subsystem)
2100     {
2101     case IMAGE_SUBSYSTEM_UNKNOWN:
2102       subsystem_name = "unspecified";
2103       break;
2104     case IMAGE_SUBSYSTEM_NATIVE:
2105       subsystem_name = "NT native";
2106       break;
2107     case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2108       subsystem_name = "Windows GUI";
2109       break;
2110     case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2111       subsystem_name = "Windows CUI";
2112       break;
2113     case IMAGE_SUBSYSTEM_POSIX_CUI:
2114       subsystem_name = "POSIX CUI";
2115       break;
2116     case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2117       subsystem_name = "Wince CUI";
2118       break;
2119     // These are from UEFI Platform Initialization Specification 1.1.
2120     case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2121       subsystem_name = "EFI application";
2122       break;
2123     case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2124       subsystem_name = "EFI boot service driver";
2125       break;
2126     case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2127       subsystem_name = "EFI runtime driver";
2128       break;
2129     case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2130       subsystem_name = "SAL runtime driver";
2131       break;
2132     // This is from revision 8.0 of the MS PE/COFF spec
2133     case IMAGE_SUBSYSTEM_XBOX:
2134       subsystem_name = "XBOX";
2135       break;
2136     // Added default case for clarity - subsystem_name is NULL anyway.
2137     default:
2138       subsystem_name = NULL;
2139     }
2140
2141   fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2142   if (subsystem_name)
2143     fprintf (file, "\t(%s)", subsystem_name);
2144   fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2145   fprintf (file, "SizeOfStackReserve\t");
2146   bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
2147   fprintf (file, "\nSizeOfStackCommit\t");
2148   bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
2149   fprintf (file, "\nSizeOfHeapReserve\t");
2150   bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
2151   fprintf (file, "\nSizeOfHeapCommit\t");
2152   bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
2153   fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2154   fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2155            (unsigned long) i->NumberOfRvaAndSizes);
2156
2157   fprintf (file, "\nThe Data Directory\n");
2158   for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2159     {
2160       fprintf (file, "Entry %1x ", j);
2161       bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
2162       fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2163       fprintf (file, "%s\n", dir_names[j]);
2164     }
2165
2166   pe_print_idata (abfd, vfile);
2167   pe_print_edata (abfd, vfile);
2168   if (bfd_coff_have_print_pdata (abfd))
2169     bfd_coff_print_pdata (abfd, vfile);
2170   else
2171     pe_print_pdata (abfd, vfile);
2172   pe_print_reloc (abfd, vfile);
2173
2174   return TRUE;
2175 }
2176
2177 /* Copy any private info we understand from the input bfd
2178    to the output bfd.  */
2179
2180 bfd_boolean
2181 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2182 {
2183   pe_data_type *ipe, *ope;
2184
2185   /* One day we may try to grok other private data.  */
2186   if (ibfd->xvec->flavour != bfd_target_coff_flavour
2187       || obfd->xvec->flavour != bfd_target_coff_flavour)
2188     return TRUE;
2189
2190   ipe = pe_data (ibfd);
2191   ope = pe_data (obfd);
2192
2193   /* pe_opthdr is copied in copy_object.  */
2194   ope->dll = ipe->dll;
2195
2196   /* Don't copy input subsystem if output is different from input.  */
2197   if (obfd->xvec != ibfd->xvec)
2198     ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2199
2200   /* For strip: if we removed .reloc, we'll make a real mess of things
2201      if we don't remove this entry as well.  */
2202   if (! pe_data (obfd)->has_reloc_section)
2203     {
2204       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2205       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
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 /* Handle the .idata section and other things that need symbol table
2257    access.  */
2258
2259 bfd_boolean
2260 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
2261 {
2262   struct coff_link_hash_entry *h1;
2263   struct bfd_link_info *info = pfinfo->info;
2264   bfd_boolean result = TRUE;
2265
2266   /* There are a few fields that need to be filled in now while we
2267      have symbol table access.
2268
2269      The .idata subsections aren't directly available as sections, but
2270      they are in the symbol table, so get them from there.  */
2271
2272   /* The import directory.  This is the address of .idata$2, with size
2273      of .idata$2 + .idata$3.  */
2274   h1 = coff_link_hash_lookup (coff_hash_table (info),
2275                               ".idata$2", FALSE, FALSE, TRUE);
2276   if (h1 != NULL)
2277     {
2278       /* PR ld/2729: We cannot rely upon all the output sections having been
2279          created properly, so check before referencing them.  Issue a warning
2280          message for any sections tht could not be found.  */
2281       if ((h1->root.type == bfd_link_hash_defined
2282            || h1->root.type == bfd_link_hash_defweak)
2283           && h1->root.u.def.section != NULL
2284           && h1->root.u.def.section->output_section != NULL)
2285         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
2286           (h1->root.u.def.value
2287            + h1->root.u.def.section->output_section->vma
2288            + h1->root.u.def.section->output_offset);
2289       else
2290         {
2291           _bfd_error_handler
2292             (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
2293              abfd);
2294           result = FALSE;
2295         }
2296
2297       h1 = coff_link_hash_lookup (coff_hash_table (info),
2298                                   ".idata$4", FALSE, FALSE, TRUE);
2299       if (h1 != NULL
2300           && (h1->root.type == bfd_link_hash_defined
2301            || h1->root.type == bfd_link_hash_defweak)
2302           && h1->root.u.def.section != NULL
2303           && h1->root.u.def.section->output_section != NULL)
2304         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
2305           ((h1->root.u.def.value
2306             + h1->root.u.def.section->output_section->vma
2307             + h1->root.u.def.section->output_offset)
2308            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
2309       else
2310         {
2311           _bfd_error_handler
2312             (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
2313              abfd);
2314           result = FALSE;
2315         }
2316
2317       /* The import address table.  This is the size/address of
2318          .idata$5.  */
2319       h1 = coff_link_hash_lookup (coff_hash_table (info),
2320                                   ".idata$5", FALSE, FALSE, TRUE);
2321       if (h1 != NULL
2322           && (h1->root.type == bfd_link_hash_defined
2323            || h1->root.type == bfd_link_hash_defweak)
2324           && h1->root.u.def.section != NULL
2325           && h1->root.u.def.section->output_section != NULL)
2326         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
2327           (h1->root.u.def.value
2328            + h1->root.u.def.section->output_section->vma
2329            + h1->root.u.def.section->output_offset);
2330       else
2331         {
2332           _bfd_error_handler
2333             (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
2334              abfd);
2335           result = FALSE;
2336         }
2337
2338       h1 = coff_link_hash_lookup (coff_hash_table (info),
2339                                   ".idata$6", FALSE, FALSE, TRUE);
2340       if (h1 != NULL
2341           && (h1->root.type == bfd_link_hash_defined
2342            || h1->root.type == bfd_link_hash_defweak)
2343           && h1->root.u.def.section != NULL
2344           && h1->root.u.def.section->output_section != NULL)
2345         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
2346           ((h1->root.u.def.value
2347             + h1->root.u.def.section->output_section->vma
2348             + h1->root.u.def.section->output_offset)
2349            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
2350       else
2351         {
2352           _bfd_error_handler
2353             (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
2354              abfd);
2355           result = FALSE;
2356         }
2357     }
2358
2359   h1 = coff_link_hash_lookup (coff_hash_table (info),
2360                               "__tls_used", FALSE, FALSE, TRUE);
2361   if (h1 != NULL)
2362     {
2363       if ((h1->root.type == bfd_link_hash_defined
2364            || h1->root.type == bfd_link_hash_defweak)
2365           && h1->root.u.def.section != NULL
2366           && h1->root.u.def.section->output_section != NULL)
2367         pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
2368           (h1->root.u.def.value
2369            + h1->root.u.def.section->output_section->vma
2370            + h1->root.u.def.section->output_offset
2371            - pe_data (abfd)->pe_opthdr.ImageBase);
2372       else
2373         {
2374           _bfd_error_handler
2375             (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
2376              abfd);
2377           result = FALSE;
2378         }
2379
2380       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
2381     }
2382
2383   /* If we couldn't find idata$2, we either have an excessively
2384      trivial program or are in DEEP trouble; we have to assume trivial
2385      program....  */
2386   return result;
2387 }