bfd/peXXigen.c

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