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