bfd/peXXigen.c

   1 /* Support for the generic parts of PE/PEI; the common executable parts.
   2    Copyright (C) 1995-2018 Free Software Foundation, Inc.
   3    Written by Cygnus Solutions.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22
  23 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
  24
  25    PE/PEI rearrangement (and code added): Donn Terry
  26                                           Softway Systems, Inc.  */
  27
  28 /* Hey look, some documentation [and in a place you expect to find it]!
  29
  30    The main reference for the pei format is "Microsoft Portable Executable
  31    and Common Object File Format Specification 4.1".  Get it if you need to
  32    do some serious hacking on this code.
  33
  34    Another reference:
  35    "Peering Inside the PE: A Tour of the Win32 Portable Executable
  36    File Format", MSJ 1994, Volume 9.
  37
  38    The *sole* difference between the pe format and the pei format is that the
  39    latter has an MSDOS 2.0 .exe header on the front that prints the message
  40    "This app must be run under Windows." (or some such).
  41    (FIXME: Whether that statement is *really* true or not is unknown.
  42    Are there more subtle differences between pe and pei formats?
  43    For now assume there aren't.  If you find one, then for God sakes
  44    document it here!)
  45
  46    The Microsoft docs use the word "image" instead of "executable" because
  47    the former can also refer to a DLL (shared library).  Confusion can arise
  48    because the `i' in `pei' also refers to "image".  The `pe' format can
  49    also create images (i.e. executables), it's just that to run on a win32
  50    system you need to use the pei format.
  51
  52    FIXME: Please add more docs here so the next poor fool that has to hack
  53    on this code has a chance of getting something accomplished without
  54    wasting too much time.  */
  55
  56 /* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64
  57    depending on whether we're compiling for straight PE or PE+.  */
  58 #define COFF_WITH_XX
  59
  60 #include "sysdep.h"
  61 #include "bfd.h"
  62 #include "libbfd.h"
  63 #include "coff/internal.h"
  64 #include "bfdver.h"
  65 #include "libiberty.h"
  66 #ifdef HAVE_WCHAR_H
  67 #include <wchar.h>
  68 #endif
  69 #ifdef HAVE_WCTYPE_H
  70 #include <wctype.h>
  71 #endif
  72
  73 /* NOTE: it's strange to be including an architecture specific header
  74    in what's supposed to be general (to PE/PEI) code.  However, that's
  75    where the definitions are, and they don't vary per architecture
  76    within PE/PEI, so we get them from there.  FIXME: The lack of
  77    variance is an assumption which may prove to be incorrect if new
  78    PE/PEI targets are created.  */
  79 #if defined COFF_WITH_pex64
  80 # include "coff/x86_64.h"
  81 #elif defined COFF_WITH_pep
  82 # include "coff/ia64.h"
  83 #else
  84 # include "coff/i386.h"
  85 #endif
  86
  87 #include "coff/pe.h"
  88 #include "libcoff.h"
  89 #include "libpei.h"
  90 #include "safe-ctype.h"
  91
  92 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
  93 # undef AOUTSZ
  94 # define AOUTSZ         PEPAOUTSZ
  95 # define PEAOUTHDR      PEPAOUTHDR
  96 #endif
  97
  98 #define HighBitSet(val)      ((val) & 0x80000000)
  99 #define SetHighBit(val)      ((val) | 0x80000000)
 100 #define WithoutHighBit(val)  ((val) & 0x7fffffff)
 101
 102 /* FIXME: This file has various tests of POWERPC_LE_PE.  Those tests
 103    worked when the code was in peicode.h, but no longer work now that
 104    the code is in peigen.c.  PowerPC NT is said to be dead.  If
 105    anybody wants to revive the code, you will have to figure out how
 106    to handle those issues.  */
 107 \f
 108 void
 109 _bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1)
 110 {
 111   SYMENT *ext = (SYMENT *) ext1;
 112   struct internal_syment *in = (struct internal_syment *) in1;
 113
 114   if (ext->e.e_name[0] == 0)
 115     {
 116       in->_n._n_n._n_zeroes = 0;
 117       in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
 118     }
 119   else
 120     memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
 121
 122   in->n_value = H_GET_32 (abfd, ext->e_value);
 123   in->n_scnum = (short) H_GET_16 (abfd, ext->e_scnum);
 124
 125   if (sizeof (ext->e_type) == 2)
 126     in->n_type = H_GET_16 (abfd, ext->e_type);
 127   else
 128     in->n_type = H_GET_32 (abfd, ext->e_type);
 129
 130   in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
 131   in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
 132
 133 #ifndef STRICT_PE_FORMAT
 134   /* This is for Gnu-created DLLs.  */
 135
 136   /* The section symbols for the .idata$ sections have class 0x68
 137      (C_SECTION), which MS documentation indicates is a section
 138      symbol.  Unfortunately, the value field in the symbol is simply a
 139      copy of the .idata section's flags rather than something useful.
 140      When these symbols are encountered, change the value to 0 so that
 141      they will be handled somewhat correctly in the bfd code.  */
 142   if (in->n_sclass == C_SECTION)
 143     {
 144       char namebuf[SYMNMLEN + 1];
 145       const char *name = NULL;
 146
 147       in->n_value = 0x0;
 148
 149       /* Create synthetic empty sections as needed.  DJ */
 150       if (in->n_scnum == 0)
 151         {
 152           asection *sec;
 153
 154           name = _bfd_coff_internal_syment_name (abfd, in, namebuf);
 155           if (name == NULL)
 156             {
 157               _bfd_error_handler (_("%pB: unable to find name for empty section"),
 158                                   abfd);
 159               bfd_set_error (bfd_error_invalid_target);
 160               return;
 161             }
 162
 163           sec = bfd_get_section_by_name (abfd, name);
 164           if (sec != NULL)
 165             in->n_scnum = sec->target_index;
 166         }
 167
 168       if (in->n_scnum == 0)
 169         {
 170           int unused_section_number = 0;
 171           asection *sec;
 172           flagword flags;
 173
 174           for (sec = abfd->sections; sec; sec = sec->next)
 175             if (unused_section_number <= sec->target_index)
 176               unused_section_number = sec->target_index + 1;
 177
 178           if (name == namebuf)
 179             {
 180               name = (const char *) bfd_alloc (abfd, strlen (namebuf) + 1);
 181               if (name == NULL)
 182                 {
 183                   _bfd_error_handler (_("%pB: out of memory creating name for empty section"),
 184                                       abfd);
 185                   return;
 186                 }
 187               strcpy ((char *) name, namebuf);
 188             }
 189
 190           flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
 191           sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
 192           if (sec == NULL)
 193             {
 194               _bfd_error_handler (_("%pB: unable to create fake empty section"),
 195                                   abfd);
 196               return;
 197             }
 198
 199           sec->vma = 0;
 200           sec->lma = 0;
 201           sec->size = 0;
 202           sec->filepos = 0;
 203           sec->rel_filepos = 0;
 204           sec->reloc_count = 0;
 205           sec->line_filepos = 0;
 206           sec->lineno_count = 0;
 207           sec->userdata = NULL;
 208           sec->next = NULL;
 209           sec->alignment_power = 2;
 210
 211           sec->target_index = unused_section_number;
 212
 213           in->n_scnum = unused_section_number;
 214         }
 215       in->n_sclass = C_STAT;
 216     }
 217 #endif
 218
 219 #ifdef coff_swap_sym_in_hook
 220   /* This won't work in peigen.c, but since it's for PPC PE, it's not
 221      worth fixing.  */
 222   coff_swap_sym_in_hook (abfd, ext1, in1);
 223 #endif
 224 }
 225
 226 static bfd_boolean
 227 abs_finder (bfd * abfd ATTRIBUTE_UNUSED, asection * sec, void * data)
 228 {
 229   bfd_vma abs_val = * (bfd_vma *) data;
 230
 231   return (sec->vma <= abs_val) && ((sec->vma + (1ULL << 32)) > abs_val);
 232 }
 233
 234 unsigned int
 235 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
 236 {
 237   struct internal_syment *in = (struct internal_syment *) inp;
 238   SYMENT *ext = (SYMENT *) extp;
 239
 240   if (in->_n._n_name[0] == 0)
 241     {
 242       H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
 243       H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
 244     }
 245   else
 246     memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
 247
 248   /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
 249      symbol.  This is a problem on 64-bit targets where we can generate
 250      absolute symbols with values >= 1^32.  We try to work around this
 251      problem by finding a section whose base address is sufficient to
 252      reduce the absolute value to < 1^32, and then transforming the
 253      symbol into a section relative symbol.  This of course is a hack.  */
 254   if (sizeof (in->n_value) > 4
 255       /* The strange computation of the shift amount is here in order to
 256          avoid a compile time warning about the comparison always being
 257          false.  It does not matter if this test fails to work as expected
 258          as the worst that can happen is that some absolute symbols are
 259          needlessly converted into section relative symbols.  */
 260       && in->n_value > ((1ULL << (sizeof (in->n_value) > 4 ? 32 : 31)) - 1)
 261       && in->n_scnum == N_ABS)
 262     {
 263       asection * sec;
 264
 265       sec = bfd_sections_find_if (abfd, abs_finder, & in->n_value);
 266       if (sec)
 267         {
 268           in->n_value -= sec->vma;
 269           in->n_scnum = sec->target_index;
 270         }
 271       /* else: FIXME: The value is outside the range of any section.  This
 272          happens for __image_base__ and __ImageBase and maybe some other
 273          symbols as well.  We should find a way to handle these values.  */
 274     }
 275
 276   H_PUT_32 (abfd, in->n_value, ext->e_value);
 277   H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
 278
 279   if (sizeof (ext->e_type) == 2)
 280     H_PUT_16 (abfd, in->n_type, ext->e_type);
 281   else
 282     H_PUT_32 (abfd, in->n_type, ext->e_type);
 283
 284   H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
 285   H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
 286
 287   return SYMESZ;
 288 }
 289
 290 void
 291 _bfd_XXi_swap_aux_in (bfd *     abfd,
 292                       void *    ext1,
 293                       int       type,
 294                       int       in_class,
 295                       int       indx ATTRIBUTE_UNUSED,
 296                       int       numaux ATTRIBUTE_UNUSED,
 297                       void *    in1)
 298 {
 299   AUXENT *ext = (AUXENT *) ext1;
 300   union internal_auxent *in = (union internal_auxent *) in1;
 301
 302   /* PR 17521: Make sure that all fields in the aux structure
 303      are initialised.  */
 304   memset (in, 0, sizeof * in);
 305   switch (in_class)
 306     {
 307     case C_FILE:
 308       if (ext->x_file.x_fname[0] == 0)
 309         {
 310           in->x_file.x_n.x_zeroes = 0;
 311           in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
 312         }
 313       else
 314         memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
 315       return;
 316
 317     case C_STAT:
 318     case C_LEAFSTAT:
 319     case C_HIDDEN:
 320       if (type == T_NULL)
 321         {
 322           in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
 323           in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
 324           in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
 325           in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
 326           in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
 327           in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
 328           return;
 329         }
 330       break;
 331     }
 332
 333   in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
 334   in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
 335
 336   if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
 337       || ISTAG (in_class))
 338     {
 339       in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
 340       in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
 341     }
 342   else
 343     {
 344       in->x_sym.x_fcnary.x_ary.x_dimen[0] =
 345         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 346       in->x_sym.x_fcnary.x_ary.x_dimen[1] =
 347         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 348       in->x_sym.x_fcnary.x_ary.x_dimen[2] =
 349         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 350       in->x_sym.x_fcnary.x_ary.x_dimen[3] =
 351         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 352     }
 353
 354   if (ISFCN (type))
 355     {
 356       in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
 357     }
 358   else
 359     {
 360       in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
 361       in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
 362     }
 363 }
 364
 365 unsigned int
 366 _bfd_XXi_swap_aux_out (bfd *  abfd,
 367                        void * inp,
 368                        int    type,
 369                        int    in_class,
 370                        int    indx ATTRIBUTE_UNUSED,
 371                        int    numaux ATTRIBUTE_UNUSED,
 372                        void * extp)
 373 {
 374   union internal_auxent *in = (union internal_auxent *) inp;
 375   AUXENT *ext = (AUXENT *) extp;
 376
 377   memset (ext, 0, AUXESZ);
 378
 379   switch (in_class)
 380     {
 381     case C_FILE:
 382       if (in->x_file.x_fname[0] == 0)
 383         {
 384           H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
 385           H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
 386         }
 387       else
 388         memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
 389
 390       return AUXESZ;
 391
 392     case C_STAT:
 393     case C_LEAFSTAT:
 394     case C_HIDDEN:
 395       if (type == T_NULL)
 396         {
 397           PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
 398           PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
 399           PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
 400           H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
 401           H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
 402           H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
 403           return AUXESZ;
 404         }
 405       break;
 406     }
 407
 408   H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
 409   H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
 410
 411   if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
 412       || ISTAG (in_class))
 413     {
 414       PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,  ext);
 415       PUT_FCN_ENDNDX  (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
 416     }
 417   else
 418     {
 419       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
 420                 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 421       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
 422                 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 423       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
 424                 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 425       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
 426                 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 427     }
 428
 429   if (ISFCN (type))
 430     H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
 431   else
 432     {
 433       PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
 434       PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
 435     }
 436
 437   return AUXESZ;
 438 }
 439
 440 void
 441 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
 442 {
 443   LINENO *ext = (LINENO *) ext1;
 444   struct internal_lineno *in = (struct internal_lineno *) in1;
 445
 446   in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
 447   in->l_lnno = GET_LINENO_LNNO (abfd, ext);
 448 }
 449
 450 unsigned int
 451 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
 452 {
 453   struct internal_lineno *in = (struct internal_lineno *) inp;
 454   struct external_lineno *ext = (struct external_lineno *) outp;
 455   H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
 456
 457   PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
 458   return LINESZ;
 459 }
 460
 461 void
 462 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
 463                           void * aouthdr_ext1,
 464                           void * aouthdr_int1)
 465 {
 466   PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
 467   AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
 468   struct internal_aouthdr *aouthdr_int
 469     = (struct internal_aouthdr *) aouthdr_int1;
 470   struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
 471
 472   aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
 473   aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
 474   aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
 475   aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
 476   aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
 477   aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
 478   aouthdr_int->text_start =
 479     GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
 480
 481 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 482   /* PE32+ does not have data_start member!  */
 483   aouthdr_int->data_start =
 484     GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
 485   a->BaseOfData = aouthdr_int->data_start;
 486 #endif
 487
 488   a->Magic = aouthdr_int->magic;
 489   a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
 490   a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
 491   a->SizeOfCode = aouthdr_int->tsize ;
 492   a->SizeOfInitializedData = aouthdr_int->dsize ;
 493   a->SizeOfUninitializedData = aouthdr_int->bsize ;
 494   a->AddressOfEntryPoint = aouthdr_int->entry;
 495   a->BaseOfCode = aouthdr_int->text_start;
 496   a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
 497   a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
 498   a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
 499   a->MajorOperatingSystemVersion =
 500     H_GET_16 (abfd, src->MajorOperatingSystemVersion);
 501   a->MinorOperatingSystemVersion =
 502     H_GET_16 (abfd, src->MinorOperatingSystemVersion);
 503   a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
 504   a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
 505   a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
 506   a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
 507   a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
 508   a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
 509   a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
 510   a->CheckSum = H_GET_32 (abfd, src->CheckSum);
 511   a->Subsystem = H_GET_16 (abfd, src->Subsystem);
 512   a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
 513   a->SizeOfStackReserve =
 514     GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
 515   a->SizeOfStackCommit =
 516     GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
 517   a->SizeOfHeapReserve =
 518     GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
 519   a->SizeOfHeapCommit =
 520     GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
 521   a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
 522   a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
 523
 524   {
 525     int idx;
 526
 527     /* PR 17512: Corrupt PE binaries can cause seg-faults.  */
 528     if (a->NumberOfRvaAndSizes > IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
 529       {
 530         /* xgettext:c-format */
 531         _bfd_error_handler
 532           (_("%pB: aout header specifies an invalid number of data-directory entries: %ld"),
 533            abfd, a->NumberOfRvaAndSizes);
 534         bfd_set_error (bfd_error_bad_value);
 535
 536         /* Paranoia: If the number is corrupt, then assume that the
 537            actual entries themselves might be corrupt as well.  */
 538         a->NumberOfRvaAndSizes = 0;
 539       }
 540
 541     for (idx = 0; idx < a->NumberOfRvaAndSizes; idx++)
 542       {
 543         /* If data directory is empty, rva also should be 0.  */
 544         int size =
 545           H_GET_32 (abfd, src->DataDirectory[idx][1]);
 546
 547         a->DataDirectory[idx].Size = size;
 548
 549         if (size)
 550           a->DataDirectory[idx].VirtualAddress =
 551             H_GET_32 (abfd, src->DataDirectory[idx][0]);
 552         else
 553           a->DataDirectory[idx].VirtualAddress = 0;
 554       }
 555
 556     while (idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
 557       {
 558         a->DataDirectory[idx].Size = 0;
 559         a->DataDirectory[idx].VirtualAddress = 0;
 560         idx ++;
 561       }
 562   }
 563
 564   if (aouthdr_int->entry)
 565     {
 566       aouthdr_int->entry += a->ImageBase;
 567 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 568       aouthdr_int->entry &= 0xffffffff;
 569 #endif
 570     }
 571
 572   if (aouthdr_int->tsize)
 573     {
 574       aouthdr_int->text_start += a->ImageBase;
 575 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 576       aouthdr_int->text_start &= 0xffffffff;
 577 #endif
 578     }
 579
 580 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 581   /* PE32+ does not have data_start member!  */
 582   if (aouthdr_int->dsize)
 583     {
 584       aouthdr_int->data_start += a->ImageBase;
 585       aouthdr_int->data_start &= 0xffffffff;
 586     }
 587 #endif
 588
 589 #ifdef POWERPC_LE_PE
 590   /* These three fields are normally set up by ppc_relocate_section.
 591      In the case of reading a file in, we can pick them up from the
 592      DataDirectory.  */
 593   first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
 594   thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
 595   import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
 596 #endif
 597 }
 598
 599 /* A support function for below.  */
 600
 601 static void
 602 add_data_entry (bfd * abfd,
 603                 struct internal_extra_pe_aouthdr *aout,
 604                 int idx,
 605                 char *name,
 606                 bfd_vma base)
 607 {
 608   asection *sec = bfd_get_section_by_name (abfd, name);
 609
 610   /* Add import directory information if it exists.  */
 611   if ((sec != NULL)
 612       && (coff_section_data (abfd, sec) != NULL)
 613       && (pei_section_data (abfd, sec) != NULL))
 614     {
 615       /* If data directory is empty, rva also should be 0.  */
 616       int size = pei_section_data (abfd, sec)->virt_size;
 617       aout->DataDirectory[idx].Size = size;
 618
 619       if (size)
 620         {
 621           aout->DataDirectory[idx].VirtualAddress =
 622             (sec->vma - base) & 0xffffffff;
 623           sec->flags |= SEC_DATA;
 624         }
 625     }
 626 }
 627
 628 unsigned int
 629 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
 630 {
 631   struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
 632   pe_data_type *pe = pe_data (abfd);
 633   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
 634   PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
 635   bfd_vma sa, fa, ib;
 636   IMAGE_DATA_DIRECTORY idata2, idata5, tls;
 637
 638   sa = extra->SectionAlignment;
 639   fa = extra->FileAlignment;
 640   ib = extra->ImageBase;
 641
 642   idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
 643   idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
 644   tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
 645
 646   if (aouthdr_in->tsize)
 647     {
 648       aouthdr_in->text_start -= ib;
 649 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 650       aouthdr_in->text_start &= 0xffffffff;
 651 #endif
 652     }
 653
 654   if (aouthdr_in->dsize)
 655     {
 656       aouthdr_in->data_start -= ib;
 657 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 658       aouthdr_in->data_start &= 0xffffffff;
 659 #endif
 660     }
 661
 662   if (aouthdr_in->entry)
 663     {
 664       aouthdr_in->entry -= ib;
 665 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 666       aouthdr_in->entry &= 0xffffffff;
 667 #endif
 668     }
 669
 670 #define FA(x) (((x) + fa -1 ) & (- fa))
 671 #define SA(x) (((x) + sa -1 ) & (- sa))
 672
 673   /* We like to have the sizes aligned.  */
 674   aouthdr_in->bsize = FA (aouthdr_in->bsize);
 675
 676   extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
 677
 678   add_data_entry (abfd, extra, PE_EXPORT_TABLE, ".edata", ib);
 679   add_data_entry (abfd, extra, PE_RESOURCE_TABLE, ".rsrc", ib);
 680   add_data_entry (abfd, extra, PE_EXCEPTION_TABLE, ".pdata", ib);
 681
 682   /* In theory we do not need to call add_data_entry for .idata$2 or
 683      .idata$5.  It will be done in bfd_coff_final_link where all the
 684      required information is available.  If however, we are not going
 685      to perform a final link, eg because we have been invoked by objcopy
 686      or strip, then we need to make sure that these Data Directory
 687      entries are initialised properly.
 688
 689      So - we copy the input values into the output values, and then, if
 690      a final link is going to be performed, it can overwrite them.  */
 691   extra->DataDirectory[PE_IMPORT_TABLE]  = idata2;
 692   extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
 693   extra->DataDirectory[PE_TLS_TABLE] = tls;
 694
 695   if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
 696     /* Until other .idata fixes are made (pending patch), the entry for
 697        .idata is needed for backwards compatibility.  FIXME.  */
 698     add_data_entry (abfd, extra, PE_IMPORT_TABLE, ".idata", ib);
 699
 700   /* For some reason, the virtual size (which is what's set by
 701      add_data_entry) for .reloc is not the same as the size recorded
 702      in this slot by MSVC; it doesn't seem to cause problems (so far),
 703      but since it's the best we've got, use it.  It does do the right
 704      thing for .pdata.  */
 705   if (pe->has_reloc_section)
 706     add_data_entry (abfd, extra, PE_BASE_RELOCATION_TABLE, ".reloc", ib);
 707
 708   {
 709     asection *sec;
 710     bfd_vma hsize = 0;
 711     bfd_vma dsize = 0;
 712     bfd_vma isize = 0;
 713     bfd_vma tsize = 0;
 714
 715     for (sec = abfd->sections; sec; sec = sec->next)
 716       {
 717         int rounded = FA (sec->size);
 718
 719         /* The first non-zero section filepos is the header size.
 720            Sections without contents will have a filepos of 0.  */
 721         if (hsize == 0)
 722           hsize = sec->filepos;
 723         if (sec->flags & SEC_DATA)
 724           dsize += rounded;
 725         if (sec->flags & SEC_CODE)
 726           tsize += rounded;
 727         /* The image size is the total VIRTUAL size (which is what is
 728            in the virt_size field).  Files have been seen (from MSVC
 729            5.0 link.exe) where the file size of the .data segment is
 730            quite small compared to the virtual size.  Without this
 731            fix, strip munges the file.
 732
 733            FIXME: We need to handle holes between sections, which may
 734            happpen when we covert from another format.  We just use
 735            the virtual address and virtual size of the last section
 736            for the image size.  */
 737         if (coff_section_data (abfd, sec) != NULL
 738             && pei_section_data (abfd, sec) != NULL)
 739           isize = (sec->vma - extra->ImageBase
 740                    + SA (FA (pei_section_data (abfd, sec)->virt_size)));
 741       }
 742
 743     aouthdr_in->dsize = dsize;
 744     aouthdr_in->tsize = tsize;
 745     extra->SizeOfHeaders = hsize;
 746     extra->SizeOfImage = isize;
 747   }
 748
 749   H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
 750
 751 /* e.g. 219510000 is linker version 2.19  */
 752 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
 753
 754   /* This piece of magic sets the "linker version" field to
 755      LINKER_VERSION.  */
 756   H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
 757             aouthdr_out->standard.vstamp);
 758
 759   PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
 760   PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
 761   PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
 762   PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
 763   PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
 764                           aouthdr_out->standard.text_start);
 765
 766 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 767   /* PE32+ does not have data_start member!  */
 768   PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
 769                           aouthdr_out->standard.data_start);
 770 #endif
 771
 772   PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
 773   H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
 774   H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
 775   H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
 776             aouthdr_out->MajorOperatingSystemVersion);
 777   H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
 778             aouthdr_out->MinorOperatingSystemVersion);
 779   H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
 780   H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
 781   H_PUT_16 (abfd, extra->MajorSubsystemVersion,
 782             aouthdr_out->MajorSubsystemVersion);
 783   H_PUT_16 (abfd, extra->MinorSubsystemVersion,
 784             aouthdr_out->MinorSubsystemVersion);
 785   H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
 786   H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
 787   H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
 788   H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
 789   H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
 790   H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
 791   PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
 792                                     aouthdr_out->SizeOfStackReserve);
 793   PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
 794                                    aouthdr_out->SizeOfStackCommit);
 795   PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
 796                                    aouthdr_out->SizeOfHeapReserve);
 797   PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
 798                                   aouthdr_out->SizeOfHeapCommit);
 799   H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
 800   H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
 801             aouthdr_out->NumberOfRvaAndSizes);
 802   {
 803     int idx;
 804
 805     for (idx = 0; idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; idx++)
 806       {
 807         H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
 808                   aouthdr_out->DataDirectory[idx][0]);
 809         H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
 810                   aouthdr_out->DataDirectory[idx][1]);
 811       }
 812   }
 813
 814   return AOUTSZ;
 815 }
 816
 817 unsigned int
 818 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
 819 {
 820   int idx;
 821   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 822   struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
 823
 824   if (pe_data (abfd)->has_reloc_section
 825       || pe_data (abfd)->dont_strip_reloc)
 826     filehdr_in->f_flags &= ~F_RELFLG;
 827
 828   if (pe_data (abfd)->dll)
 829     filehdr_in->f_flags |= F_DLL;
 830
 831   filehdr_in->pe.e_magic    = IMAGE_DOS_SIGNATURE;
 832   filehdr_in->pe.e_cblp     = 0x90;
 833   filehdr_in->pe.e_cp       = 0x3;
 834   filehdr_in->pe.e_crlc     = 0x0;
 835   filehdr_in->pe.e_cparhdr  = 0x4;
 836   filehdr_in->pe.e_minalloc = 0x0;
 837   filehdr_in->pe.e_maxalloc = 0xffff;
 838   filehdr_in->pe.e_ss       = 0x0;
 839   filehdr_in->pe.e_sp       = 0xb8;
 840   filehdr_in->pe.e_csum     = 0x0;
 841   filehdr_in->pe.e_ip       = 0x0;
 842   filehdr_in->pe.e_cs       = 0x0;
 843   filehdr_in->pe.e_lfarlc   = 0x40;
 844   filehdr_in->pe.e_ovno     = 0x0;
 845
 846   for (idx = 0; idx < 4; idx++)
 847     filehdr_in->pe.e_res[idx] = 0x0;
 848
 849   filehdr_in->pe.e_oemid   = 0x0;
 850   filehdr_in->pe.e_oeminfo = 0x0;
 851
 852   for (idx = 0; idx < 10; idx++)
 853     filehdr_in->pe.e_res2[idx] = 0x0;
 854
 855   filehdr_in->pe.e_lfanew = 0x80;
 856
 857   /* This next collection of data are mostly just characters.  It
 858      appears to be constant within the headers put on NT exes.  */
 859   filehdr_in->pe.dos_message[0]  = 0x0eba1f0e;
 860   filehdr_in->pe.dos_message[1]  = 0xcd09b400;
 861   filehdr_in->pe.dos_message[2]  = 0x4c01b821;
 862   filehdr_in->pe.dos_message[3]  = 0x685421cd;
 863   filehdr_in->pe.dos_message[4]  = 0x70207369;
 864   filehdr_in->pe.dos_message[5]  = 0x72676f72;
 865   filehdr_in->pe.dos_message[6]  = 0x63206d61;
 866   filehdr_in->pe.dos_message[7]  = 0x6f6e6e61;
 867   filehdr_in->pe.dos_message[8]  = 0x65622074;
 868   filehdr_in->pe.dos_message[9]  = 0x6e757220;
 869   filehdr_in->pe.dos_message[10] = 0x206e6920;
 870   filehdr_in->pe.dos_message[11] = 0x20534f44;
 871   filehdr_in->pe.dos_message[12] = 0x65646f6d;
 872   filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
 873   filehdr_in->pe.dos_message[14] = 0x24;
 874   filehdr_in->pe.dos_message[15] = 0x0;
 875   filehdr_in->pe.nt_signature = IMAGE_NT_SIGNATURE;
 876
 877   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
 878   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 879
 880   /* Use a real timestamp by default, unless the no-insert-timestamp
 881      option was chosen.  */
 882   if ((pe_data (abfd)->insert_timestamp))
 883     H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
 884   else
 885     H_PUT_32 (abfd, 0, filehdr_out->f_timdat);
 886
 887   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
 888                       filehdr_out->f_symptr);
 889   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 890   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 891   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 892
 893   /* Put in extra dos header stuff.  This data remains essentially
 894      constant, it just has to be tacked on to the beginning of all exes
 895      for NT.  */
 896   H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
 897   H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
 898   H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
 899   H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
 900   H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
 901   H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
 902   H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
 903   H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
 904   H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
 905   H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
 906   H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
 907   H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
 908   H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
 909   H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
 910
 911   for (idx = 0; idx < 4; idx++)
 912     H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
 913
 914   H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
 915   H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
 916
 917   for (idx = 0; idx < 10; idx++)
 918     H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
 919
 920   H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
 921
 922   for (idx = 0; idx < 16; idx++)
 923     H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
 924               filehdr_out->dos_message[idx]);
 925
 926   /* Also put in the NT signature.  */
 927   H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
 928
 929   return FILHSZ;
 930 }
 931
 932 unsigned int
 933 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
 934 {
 935   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 936   FILHDR *filehdr_out = (FILHDR *) out;
 937
 938   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
 939   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 940   H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
 941   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
 942   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 943   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 944   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 945
 946   return FILHSZ;
 947 }
 948
 949 unsigned int
 950 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
 951 {
 952   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 953   SCNHDR *scnhdr_ext = (SCNHDR *) out;
 954   unsigned int ret = SCNHSZ;
 955   bfd_vma ps;
 956   bfd_vma ss;
 957
 958   memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
 959
 960   PUT_SCNHDR_VADDR (abfd,
 961                     ((scnhdr_int->s_vaddr
 962                       - pe_data (abfd)->pe_opthdr.ImageBase)
 963                      & 0xffffffff),
 964                     scnhdr_ext->s_vaddr);
 965
 966   /* NT wants the size data to be rounded up to the next
 967      NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
 968      sometimes).  */
 969   if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
 970     {
 971       if (bfd_pei_p (abfd))
 972         {
 973           ps = scnhdr_int->s_size;
 974           ss = 0;
 975         }
 976       else
 977        {
 978          ps = 0;
 979          ss = scnhdr_int->s_size;
 980        }
 981     }
 982   else
 983     {
 984       if (bfd_pei_p (abfd))
 985         ps = scnhdr_int->s_paddr;
 986       else
 987         ps = 0;
 988
 989       ss = scnhdr_int->s_size;
 990     }
 991
 992   PUT_SCNHDR_SIZE (abfd, ss,
 993                    scnhdr_ext->s_size);
 994
 995   /* s_paddr in PE is really the virtual size.  */
 996   PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
 997
 998   PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
 999                      scnhdr_ext->s_scnptr);
1000   PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
1001                      scnhdr_ext->s_relptr);
1002   PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
1003                       scnhdr_ext->s_lnnoptr);
1004
1005   {
1006     /* Extra flags must be set when dealing with PE.  All sections should also
1007        have the IMAGE_SCN_MEM_READ (0x40000000) flag set.  In addition, the
1008        .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
1009        sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
1010        (this is especially important when dealing with the .idata section since
1011        the addresses for routines from .dlls must be overwritten).  If .reloc
1012        section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
1013        (0x02000000).  Also, the resource data should also be read and
1014        writable.  */
1015
1016     /* FIXME: Alignment is also encoded in this field, at least on PPC and
1017        ARM-WINCE.  Although - how do we get the original alignment field
1018        back ?  */
1019
1020     typedef struct
1021     {
1022       char section_name[SCNNMLEN];
1023       unsigned long     must_have;
1024     }
1025     pe_required_section_flags;
1026
1027     pe_required_section_flags known_sections [] =
1028       {
1029         { ".arch",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
1030         { ".bss",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1031         { ".data",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1032         { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1033         { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1034         { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1035         { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1036         { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
1037         { ".rsrc",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1038         { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
1039         { ".tls",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1040         { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1041       };
1042
1043     pe_required_section_flags * p;
1044
1045     /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1046        we know exactly what this specific section wants so we remove it
1047        and then allow the must_have field to add it back in if necessary.
1048        However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1049        default WP_TEXT file flag has been cleared.  WP_TEXT may be cleared
1050        by ld --enable-auto-import (if auto-import is actually needed),
1051        by ld --omagic, or by obcopy --writable-text.  */
1052
1053     for (p = known_sections;
1054          p < known_sections + ARRAY_SIZE (known_sections);
1055          p++)
1056       if (memcmp (scnhdr_int->s_name, p->section_name, SCNNMLEN) == 0)
1057         {
1058           if (memcmp (scnhdr_int->s_name, ".text", sizeof ".text")
1059               || (bfd_get_file_flags (abfd) & WP_TEXT))
1060             scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
1061           scnhdr_int->s_flags |= p->must_have;
1062           break;
1063         }
1064
1065     H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1066   }
1067
1068   if (coff_data (abfd)->link_info
1069       && ! bfd_link_relocatable (coff_data (abfd)->link_info)
1070       && ! bfd_link_pic (coff_data (abfd)->link_info)
1071       && memcmp (scnhdr_int->s_name, ".text", sizeof ".text") == 0)
1072     {
1073       /* By inference from looking at MS output, the 32 bit field
1074          which is the combination of the number_of_relocs and
1075          number_of_linenos is used for the line number count in
1076          executables.  A 16-bit field won't do for cc1.  The MS
1077          document says that the number of relocs is zero for
1078          executables, but the 17-th bit has been observed to be there.
1079          Overflow is not an issue: a 4G-line program will overflow a
1080          bunch of other fields long before this!  */
1081       H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
1082       H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
1083     }
1084   else
1085     {
1086       if (scnhdr_int->s_nlnno <= 0xffff)
1087         H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
1088       else
1089         {
1090           /* xgettext:c-format */
1091           _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1092                               abfd, scnhdr_int->s_nlnno);
1093           bfd_set_error (bfd_error_file_truncated);
1094           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1095           ret = 0;
1096         }
1097
1098       /* Although we could encode 0xffff relocs here, we do not, to be
1099          consistent with other parts of bfd. Also it lets us warn, as
1100          we should never see 0xffff here w/o having the overflow flag
1101          set.  */
1102       if (scnhdr_int->s_nreloc < 0xffff)
1103         H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1104       else
1105         {
1106           /* PE can deal with large #s of relocs, but not here.  */
1107           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1108           scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1109           H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1110         }
1111     }
1112   return ret;
1113 }
1114
1115 void
1116 _bfd_XXi_swap_debugdir_in (bfd * abfd, void * ext1, void * in1)
1117 {
1118   struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) ext1;
1119   struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) in1;
1120
1121   in->Characteristics = H_GET_32(abfd, ext->Characteristics);
1122   in->TimeDateStamp = H_GET_32(abfd, ext->TimeDateStamp);
1123   in->MajorVersion = H_GET_16(abfd, ext->MajorVersion);
1124   in->MinorVersion = H_GET_16(abfd, ext->MinorVersion);
1125   in->Type = H_GET_32(abfd, ext->Type);
1126   in->SizeOfData = H_GET_32(abfd, ext->SizeOfData);
1127   in->AddressOfRawData = H_GET_32(abfd, ext->AddressOfRawData);
1128   in->PointerToRawData = H_GET_32(abfd, ext->PointerToRawData);
1129 }
1130
1131 unsigned int
1132 _bfd_XXi_swap_debugdir_out (bfd * abfd, void * inp, void * extp)
1133 {
1134   struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) extp;
1135   struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) inp;
1136
1137   H_PUT_32(abfd, in->Characteristics, ext->Characteristics);
1138   H_PUT_32(abfd, in->TimeDateStamp, ext->TimeDateStamp);
1139   H_PUT_16(abfd, in->MajorVersion, ext->MajorVersion);
1140   H_PUT_16(abfd, in->MinorVersion, ext->MinorVersion);
1141   H_PUT_32(abfd, in->Type, ext->Type);
1142   H_PUT_32(abfd, in->SizeOfData, ext->SizeOfData);
1143   H_PUT_32(abfd, in->AddressOfRawData, ext->AddressOfRawData);
1144   H_PUT_32(abfd, in->PointerToRawData, ext->PointerToRawData);
1145
1146   return sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
1147 }
1148
1149 CODEVIEW_INFO *
1150 _bfd_XXi_slurp_codeview_record (bfd * abfd, file_ptr where, unsigned long length, CODEVIEW_INFO *cvinfo)
1151 {
1152   char buffer[256+1];
1153
1154   if (bfd_seek (abfd, where, SEEK_SET) != 0)
1155     return NULL;
1156
1157   if (bfd_bread (buffer, 256, abfd) < 4)
1158     return NULL;
1159
1160   /* Ensure null termination of filename.  */
1161   buffer[256] = '\0';
1162
1163   cvinfo->CVSignature = H_GET_32 (abfd, buffer);
1164   cvinfo->Age = 0;
1165
1166   if ((cvinfo->CVSignature == CVINFO_PDB70_CVSIGNATURE)
1167       && (length > sizeof (CV_INFO_PDB70)))
1168     {
1169       CV_INFO_PDB70 *cvinfo70 = (CV_INFO_PDB70 *)(buffer);
1170
1171       cvinfo->Age = H_GET_32(abfd, cvinfo70->Age);
1172
1173       /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1174          by 8 single bytes.  Byte swap them so we can conveniently treat the GUID
1175          as 16 bytes in big-endian order.  */
1176       bfd_putb32 (bfd_getl32 (cvinfo70->Signature), cvinfo->Signature);
1177       bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[4])), &(cvinfo->Signature[4]));
1178       bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[6])), &(cvinfo->Signature[6]));
1179       memcpy (&(cvinfo->Signature[8]), &(cvinfo70->Signature[8]), 8);
1180
1181       cvinfo->SignatureLength = CV_INFO_SIGNATURE_LENGTH;
1182       // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1183
1184       return cvinfo;
1185     }
1186   else if ((cvinfo->CVSignature == CVINFO_PDB20_CVSIGNATURE)
1187            && (length > sizeof (CV_INFO_PDB20)))
1188     {
1189       CV_INFO_PDB20 *cvinfo20 = (CV_INFO_PDB20 *)(buffer);
1190       cvinfo->Age = H_GET_32(abfd, cvinfo20->Age);
1191       memcpy (cvinfo->Signature, cvinfo20->Signature, 4);
1192       cvinfo->SignatureLength = 4;
1193       // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1194
1195       return cvinfo;
1196     }
1197
1198   return NULL;
1199 }
1200
1201 unsigned int
1202 _bfd_XXi_write_codeview_record (bfd * abfd, file_ptr where, CODEVIEW_INFO *cvinfo)
1203 {
1204   const bfd_size_type size = sizeof (CV_INFO_PDB70) + 1;
1205   bfd_size_type written;
1206   CV_INFO_PDB70 *cvinfo70;
1207   char * buffer;
1208
1209   if (bfd_seek (abfd, where, SEEK_SET) != 0)
1210     return 0;
1211
1212   buffer = xmalloc (size);
1213   cvinfo70 = (CV_INFO_PDB70 *) buffer;
1214   H_PUT_32 (abfd, CVINFO_PDB70_CVSIGNATURE, cvinfo70->CvSignature);
1215
1216   /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1217      in little-endian order, followed by 8 single bytes.  */
1218   bfd_putl32 (bfd_getb32 (cvinfo->Signature), cvinfo70->Signature);
1219   bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[4])), &(cvinfo70->Signature[4]));
1220   bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[6])), &(cvinfo70->Signature[6]));
1221   memcpy (&(cvinfo70->Signature[8]), &(cvinfo->Signature[8]), 8);
1222
1223   H_PUT_32 (abfd, cvinfo->Age, cvinfo70->Age);
1224   cvinfo70->PdbFileName[0] = '\0';
1225
1226   written = bfd_bwrite (buffer, size, abfd);
1227
1228   free (buffer);
1229
1230   return written == size ? size : 0;
1231 }
1232
1233 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1234 {
1235   N_("Export Directory [.edata (or where ever we found it)]"),
1236   N_("Import Directory [parts of .idata]"),
1237   N_("Resource Directory [.rsrc]"),
1238   N_("Exception Directory [.pdata]"),
1239   N_("Security Directory"),
1240   N_("Base Relocation Directory [.reloc]"),
1241   N_("Debug Directory"),
1242   N_("Description Directory"),
1243   N_("Special Directory"),
1244   N_("Thread Storage Directory [.tls]"),
1245   N_("Load Configuration Directory"),
1246   N_("Bound Import Directory"),
1247   N_("Import Address Table Directory"),
1248   N_("Delay Import Directory"),
1249   N_("CLR Runtime Header"),
1250   N_("Reserved")
1251 };
1252
1253 #ifdef POWERPC_LE_PE
1254 /* The code for the PPC really falls in the "architecture dependent"
1255    category.  However, it's not clear that anyone will ever care, so
1256    we're ignoring the issue for now; if/when PPC matters, some of this
1257    may need to go into peicode.h, or arguments passed to enable the
1258    PPC- specific code.  */
1259 #endif
1260
1261 static bfd_boolean
1262 pe_print_idata (bfd * abfd, void * vfile)
1263 {
1264   FILE *file = (FILE *) vfile;
1265   bfd_byte *data;
1266   asection *section;
1267   bfd_signed_vma adj;
1268
1269 #ifdef POWERPC_LE_PE
1270   asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1271 #endif
1272
1273   bfd_size_type datasize = 0;
1274   bfd_size_type dataoff;
1275   bfd_size_type i;
1276   int onaline = 20;
1277
1278   pe_data_type *pe = pe_data (abfd);
1279   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1280
1281   bfd_vma addr;
1282
1283   addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1284
1285   if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1286     {
1287       /* Maybe the extra header isn't there.  Look for the section.  */
1288       section = bfd_get_section_by_name (abfd, ".idata");
1289       if (section == NULL)
1290         return TRUE;
1291
1292       addr = section->vma;
1293       datasize = section->size;
1294       if (datasize == 0)
1295         return TRUE;
1296     }
1297   else
1298     {
1299       addr += extra->ImageBase;
1300       for (section = abfd->sections; section != NULL; section = section->next)
1301         {
1302           datasize = section->size;
1303           if (addr >= section->vma && addr < section->vma + datasize)
1304             break;
1305         }
1306
1307       if (section == NULL)
1308         {
1309           fprintf (file,
1310                    _("\nThere is an import table, but the section containing it could not be found\n"));
1311           return TRUE;
1312         }
1313       else if (!(section->flags & SEC_HAS_CONTENTS))
1314         {
1315           fprintf (file,
1316                    _("\nThere is an import table in %s, but that section has no contents\n"),
1317                    section->name);
1318           return TRUE;
1319         }
1320     }
1321
1322   /* xgettext:c-format */
1323   fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1324            section->name, (unsigned long) addr);
1325
1326   dataoff = addr - section->vma;
1327
1328 #ifdef POWERPC_LE_PE
1329   if (rel_section != 0 && rel_section->size != 0)
1330     {
1331       /* The toc address can be found by taking the starting address,
1332          which on the PPC locates a function descriptor. The
1333          descriptor consists of the function code starting address
1334          followed by the address of the toc. The starting address we
1335          get from the bfd, and the descriptor is supposed to be in the
1336          .reldata section.  */
1337
1338       bfd_vma loadable_toc_address;
1339       bfd_vma toc_address;
1340       bfd_vma start_address;
1341       bfd_byte *data;
1342       bfd_vma offset;
1343
1344       if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1345         {
1346           if (data != NULL)
1347             free (data);
1348           return FALSE;
1349         }
1350
1351       offset = abfd->start_address - rel_section->vma;
1352
1353       if (offset >= rel_section->size || offset + 8 > rel_section->size)
1354         {
1355           if (data != NULL)
1356             free (data);
1357           return FALSE;
1358         }
1359
1360       start_address = bfd_get_32 (abfd, data + offset);
1361       loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1362       toc_address = loadable_toc_address - 32768;
1363
1364       fprintf (file,
1365                _("\nFunction descriptor located at the start address: %04lx\n"),
1366                (unsigned long int) (abfd->start_address));
1367       fprintf (file,
1368                /* xgettext:c-format */
1369                _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1370                start_address, loadable_toc_address, toc_address);
1371       if (data != NULL)
1372         free (data);
1373     }
1374   else
1375     {
1376       fprintf (file,
1377                _("\nNo reldata section! Function descriptor not decoded.\n"));
1378     }
1379 #endif
1380
1381   fprintf (file,
1382            _("\nThe Import Tables (interpreted %s section contents)\n"),
1383            section->name);
1384   fprintf (file,
1385            _("\
1386  vma:            Hint    Time      Forward  DLL       First\n\
1387                  Table   Stamp     Chain    Name      Thunk\n"));
1388
1389   /* Read the whole section.  Some of the fields might be before dataoff.  */
1390   if (!bfd_malloc_and_get_section (abfd, section, &data))
1391     {
1392       if (data != NULL)
1393         free (data);
1394       return FALSE;
1395     }
1396
1397   adj = section->vma - extra->ImageBase;
1398
1399   /* Print all image import descriptors.  */
1400   for (i = dataoff; i + onaline <= datasize; i += onaline)
1401     {
1402       bfd_vma hint_addr;
1403       bfd_vma time_stamp;
1404       bfd_vma forward_chain;
1405       bfd_vma dll_name;
1406       bfd_vma first_thunk;
1407       int idx = 0;
1408       bfd_size_type j;
1409       char *dll;
1410
1411       /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress).  */
1412       fprintf (file, " %08lx\t", (unsigned long) (i + adj));
1413       hint_addr = bfd_get_32 (abfd, data + i);
1414       time_stamp = bfd_get_32 (abfd, data + i + 4);
1415       forward_chain = bfd_get_32 (abfd, data + i + 8);
1416       dll_name = bfd_get_32 (abfd, data + i + 12);
1417       first_thunk = bfd_get_32 (abfd, data + i + 16);
1418
1419       fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1420                (unsigned long) hint_addr,
1421                (unsigned long) time_stamp,
1422                (unsigned long) forward_chain,
1423                (unsigned long) dll_name,
1424                (unsigned long) first_thunk);
1425
1426       if (hint_addr == 0 && first_thunk == 0)
1427         break;
1428
1429       if (dll_name - adj >= section->size)
1430         break;
1431
1432       dll = (char *) data + dll_name - adj;
1433       /* PR 17512 file: 078-12277-0.004.  */
1434       bfd_size_type maxlen = (char *)(data + datasize) - dll - 1;
1435       fprintf (file, _("\n\tDLL Name: %.*s\n"), (int) maxlen, dll);
1436
1437       /* PR 21546: When the Hint Address is zero,
1438          we try the First Thunk instead.  */
1439       if (hint_addr == 0)
1440         hint_addr = first_thunk;
1441
1442       if (hint_addr != 0 && hint_addr - adj < datasize)
1443         {
1444           bfd_byte *ft_data;
1445           asection *ft_section;
1446           bfd_vma ft_addr;
1447           bfd_size_type ft_datasize;
1448           int ft_idx;
1449           int ft_allocated;
1450
1451           fprintf (file, _("\tvma:  Hint/Ord Member-Name Bound-To\n"));
1452
1453           idx = hint_addr - adj;
1454
1455           ft_addr = first_thunk + extra->ImageBase;
1456           ft_idx = first_thunk - adj;
1457           ft_data = data + ft_idx;
1458           ft_datasize = datasize - ft_idx;
1459           ft_allocated = 0;
1460
1461           if (first_thunk != hint_addr)
1462             {
1463               /* Find the section which contains the first thunk.  */
1464               for (ft_section = abfd->sections;
1465                    ft_section != NULL;
1466                    ft_section = ft_section->next)
1467                 {
1468                   if (ft_addr >= ft_section->vma
1469                       && ft_addr < ft_section->vma + ft_section->size)
1470                     break;
1471                 }
1472
1473               if (ft_section == NULL)
1474                 {
1475                   fprintf (file,
1476                        _("\nThere is a first thunk, but the section containing it could not be found\n"));
1477                   continue;
1478                 }
1479
1480               /* Now check to see if this section is the same as our current
1481                  section.  If it is not then we will have to load its data in.  */
1482               if (ft_section != section)
1483                 {
1484                   ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1485                   ft_datasize = ft_section->size - ft_idx;
1486                   ft_data = (bfd_byte *) bfd_malloc (ft_datasize);
1487                   if (ft_data == NULL)
1488                     continue;
1489
1490                   /* Read ft_datasize bytes starting at offset ft_idx.  */
1491                   if (!bfd_get_section_contents (abfd, ft_section, ft_data,
1492                                                  (bfd_vma) ft_idx, ft_datasize))
1493                     {
1494                       free (ft_data);
1495                       continue;
1496                     }
1497                   ft_allocated = 1;
1498                 }
1499             }
1500
1501           /* Print HintName vector entries.  */
1502 #ifdef COFF_WITH_pex64
1503           for (j = 0; idx + j + 8 <= datasize; j += 8)
1504             {
1505               bfd_size_type amt;
1506               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1507               unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1508
1509               if (!member && !member_high)
1510                 break;
1511
1512               amt = member - adj;
1513
1514               if (HighBitSet (member_high))
1515                 fprintf (file, "\t%lx%08lx\t %4lx%08lx  <none>",
1516                          member_high, member,
1517                          WithoutHighBit (member_high), member);
1518               /* PR binutils/17512: Handle corrupt PE data.  */
1519               else if (amt >= datasize || amt + 2 >= datasize)
1520                 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
1521               else
1522                 {
1523                   int ordinal;
1524                   char *member_name;
1525
1526                   ordinal = bfd_get_16 (abfd, data + amt);
1527                   member_name = (char *) data + amt + 2;
1528                   fprintf (file, "\t%04lx\t %4d  %.*s",member, ordinal,
1529                            (int) (datasize - (amt + 2)), member_name);
1530                 }
1531
1532               /* If the time stamp is not zero, the import address
1533                  table holds actual addresses.  */
1534               if (time_stamp != 0
1535                   && first_thunk != 0
1536                   && first_thunk != hint_addr
1537                   && j + 4 <= ft_datasize)
1538                 fprintf (file, "\t%04lx",
1539                          (unsigned long) bfd_get_32 (abfd, ft_data + j));
1540               fprintf (file, "\n");
1541             }
1542 #else
1543           for (j = 0; idx + j + 4 <= datasize; j += 4)
1544             {
1545               bfd_size_type amt;
1546               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1547
1548               /* Print single IMAGE_IMPORT_BY_NAME vector.  */
1549               if (member == 0)
1550                 break;
1551
1552               amt = member - adj;
1553
1554               if (HighBitSet (member))
1555                 fprintf (file, "\t%04lx\t %4lu  <none>",
1556                          member, WithoutHighBit (member));
1557               /* PR binutils/17512: Handle corrupt PE data.  */
1558               else if (amt >= datasize || amt + 2 >= datasize)
1559                 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
1560               else
1561                 {
1562                   int ordinal;
1563                   char *member_name;
1564
1565                   ordinal = bfd_get_16 (abfd, data + amt);
1566                   member_name = (char *) data + amt + 2;
1567                   fprintf (file, "\t%04lx\t %4d  %.*s",
1568                            member, ordinal,
1569                            (int) (datasize - (amt + 2)), member_name);
1570                 }
1571
1572               /* If the time stamp is not zero, the import address
1573                  table holds actual addresses.  */
1574               if (time_stamp != 0
1575                   && first_thunk != 0
1576                   && first_thunk != hint_addr
1577                   && j + 4 <= ft_datasize)
1578                 fprintf (file, "\t%04lx",
1579                          (unsigned long) bfd_get_32 (abfd, ft_data + j));
1580
1581               fprintf (file, "\n");
1582             }
1583 #endif
1584           if (ft_allocated)
1585             free (ft_data);
1586         }
1587
1588       fprintf (file, "\n");
1589     }
1590
1591   free (data);
1592
1593   return TRUE;
1594 }
1595
1596 static bfd_boolean
1597 pe_print_edata (bfd * abfd, void * vfile)
1598 {
1599   FILE *file = (FILE *) vfile;
1600   bfd_byte *data;
1601   asection *section;
1602   bfd_size_type datasize = 0;
1603   bfd_size_type dataoff;
1604   bfd_size_type i;
1605   bfd_vma       adj;
1606   struct EDT_type
1607   {
1608     long export_flags;          /* Reserved - should be zero.  */
1609     long time_stamp;
1610     short major_ver;
1611     short minor_ver;
1612     bfd_vma name;               /* RVA - relative to image base.  */
1613     long base;                  /* Ordinal base.  */
1614     unsigned long num_functions;/* Number in the export address table.  */
1615     unsigned long num_names;    /* Number in the name pointer table.  */
1616     bfd_vma eat_addr;           /* RVA to the export address table.  */
1617     bfd_vma npt_addr;           /* RVA to the Export Name Pointer Table.  */
1618     bfd_vma ot_addr;            /* RVA to the Ordinal Table.  */
1619   } edt;
1620
1621   pe_data_type *pe = pe_data (abfd);
1622   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1623
1624   bfd_vma addr;
1625
1626   addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1627
1628   if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1629     {
1630       /* Maybe the extra header isn't there.  Look for the section.  */
1631       section = bfd_get_section_by_name (abfd, ".edata");
1632       if (section == NULL)
1633         return TRUE;
1634
1635       addr = section->vma;
1636       dataoff = 0;
1637       datasize = section->size;
1638       if (datasize == 0)
1639         return TRUE;
1640     }
1641   else
1642     {
1643       addr += extra->ImageBase;
1644
1645       for (section = abfd->sections; section != NULL; section = section->next)
1646         if (addr >= section->vma && addr < section->vma + section->size)
1647           break;
1648
1649       if (section == NULL)
1650         {
1651           fprintf (file,
1652                    _("\nThere is an export table, but the section containing it could not be found\n"));
1653           return TRUE;
1654         }
1655       else if (!(section->flags & SEC_HAS_CONTENTS))
1656         {
1657           fprintf (file,
1658                    _("\nThere is an export table in %s, but that section has no contents\n"),
1659                    section->name);
1660           return TRUE;
1661         }
1662
1663       dataoff = addr - section->vma;
1664       datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1665       if (dataoff > section->size
1666           || datasize > section->size - dataoff)
1667         {
1668           fprintf (file,
1669                    _("\nThere is an export table in %s, but it does not fit into that section\n"),
1670                    section->name);
1671           return TRUE;
1672         }
1673     }
1674
1675   /* PR 17512: Handle corrupt PE binaries.  */
1676   if (datasize < 40)
1677     {
1678       fprintf (file,
1679                /* xgettext:c-format */
1680                _("\nThere is an export table in %s, but it is too small (%d)\n"),
1681                section->name, (int) datasize);
1682       return TRUE;
1683     }
1684
1685   /* xgettext:c-format */
1686   fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1687            section->name, (unsigned long) addr);
1688
1689   data = (bfd_byte *) bfd_malloc (datasize);
1690   if (data == NULL)
1691     return FALSE;
1692
1693   if (! bfd_get_section_contents (abfd, section, data,
1694                                   (file_ptr) dataoff, datasize))
1695     return FALSE;
1696
1697   /* Go get Export Directory Table.  */
1698   edt.export_flags   = bfd_get_32 (abfd, data +  0);
1699   edt.time_stamp     = bfd_get_32 (abfd, data +  4);
1700   edt.major_ver      = bfd_get_16 (abfd, data +  8);
1701   edt.minor_ver      = bfd_get_16 (abfd, data + 10);
1702   edt.name           = bfd_get_32 (abfd, data + 12);
1703   edt.base           = bfd_get_32 (abfd, data + 16);
1704   edt.num_functions  = bfd_get_32 (abfd, data + 20);
1705   edt.num_names      = bfd_get_32 (abfd, data + 24);
1706   edt.eat_addr       = bfd_get_32 (abfd, data + 28);
1707   edt.npt_addr       = bfd_get_32 (abfd, data + 32);
1708   edt.ot_addr        = bfd_get_32 (abfd, data + 36);
1709
1710   adj = section->vma - extra->ImageBase + dataoff;
1711
1712   /* Dump the EDT first.  */
1713   fprintf (file,
1714            _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1715            section->name);
1716
1717   fprintf (file,
1718            _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1719
1720   fprintf (file,
1721            _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1722
1723   fprintf (file,
1724            /* xgettext:c-format */
1725            _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1726
1727   fprintf (file,
1728            _("Name \t\t\t\t"));
1729   bfd_fprintf_vma (abfd, file, edt.name);
1730
1731   if ((edt.name >= adj) && (edt.name < adj + datasize))
1732     fprintf (file, " %.*s\n",
1733              (int) (datasize - (edt.name - adj)),
1734              data + edt.name - adj);
1735   else
1736     fprintf (file, "(outside .edata section)\n");
1737
1738   fprintf (file,
1739            _("Ordinal Base \t\t\t%ld\n"), edt.base);
1740
1741   fprintf (file,
1742            _("Number in:\n"));
1743
1744   fprintf (file,
1745            _("\tExport Address Table \t\t%08lx\n"),
1746            edt.num_functions);
1747
1748   fprintf (file,
1749            _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1750
1751   fprintf (file,
1752            _("Table Addresses\n"));
1753
1754   fprintf (file,
1755            _("\tExport Address Table \t\t"));
1756   bfd_fprintf_vma (abfd, file, edt.eat_addr);
1757   fprintf (file, "\n");
1758
1759   fprintf (file,
1760            _("\tName Pointer Table \t\t"));
1761   bfd_fprintf_vma (abfd, file, edt.npt_addr);
1762   fprintf (file, "\n");
1763
1764   fprintf (file,
1765            _("\tOrdinal Table \t\t\t"));
1766   bfd_fprintf_vma (abfd, file, edt.ot_addr);
1767   fprintf (file, "\n");
1768
1769   /* The next table to find is the Export Address Table. It's basically
1770      a list of pointers that either locate a function in this dll, or
1771      forward the call to another dll. Something like:
1772       typedef union
1773       {
1774         long export_rva;
1775         long forwarder_rva;
1776       } export_address_table_entry;  */
1777
1778   fprintf (file,
1779           _("\nExport Address Table -- Ordinal Base %ld\n"),
1780           edt.base);
1781
1782   /* PR 17512: Handle corrupt PE binaries.  */
1783   /* PR 17512 file: 140-165018-0.004.  */
1784   if (edt.eat_addr - adj >= datasize
1785       /* PR 17512: file: 092b1829 */
1786       || (edt.num_functions + 1) * 4 < edt.num_functions
1787       || edt.eat_addr - adj + (edt.num_functions + 1) * 4 > datasize)
1788     fprintf (file, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1789              (long) edt.eat_addr,
1790              (long) edt.num_functions);
1791   else for (i = 0; i < edt.num_functions; ++i)
1792     {
1793       bfd_vma eat_member = bfd_get_32 (abfd,
1794                                        data + edt.eat_addr + (i * 4) - adj);
1795       if (eat_member == 0)
1796         continue;
1797
1798       if (eat_member - adj <= datasize)
1799         {
1800           /* This rva is to a name (forwarding function) in our section.  */
1801           /* Should locate a function descriptor.  */
1802           fprintf (file,
1803                    "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1804                    (long) i,
1805                    (long) (i + edt.base),
1806                    (unsigned long) eat_member,
1807                    _("Forwarder RVA"),
1808                    (int)(datasize - (eat_member - adj)),
1809                    data + eat_member - adj);
1810         }
1811       else
1812         {
1813           /* Should locate a function descriptor in the reldata section.  */
1814           fprintf (file,
1815                    "\t[%4ld] +base[%4ld] %04lx %s\n",
1816                    (long) i,
1817                    (long) (i + edt.base),
1818                    (unsigned long) eat_member,
1819                    _("Export RVA"));
1820         }
1821     }
1822
1823   /* The Export Name Pointer Table is paired with the Export Ordinal Table.  */
1824   /* Dump them in parallel for clarity.  */
1825   fprintf (file,
1826            _("\n[Ordinal/Name Pointer] Table\n"));
1827
1828   /* PR 17512: Handle corrupt PE binaries.  */
1829   if (edt.npt_addr + (edt.num_names * 4) - adj >= datasize
1830       /* PR 17512: file: bb68816e.  */
1831       || edt.num_names * 4 < edt.num_names
1832       || (data + edt.npt_addr - adj) < data)
1833     /* xgettext:c-format */
1834     fprintf (file, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1835              (long) edt.npt_addr,
1836              (long) edt.num_names);
1837   /* PR 17512: file: 140-147171-0.004.  */
1838   else if (edt.ot_addr + (edt.num_names * 2) - adj >= datasize
1839            || data + edt.ot_addr - adj < data)
1840     /* xgettext:c-format */
1841     fprintf (file, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1842              (long) edt.ot_addr,
1843              (long) edt.num_names);
1844   else for (i = 0; i < edt.num_names; ++i)
1845     {
1846       bfd_vma  name_ptr;
1847       bfd_vma  ord;
1848
1849       ord = bfd_get_16 (abfd, data + edt.ot_addr + (i * 2) - adj);
1850       name_ptr = bfd_get_32 (abfd, data + edt.npt_addr + (i * 4) - adj);
1851
1852       if ((name_ptr - adj) >= datasize)
1853         {
1854           /* xgettext:c-format */
1855           fprintf (file, _("\t[%4ld] <corrupt offset: %lx>\n"),
1856                    (long) ord, (long) name_ptr);
1857         }
1858       else
1859         {
1860           char * name = (char *) data + name_ptr - adj;
1861
1862           fprintf (file, "\t[%4ld] %.*s\n", (long) ord,
1863                    (int)((char *)(data + datasize) - name), name);
1864         }
1865     }
1866
1867   free (data);
1868
1869   return TRUE;
1870 }
1871
1872 /* This really is architecture dependent.  On IA-64, a .pdata entry
1873    consists of three dwords containing relative virtual addresses that
1874    specify the start and end address of the code range the entry
1875    covers and the address of the corresponding unwind info data.
1876
1877    On ARM and SH-4, a compressed PDATA structure is used :
1878    _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1879    _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1880    See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1881
1882    This is the version for uncompressed data.  */
1883
1884 static bfd_boolean
1885 pe_print_pdata (bfd * abfd, void * vfile)
1886 {
1887 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1888 # define PDATA_ROW_SIZE (3 * 8)
1889 #else
1890 # define PDATA_ROW_SIZE (5 * 4)
1891 #endif
1892   FILE *file = (FILE *) vfile;
1893   bfd_byte *data = 0;
1894   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1895   bfd_size_type datasize = 0;
1896   bfd_size_type i;
1897   bfd_size_type start, stop;
1898   int onaline = PDATA_ROW_SIZE;
1899
1900   if (section == NULL
1901       || coff_section_data (abfd, section) == NULL
1902       || pei_section_data (abfd, section) == NULL)
1903     return TRUE;
1904
1905   stop = pei_section_data (abfd, section)->virt_size;
1906   if ((stop % onaline) != 0)
1907     fprintf (file,
1908              /* xgettext:c-format */
1909              _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1910              (long) stop, onaline);
1911
1912   fprintf (file,
1913            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1914 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1915   fprintf (file,
1916            _(" vma:\t\t\tBegin Address    End Address      Unwind Info\n"));
1917 #else
1918   fprintf (file, _("\
1919  vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n\
1920      \t\tAddress  Address  Handler  Data     Address    Mask\n"));
1921 #endif
1922
1923   datasize = section->size;
1924   if (datasize == 0)
1925     return TRUE;
1926
1927   /* PR 17512: file: 002-193900-0.004.  */
1928   if (datasize < stop)
1929     {
1930       /* xgettext:c-format */
1931       fprintf (file, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1932                (long) stop, (long) datasize);
1933       return FALSE;
1934     }
1935
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   for (i = start; i < stop; i += onaline)
1946     {
1947       bfd_vma begin_addr;
1948       bfd_vma end_addr;
1949       bfd_vma eh_handler;
1950       bfd_vma eh_data;
1951       bfd_vma prolog_end_addr;
1952 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1953       int em_data;
1954 #endif
1955
1956       if (i + PDATA_ROW_SIZE > stop)
1957         break;
1958
1959       begin_addr      = GET_PDATA_ENTRY (abfd, data + i     );
1960       end_addr        = GET_PDATA_ENTRY (abfd, data + i +  4);
1961       eh_handler      = GET_PDATA_ENTRY (abfd, data + i +  8);
1962       eh_data         = GET_PDATA_ENTRY (abfd, data + i + 12);
1963       prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1964
1965       if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1966           && eh_data == 0 && prolog_end_addr == 0)
1967         /* We are probably into the padding of the section now.  */
1968         break;
1969
1970 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1971       em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1972 #endif
1973       eh_handler &= ~(bfd_vma) 0x3;
1974       prolog_end_addr &= ~(bfd_vma) 0x3;
1975
1976       fputc (' ', file);
1977       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1978       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1979       bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1980       bfd_fprintf_vma (abfd, file, eh_handler);
1981 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1982       fputc (' ', file);
1983       bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1984       bfd_fprintf_vma (abfd, file, prolog_end_addr);
1985       fprintf (file, "   %x", em_data);
1986 #endif
1987
1988 #ifdef POWERPC_LE_PE
1989       if (eh_handler == 0 && eh_data != 0)
1990         {
1991           /* Special bits here, although the meaning may be a little
1992              mysterious. The only one I know for sure is 0x03
1993              Code Significance
1994              0x00 None
1995              0x01 Register Save Millicode
1996              0x02 Register Restore Millicode
1997              0x03 Glue Code Sequence.  */
1998           switch (eh_data)
1999             {
2000             case 0x01:
2001               fprintf (file, _(" Register save millicode"));
2002               break;
2003             case 0x02:
2004               fprintf (file, _(" Register restore millicode"));
2005               break;
2006             case 0x03:
2007               fprintf (file, _(" Glue code sequence"));
2008               break;
2009             default:
2010               break;
2011             }
2012         }
2013 #endif
2014       fprintf (file, "\n");
2015     }
2016
2017   free (data);
2018
2019   return TRUE;
2020 #undef PDATA_ROW_SIZE
2021 }
2022
2023 typedef struct sym_cache
2024 {
2025   int        symcount;
2026   asymbol ** syms;
2027 } sym_cache;
2028
2029 static asymbol **
2030 slurp_symtab (bfd *abfd, sym_cache *psc)
2031 {
2032   asymbol ** sy = NULL;
2033   long storage;
2034
2035   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
2036     {
2037       psc->symcount = 0;
2038       return NULL;
2039     }
2040
2041   storage = bfd_get_symtab_upper_bound (abfd);
2042   if (storage < 0)
2043     return NULL;
2044   if (storage)
2045     {
2046       sy = (asymbol **) bfd_malloc (storage);
2047       if (sy == NULL)
2048         return NULL;
2049     }
2050
2051   psc->symcount = bfd_canonicalize_symtab (abfd, sy);
2052   if (psc->symcount < 0)
2053     return NULL;
2054   return sy;
2055 }
2056
2057 static const char *
2058 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
2059 {
2060   int i;
2061
2062   if (psc->syms == 0)
2063     psc->syms = slurp_symtab (abfd, psc);
2064
2065   for (i = 0; i < psc->symcount; i++)
2066     {
2067       if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
2068         return psc->syms[i]->name;
2069     }
2070
2071   return NULL;
2072 }
2073
2074 static void
2075 cleanup_syms (sym_cache *psc)
2076 {
2077   psc->symcount = 0;
2078   free (psc->syms);
2079   psc->syms = NULL;
2080 }
2081
2082 /* This is the version for "compressed" pdata.  */
2083
2084 bfd_boolean
2085 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
2086 {
2087 # define PDATA_ROW_SIZE (2 * 4)
2088   FILE *file = (FILE *) vfile;
2089   bfd_byte *data = NULL;
2090   asection *section = bfd_get_section_by_name (abfd, ".pdata");
2091   bfd_size_type datasize = 0;
2092   bfd_size_type i;
2093   bfd_size_type start, stop;
2094   int onaline = PDATA_ROW_SIZE;
2095   struct sym_cache cache = {0, 0} ;
2096
2097   if (section == NULL
2098       || coff_section_data (abfd, section) == NULL
2099       || pei_section_data (abfd, section) == NULL)
2100     return TRUE;
2101
2102   stop = pei_section_data (abfd, section)->virt_size;
2103   if ((stop % onaline) != 0)
2104     fprintf (file,
2105              /* xgettext:c-format */
2106              _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2107              (long) stop, onaline);
2108
2109   fprintf (file,
2110            _("\nThe Function Table (interpreted .pdata section contents)\n"));
2111
2112   fprintf (file, _("\
2113  vma:\t\tBegin    Prolog   Function Flags    Exception EH\n\
2114      \t\tAddress  Length   Length   32b exc  Handler   Data\n"));
2115
2116   datasize = section->size;
2117   if (datasize == 0)
2118     return TRUE;
2119
2120   if (! bfd_malloc_and_get_section (abfd, section, &data))
2121     {
2122       if (data != NULL)
2123         free (data);
2124       return FALSE;
2125     }
2126
2127   start = 0;
2128
2129   for (i = start; i < stop; i += onaline)
2130     {
2131       bfd_vma begin_addr;
2132       bfd_vma other_data;
2133       bfd_vma prolog_length, function_length;
2134       int flag32bit, exception_flag;
2135       asection *tsection;
2136
2137       if (i + PDATA_ROW_SIZE > stop)
2138         break;
2139
2140       begin_addr = GET_PDATA_ENTRY (abfd, data + i     );
2141       other_data = GET_PDATA_ENTRY (abfd, data + i +  4);
2142
2143       if (begin_addr == 0 && other_data == 0)
2144         /* We are probably into the padding of the section now.  */
2145         break;
2146
2147       prolog_length = (other_data & 0x000000FF);
2148       function_length = (other_data & 0x3FFFFF00) >> 8;
2149       flag32bit = (int)((other_data & 0x40000000) >> 30);
2150       exception_flag = (int)((other_data & 0x80000000) >> 31);
2151
2152       fputc (' ', file);
2153       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
2154       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
2155       bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
2156       bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
2157       fprintf (file, "%2d  %2d   ", flag32bit, exception_flag);
2158
2159       /* Get the exception handler's address and the data passed from the
2160          .text section. This is really the data that belongs with the .pdata
2161          but got "compressed" out for the ARM and SH4 architectures.  */
2162       tsection = bfd_get_section_by_name (abfd, ".text");
2163       if (tsection && coff_section_data (abfd, tsection)
2164           && pei_section_data (abfd, tsection))
2165         {
2166           bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
2167           bfd_byte *tdata;
2168
2169           tdata = (bfd_byte *) bfd_malloc (8);
2170           if (tdata)
2171             {
2172               if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
2173                 {
2174                   bfd_vma eh, eh_data;
2175
2176                   eh = bfd_get_32 (abfd, tdata);
2177                   eh_data = bfd_get_32 (abfd, tdata + 4);
2178                   fprintf (file, "%08x  ", (unsigned int) eh);
2179                   fprintf (file, "%08x", (unsigned int) eh_data);
2180                   if (eh != 0)
2181                     {
2182                       const char *s = my_symbol_for_address (abfd, eh, &cache);
2183
2184                       if (s)
2185                         fprintf (file, " (%s) ", s);
2186                     }
2187                 }
2188               free (tdata);
2189             }
2190         }
2191
2192       fprintf (file, "\n");
2193     }
2194
2195   free (data);
2196
2197   cleanup_syms (& cache);
2198
2199   return TRUE;
2200 #undef PDATA_ROW_SIZE
2201 }
2202
2203 \f
2204 #define IMAGE_REL_BASED_HIGHADJ 4
2205 static const char * const tbl[] =
2206 {
2207   "ABSOLUTE",
2208   "HIGH",
2209   "LOW",
2210   "HIGHLOW",
2211   "HIGHADJ",
2212   "MIPS_JMPADDR",
2213   "SECTION",
2214   "REL32",
2215   "RESERVED1",
2216   "MIPS_JMPADDR16",
2217   "DIR64",
2218   "HIGH3ADJ",
2219   "UNKNOWN",   /* MUST be last.  */
2220 };
2221
2222 static bfd_boolean
2223 pe_print_reloc (bfd * abfd, void * vfile)
2224 {
2225   FILE *file = (FILE *) vfile;
2226   bfd_byte *data = 0;
2227   asection *section = bfd_get_section_by_name (abfd, ".reloc");
2228   bfd_byte *p, *end;
2229
2230   if (section == NULL || section->size == 0 || !(section->flags & SEC_HAS_CONTENTS))
2231     return TRUE;
2232
2233   fprintf (file,
2234            _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2235
2236   if (! bfd_malloc_and_get_section (abfd, section, &data))
2237     {
2238       if (data != NULL)
2239         free (data);
2240       return FALSE;
2241     }
2242
2243   p = data;
2244   end = data + section->size;
2245   while (p + 8 <= end)
2246     {
2247       int j;
2248       bfd_vma virtual_address;
2249       unsigned long number, size;
2250       bfd_byte *chunk_end;
2251
2252       /* The .reloc section is a sequence of blocks, with a header consisting
2253          of two 32 bit quantities, followed by a number of 16 bit entries.  */
2254       virtual_address = bfd_get_32 (abfd, p);
2255       size = bfd_get_32 (abfd, p + 4);
2256       p += 8;
2257       number = (size - 8) / 2;
2258
2259       if (size == 0)
2260         break;
2261
2262       fprintf (file,
2263                /* xgettext:c-format */
2264                _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2265                (unsigned long) virtual_address, size, size, number);
2266
2267       chunk_end = p - 8 + size;
2268       if (chunk_end > end)
2269         chunk_end = end;
2270       j = 0;
2271       while (p + 2 <= chunk_end)
2272         {
2273           unsigned short e = bfd_get_16 (abfd, p);
2274           unsigned int t = (e & 0xF000) >> 12;
2275           int off = e & 0x0FFF;
2276
2277           if (t >= sizeof (tbl) / sizeof (tbl[0]))
2278             t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
2279
2280           fprintf (file,
2281                    /* xgettext:c-format */
2282                    _("\treloc %4d offset %4x [%4lx] %s"),
2283                    j, off, (unsigned long) (off + virtual_address), tbl[t]);
2284
2285           p += 2;
2286           j++;
2287
2288           /* HIGHADJ takes an argument, - the next record *is* the
2289              low 16 bits of addend.  */
2290           if (t == IMAGE_REL_BASED_HIGHADJ && p + 2 <= chunk_end)
2291             {
2292               fprintf (file, " (%4x)", (unsigned int) bfd_get_16 (abfd, p));
2293               p += 2;
2294               j++;
2295             }
2296
2297           fprintf (file, "\n");
2298         }
2299     }
2300
2301   free (data);
2302
2303   return TRUE;
2304 }
2305 \f
2306 /* A data structure describing the regions of a .rsrc section.
2307    Some fields are filled in as the section is parsed.  */
2308
2309 typedef struct rsrc_regions
2310 {
2311   bfd_byte * section_start;
2312   bfd_byte * section_end;
2313   bfd_byte * strings_start;
2314   bfd_byte * resource_start;
2315 } rsrc_regions;
2316
2317 static bfd_byte *
2318 rsrc_print_resource_directory (FILE * , bfd *, unsigned int, bfd_byte *,
2319                                rsrc_regions *, bfd_vma);
2320
2321 /* Print the resource entry at DATA, with the text indented by INDENT.
2322    Recusively calls rsrc_print_resource_directory to print the contents
2323    of directory entries.
2324    Returns the address of the end of the data associated with the entry
2325    or section_end + 1 upon failure.  */
2326
2327 static bfd_byte *
2328 rsrc_print_resource_entries (FILE *         file,
2329                              bfd *          abfd,
2330                              unsigned int   indent,
2331                              bfd_boolean    is_name,
2332                              bfd_byte *     data,
2333                              rsrc_regions * regions,
2334                              bfd_vma        rva_bias)
2335 {
2336   unsigned long entry, addr, size;
2337   bfd_byte * leaf;
2338
2339   if (data + 8 >= regions->section_end)
2340     return regions->section_end + 1;
2341
2342   /* xgettext:c-format */
2343   fprintf (file, _("%03x %*.s Entry: "), (int)(data - regions->section_start), indent, " ");
2344
2345   entry = (unsigned long) bfd_get_32 (abfd, data);
2346   if (is_name)
2347     {
2348       bfd_byte * name;
2349
2350       /* Note - the documentation says that this field is an RVA value
2351          but windres appears to produce a section relative offset with
2352          the top bit set.  Support both styles for now.  */
2353       if (HighBitSet (entry))
2354         name = regions->section_start + WithoutHighBit (entry);
2355       else
2356         name = regions->section_start + entry - rva_bias;
2357
2358       if (name + 2 < regions->section_end && name > regions->section_start)
2359         {
2360           unsigned int len;
2361
2362           if (regions->strings_start == NULL)
2363             regions->strings_start = name;
2364
2365           len = bfd_get_16 (abfd, name);
2366
2367           fprintf (file, _("name: [val: %08lx len %d]: "), entry, len);
2368
2369           if (name + 2 + len * 2 < regions->section_end)
2370             {
2371               /* This strange loop is to cope with multibyte characters.  */
2372               while (len --)
2373                 {
2374                   char c;
2375
2376                   name += 2;
2377                   c = * name;
2378                   /* Avoid printing control characters.  */
2379                   if (c > 0 && c < 32)
2380                     fprintf (file, "^%c", c + 64);
2381                   else
2382                     fprintf (file, "%.1s", name);
2383                 }
2384             }
2385           else
2386             {
2387               fprintf (file, _("<corrupt string length: %#x>\n"), len);
2388               /* PR binutils/17512: Do not try to continue decoding a
2389                  corrupted resource section.  It is likely to end up with
2390                  reams of extraneous output.  FIXME: We could probably
2391                  continue if we disable the printing of strings...  */
2392               return regions->section_end + 1;
2393             }
2394         }
2395       else
2396         {
2397           fprintf (file, _("<corrupt string offset: %#lx>\n"), entry);
2398           return regions->section_end + 1;
2399         }
2400     }
2401   else
2402     fprintf (file, _("ID: %#08lx"), entry);
2403
2404   entry = (long) bfd_get_32 (abfd, data + 4);
2405   fprintf (file, _(", Value: %#08lx\n"), entry);
2406
2407   if (HighBitSet  (entry))
2408     {
2409       data = regions->section_start + WithoutHighBit (entry);
2410       if (data <= regions->section_start || data > regions->section_end)
2411         return regions->section_end + 1;
2412
2413       /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2414          in the resource table.  We need some way to detect this.  */
2415       return rsrc_print_resource_directory (file, abfd, indent + 1, data,
2416                                             regions, rva_bias);
2417     }
2418
2419   leaf = regions->section_start + entry;
2420
2421   if (leaf + 16 >= regions->section_end
2422       /* PR 17512: file: 055dff7e.  */
2423       || leaf < regions->section_start)
2424     return regions->section_end + 1;
2425
2426   /* xgettext:c-format */
2427   fprintf (file, _("%03x %*.s  Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2428            (int) (entry), indent, " ",
2429            addr = (long) bfd_get_32 (abfd, leaf),
2430            size = (long) bfd_get_32 (abfd, leaf + 4),
2431            (int) bfd_get_32 (abfd, leaf + 8));
2432
2433   /* Check that the reserved entry is 0.  */
2434   if (bfd_get_32 (abfd, leaf + 12) != 0
2435       /* And that the data address/size is valid too.  */
2436       || (regions->section_start + (addr - rva_bias) + size > regions->section_end))
2437     return regions->section_end + 1;
2438
2439   if (regions->resource_start == NULL)
2440     regions->resource_start = regions->section_start + (addr - rva_bias);
2441
2442   return regions->section_start + (addr - rva_bias) + size;
2443 }
2444
2445 #define max(a,b) ((a) > (b) ? (a) : (b))
2446 #define min(a,b) ((a) < (b) ? (a) : (b))
2447
2448 static bfd_byte *
2449 rsrc_print_resource_directory (FILE *         file,
2450                                bfd *          abfd,
2451                                unsigned int   indent,
2452                                bfd_byte *     data,
2453                                rsrc_regions * regions,
2454                                bfd_vma        rva_bias)
2455 {
2456   unsigned int num_names, num_ids;
2457   bfd_byte * highest_data = data;
2458
2459   if (data + 16 >= regions->section_end)
2460     return regions->section_end + 1;
2461
2462   fprintf (file, "%03x %*.s ", (int)(data - regions->section_start), indent, " ");
2463   switch (indent)
2464     {
2465     case 0: fprintf (file, "Type"); break;
2466     case 2: fprintf (file, "Name"); break;
2467     case 4: fprintf (file, "Language"); break;
2468     default:
2469       fprintf (file, _("<unknown directory type: %d>\n"), indent);
2470       /* FIXME: For now we end the printing here.  If in the
2471          future more directory types are added to the RSRC spec
2472          then we will need to change this.  */
2473       return regions->section_end + 1;
2474     }
2475
2476   /* xgettext:c-format */
2477   fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2478            (int) bfd_get_32 (abfd, data),
2479            (long) bfd_get_32 (abfd, data + 4),
2480            (int)  bfd_get_16 (abfd, data + 8),
2481            (int)  bfd_get_16 (abfd, data + 10),
2482            num_names = (int) bfd_get_16 (abfd, data + 12),
2483            num_ids =   (int) bfd_get_16 (abfd, data + 14));
2484   data += 16;
2485
2486   while (num_names --)
2487     {
2488       bfd_byte * entry_end;
2489
2490       entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE,
2491                                                data, regions, rva_bias);
2492       data += 8;
2493       highest_data = max (highest_data, entry_end);
2494       if (entry_end >= regions->section_end)
2495         return entry_end;
2496     }
2497
2498   while (num_ids --)
2499     {
2500       bfd_byte * entry_end;
2501
2502       entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE,
2503                                                data, regions, rva_bias);
2504       data += 8;
2505       highest_data = max (highest_data, entry_end);
2506       if (entry_end >= regions->section_end)
2507         return entry_end;
2508     }
2509
2510   return max (highest_data, data);
2511 }
2512
2513 /* Display the contents of a .rsrc section.  We do not try to
2514    reproduce the resources, windres does that.  Instead we dump
2515    the tables in a human readable format.  */
2516
2517 static bfd_boolean
2518 rsrc_print_section (bfd * abfd, void * vfile)
2519 {
2520   bfd_vma rva_bias;
2521   pe_data_type * pe;
2522   FILE * file = (FILE *) vfile;
2523   bfd_size_type datasize;
2524   asection * section;
2525   bfd_byte * data;
2526   rsrc_regions regions;
2527
2528   pe = pe_data (abfd);
2529   if (pe == NULL)
2530     return TRUE;
2531
2532   section = bfd_get_section_by_name (abfd, ".rsrc");
2533   if (section == NULL)
2534     return TRUE;
2535   if (!(section->flags & SEC_HAS_CONTENTS))
2536     return TRUE;
2537
2538   datasize = section->size;
2539   if (datasize == 0)
2540     return TRUE;
2541
2542   rva_bias = section->vma - pe->pe_opthdr.ImageBase;
2543
2544   if (! bfd_malloc_and_get_section (abfd, section, & data))
2545     {
2546       if (data != NULL)
2547         free (data);
2548       return FALSE;
2549     }
2550
2551   regions.section_start = data;
2552   regions.section_end = data + datasize;
2553   regions.strings_start = NULL;
2554   regions.resource_start = NULL;
2555
2556   fflush (file);
2557   fprintf (file, "\nThe .rsrc Resource Directory section:\n");
2558
2559   while (data < regions.section_end)
2560     {
2561       bfd_byte * p = data;
2562
2563       data = rsrc_print_resource_directory (file, abfd, 0, data, & regions, rva_bias);
2564
2565       if (data == regions.section_end + 1)
2566         fprintf (file, _("Corrupt .rsrc section detected!\n"));
2567       else
2568         {
2569           /* Align data before continuing.  */
2570           int align = (1 << section->alignment_power) - 1;
2571
2572           data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align);
2573           rva_bias += data - p;
2574
2575           /* For reasons that are unclear .rsrc sections are sometimes created
2576              aligned to a 1^3 boundary even when their alignment is set at
2577              1^2.  Catch that case here before we issue a spurious warning
2578              message.  */
2579           if (data == (regions.section_end - 4))
2580             data = regions.section_end;
2581           else if (data < regions.section_end)
2582             {
2583               /* If the extra data is all zeros then do not complain.
2584                  This is just padding so that the section meets the
2585                  page size requirements.  */
2586               while (++ data < regions.section_end)
2587                 if (*data != 0)
2588                   break;
2589               if (data < regions.section_end)
2590                 fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2591             }
2592         }
2593     }
2594
2595   if (regions.strings_start != NULL)
2596     fprintf (file, _(" String table starts at offset: %#03x\n"),
2597              (int) (regions.strings_start - regions.section_start));
2598   if (regions.resource_start != NULL)
2599     fprintf (file, _(" Resources start at offset: %#03x\n"),
2600              (int) (regions.resource_start - regions.section_start));
2601
2602   free (regions.section_start);
2603   return TRUE;
2604 }
2605
2606 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2607
2608 static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] =
2609 {
2610   "Unknown",
2611   "COFF",
2612   "CodeView",
2613   "FPO",
2614   "Misc",
2615   "Exception",
2616   "Fixup",
2617   "OMAP-to-SRC",
2618   "OMAP-from-SRC",
2619   "Borland",
2620   "Reserved",
2621   "CLSID",
2622 };
2623
2624 static bfd_boolean
2625 pe_print_debugdata (bfd * abfd, void * vfile)
2626 {
2627   FILE *file = (FILE *) vfile;
2628   pe_data_type *pe = pe_data (abfd);
2629   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
2630   asection *section;
2631   bfd_byte *data = 0;
2632   bfd_size_type dataoff;
2633   unsigned int i;
2634
2635   bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
2636   bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
2637
2638   if (size == 0)
2639     return TRUE;
2640
2641   addr += extra->ImageBase;
2642   for (section = abfd->sections; section != NULL; section = section->next)
2643     {
2644       if ((addr >= section->vma) && (addr < (section->vma + section->size)))
2645         break;
2646     }
2647
2648   if (section == NULL)
2649     {
2650       fprintf (file,
2651                _("\nThere is a debug directory, but the section containing it could not be found\n"));
2652       return TRUE;
2653     }
2654   else if (!(section->flags & SEC_HAS_CONTENTS))
2655     {
2656       fprintf (file,
2657                _("\nThere is a debug directory in %s, but that section has no contents\n"),
2658                section->name);
2659       return TRUE;
2660     }
2661   else if (section->size < size)
2662     {
2663       fprintf (file,
2664                _("\nError: section %s contains the debug data starting address but it is too small\n"),
2665                section->name);
2666       return FALSE;
2667     }
2668
2669   fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2670            section->name, (unsigned long) addr);
2671
2672   dataoff = addr - section->vma;
2673
2674   if (size > (section->size - dataoff))
2675     {
2676       fprintf (file, _("The debug data size field in the data directory is too big for the section"));
2677       return FALSE;
2678     }
2679
2680   fprintf (file,
2681            _("Type                Size     Rva      Offset\n"));
2682
2683   /* Read the whole section.  */
2684   if (!bfd_malloc_and_get_section (abfd, section, &data))
2685     {
2686       if (data != NULL)
2687         free (data);
2688       return FALSE;
2689     }
2690
2691   for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2692     {
2693       const char *type_name;
2694       struct external_IMAGE_DEBUG_DIRECTORY *ext
2695         = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
2696       struct internal_IMAGE_DEBUG_DIRECTORY idd;
2697
2698       _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
2699
2700       if ((idd.Type) >= IMAGE_NUMBEROF_DEBUG_TYPES)
2701         type_name = debug_type_names[0];
2702       else
2703         type_name = debug_type_names[idd.Type];
2704
2705       fprintf (file, " %2ld  %14s %08lx %08lx %08lx\n",
2706                idd.Type, type_name, idd.SizeOfData,
2707                idd.AddressOfRawData, idd.PointerToRawData);
2708
2709       if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
2710         {
2711           char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1];
2712           /* PR 17512: file: 065-29434-0.001:0.1
2713              We need to use a 32-bit aligned buffer
2714              to safely read in a codeview record.  */
2715           char buffer[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO);
2716
2717           CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
2718
2719           /* The debug entry doesn't have to have to be in a section,
2720              in which case AddressOfRawData is 0, so always use PointerToRawData.  */
2721           if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData,
2722                                                idd.SizeOfData, cvinfo))
2723             continue;
2724
2725           for (i = 0; i < cvinfo->SignatureLength; i++)
2726             sprintf (&signature[i*2], "%02x", cvinfo->Signature[i] & 0xff);
2727
2728           /* xgettext:c-format */
2729           fprintf (file, _("(format %c%c%c%c signature %s age %ld)\n"),
2730                    buffer[0], buffer[1], buffer[2], buffer[3],
2731                    signature, cvinfo->Age);
2732         }
2733     }
2734
2735   if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0)
2736     fprintf (file,
2737             _("The debug directory size is not a multiple of the debug directory entry size\n"));
2738
2739   return TRUE;
2740 }
2741
2742 /* Print out the program headers.  */
2743
2744 bfd_boolean
2745 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2746 {
2747   FILE *file = (FILE *) vfile;
2748   int j;
2749   pe_data_type *pe = pe_data (abfd);
2750   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2751   const char *subsystem_name = NULL;
2752   const char *name;
2753
2754   /* The MS dumpbin program reportedly ands with 0xff0f before
2755      printing the characteristics field.  Not sure why.  No reason to
2756      emulate it here.  */
2757   fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2758 #undef PF
2759 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2760   PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2761   PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2762   PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2763   PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2764   PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2765   PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2766   PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2767   PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2768   PF (IMAGE_FILE_SYSTEM, "system file");
2769   PF (IMAGE_FILE_DLL, "DLL");
2770   PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2771 #undef PF
2772
2773   /* ctime implies '\n'.  */
2774   {
2775     time_t t = pe->coff.timestamp;
2776     fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2777   }
2778
2779 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2780 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2781 #endif
2782 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2783 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2784 #endif
2785 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2786 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2787 #endif
2788
2789   switch (i->Magic)
2790     {
2791     case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2792       name = "PE32";
2793       break;
2794     case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2795       name = "PE32+";
2796       break;
2797     case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2798       name = "ROM";
2799       break;
2800     default:
2801       name = NULL;
2802       break;
2803     }
2804   fprintf (file, "Magic\t\t\t%04x", i->Magic);
2805   if (name)
2806     fprintf (file, "\t(%s)",name);
2807   fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2808   fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2809   fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2810   fprintf (file, "SizeOfInitializedData\t%08lx\n",
2811            (unsigned long) i->SizeOfInitializedData);
2812   fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2813            (unsigned long) i->SizeOfUninitializedData);
2814   fprintf (file, "AddressOfEntryPoint\t");
2815   bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2816   fprintf (file, "\nBaseOfCode\t\t");
2817   bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2818 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2819   /* PE32+ does not have BaseOfData member!  */
2820   fprintf (file, "\nBaseOfData\t\t");
2821   bfd_fprintf_vma (abfd, file, i->BaseOfData);
2822 #endif
2823
2824   fprintf (file, "\nImageBase\t\t");
2825   bfd_fprintf_vma (abfd, file, i->ImageBase);
2826   fprintf (file, "\nSectionAlignment\t");
2827   bfd_fprintf_vma (abfd, file, i->SectionAlignment);
2828   fprintf (file, "\nFileAlignment\t\t");
2829   bfd_fprintf_vma (abfd, file, i->FileAlignment);
2830   fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2831   fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2832   fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2833   fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2834   fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2835   fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2836   fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2837   fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2838   fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2839   fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2840
2841   switch (i->Subsystem)
2842     {
2843     case IMAGE_SUBSYSTEM_UNKNOWN:
2844       subsystem_name = "unspecified";
2845       break;
2846     case IMAGE_SUBSYSTEM_NATIVE:
2847       subsystem_name = "NT native";
2848       break;
2849     case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2850       subsystem_name = "Windows GUI";
2851       break;
2852     case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2853       subsystem_name = "Windows CUI";
2854       break;
2855     case IMAGE_SUBSYSTEM_POSIX_CUI:
2856       subsystem_name = "POSIX CUI";
2857       break;
2858     case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2859       subsystem_name = "Wince CUI";
2860       break;
2861     // These are from UEFI Platform Initialization Specification 1.1.
2862     case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2863       subsystem_name = "EFI application";
2864       break;
2865     case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2866       subsystem_name = "EFI boot service driver";
2867       break;
2868     case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2869       subsystem_name = "EFI runtime driver";
2870       break;
2871     case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2872       subsystem_name = "SAL runtime driver";
2873       break;
2874     // This is from revision 8.0 of the MS PE/COFF spec
2875     case IMAGE_SUBSYSTEM_XBOX:
2876       subsystem_name = "XBOX";
2877       break;
2878     // Added default case for clarity - subsystem_name is NULL anyway.
2879     default:
2880       subsystem_name = NULL;
2881     }
2882
2883   fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2884   if (subsystem_name)
2885     fprintf (file, "\t(%s)", subsystem_name);
2886   fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2887   fprintf (file, "SizeOfStackReserve\t");
2888   bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
2889   fprintf (file, "\nSizeOfStackCommit\t");
2890   bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
2891   fprintf (file, "\nSizeOfHeapReserve\t");
2892   bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
2893   fprintf (file, "\nSizeOfHeapCommit\t");
2894   bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
2895   fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2896   fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2897            (unsigned long) i->NumberOfRvaAndSizes);
2898
2899   fprintf (file, "\nThe Data Directory\n");
2900   for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2901     {
2902       fprintf (file, "Entry %1x ", j);
2903       bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
2904       fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2905       fprintf (file, "%s\n", dir_names[j]);
2906     }
2907
2908   pe_print_idata (abfd, vfile);
2909   pe_print_edata (abfd, vfile);
2910   if (bfd_coff_have_print_pdata (abfd))
2911     bfd_coff_print_pdata (abfd, vfile);
2912   else
2913     pe_print_pdata (abfd, vfile);
2914   pe_print_reloc (abfd, vfile);
2915   pe_print_debugdata (abfd, file);
2916
2917   rsrc_print_section (abfd, vfile);
2918
2919   return TRUE;
2920 }
2921
2922 static bfd_boolean
2923 is_vma_in_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
2924 {
2925   bfd_vma addr = * (bfd_vma *) obj;
2926   return (addr >= sect->vma) && (addr < (sect->vma + sect->size));
2927 }
2928
2929 static asection *
2930 find_section_by_vma (bfd *abfd, bfd_vma addr)
2931 {
2932   return bfd_sections_find_if (abfd, is_vma_in_section, (void *) & addr);
2933 }
2934
2935 /* Copy any private info we understand from the input bfd
2936    to the output bfd.  */
2937
2938 bfd_boolean
2939 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2940 {
2941   pe_data_type *ipe, *ope;
2942
2943   /* One day we may try to grok other private data.  */
2944   if (ibfd->xvec->flavour != bfd_target_coff_flavour
2945       || obfd->xvec->flavour != bfd_target_coff_flavour)
2946     return TRUE;
2947
2948   ipe = pe_data (ibfd);
2949   ope = pe_data (obfd);
2950
2951   /* pe_opthdr is copied in copy_object.  */
2952   ope->dll = ipe->dll;
2953
2954   /* Don't copy input subsystem if output is different from input.  */
2955   if (obfd->xvec != ibfd->xvec)
2956     ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2957
2958   /* For strip: if we removed .reloc, we'll make a real mess of things
2959      if we don't remove this entry as well.  */
2960   if (! pe_data (obfd)->has_reloc_section)
2961     {
2962       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2963       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2964     }
2965
2966   /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2967      But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2968      won't be added.  */
2969   if (! pe_data (ibfd)->has_reloc_section
2970       && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
2971     pe_data (obfd)->dont_strip_reloc = 1;
2972
2973   /* The file offsets contained in the debug directory need rewriting.  */
2974   if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size != 0)
2975     {
2976       bfd_vma addr = ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].VirtualAddress
2977         + ope->pe_opthdr.ImageBase;
2978       asection *section = find_section_by_vma (obfd, addr);
2979       bfd_byte *data;
2980
2981       if (section && bfd_malloc_and_get_section (obfd, section, &data))
2982         {
2983           unsigned int i;
2984           struct external_IMAGE_DEBUG_DIRECTORY *dd =
2985             (struct external_IMAGE_DEBUG_DIRECTORY *)(data + (addr - section->vma));
2986
2987           /* PR 17512: file: 0f15796a.  */
2988           if ((unsigned long) ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
2989               > section->size - (addr - section->vma))
2990             {
2991               /* xgettext:c-format */
2992               _bfd_error_handler
2993                 (_("%pB: Data Directory size (%lx) "
2994                    "exceeds space left in section (%" PRIx64 ")"),
2995                  obfd, ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size,
2996                  (uint64_t) (section->size - (addr - section->vma)));
2997               free (data);
2998               return FALSE;
2999             }
3000
3001           for (i = 0; i < ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
3002                  / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
3003             {
3004               asection *ddsection;
3005               struct external_IMAGE_DEBUG_DIRECTORY *edd = &(dd[i]);
3006               struct internal_IMAGE_DEBUG_DIRECTORY idd;
3007
3008               _bfd_XXi_swap_debugdir_in (obfd, edd, &idd);
3009
3010               if (idd.AddressOfRawData == 0)
3011                 continue; /* RVA 0 means only offset is valid, not handled yet.  */
3012
3013               ddsection = find_section_by_vma (obfd, idd.AddressOfRawData + ope->pe_opthdr.ImageBase);
3014               if (!ddsection)
3015                 continue; /* Not in a section! */
3016
3017               idd.PointerToRawData = ddsection->filepos + (idd.AddressOfRawData
3018                                                            + ope->pe_opthdr.ImageBase) - ddsection->vma;
3019
3020               _bfd_XXi_swap_debugdir_out (obfd, &idd, edd);
3021             }
3022
3023           if (!bfd_set_section_contents (obfd, section, data, 0, section->size))
3024             {
3025               _bfd_error_handler (_("failed to update file offsets in debug directory"));
3026               free (data);
3027               return FALSE;
3028             }
3029           free (data);
3030         }
3031       else if (section)
3032         {
3033           _bfd_error_handler (_("%pB: failed to read debug data section"), obfd);
3034           return FALSE;
3035         }
3036     }
3037
3038   return TRUE;
3039 }
3040
3041 /* Copy private section data.  */
3042
3043 bfd_boolean
3044 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
3045                                        asection *isec,
3046                                        bfd *obfd,
3047                                        asection *osec)
3048 {
3049   if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
3050       || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
3051     return TRUE;
3052
3053   if (coff_section_data (ibfd, isec) != NULL
3054       && pei_section_data (ibfd, isec) != NULL)
3055     {
3056       if (coff_section_data (obfd, osec) == NULL)
3057         {
3058           bfd_size_type amt = sizeof (struct coff_section_tdata);
3059           osec->used_by_bfd = bfd_zalloc (obfd, amt);
3060           if (osec->used_by_bfd == NULL)
3061             return FALSE;
3062         }
3063
3064       if (pei_section_data (obfd, osec) == NULL)
3065         {
3066           bfd_size_type amt = sizeof (struct pei_section_tdata);
3067           coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
3068           if (coff_section_data (obfd, osec)->tdata == NULL)
3069             return FALSE;
3070         }
3071
3072       pei_section_data (obfd, osec)->virt_size =
3073         pei_section_data (ibfd, isec)->virt_size;
3074       pei_section_data (obfd, osec)->pe_flags =
3075         pei_section_data (ibfd, isec)->pe_flags;
3076     }
3077
3078   return TRUE;
3079 }
3080
3081 void
3082 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
3083 {
3084   coff_get_symbol_info (abfd, symbol, ret);
3085 }
3086
3087 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3088 static int
3089 sort_x64_pdata (const void *l, const void *r)
3090 {
3091   const char *lp = (const char *) l;
3092   const char *rp = (const char *) r;
3093   bfd_vma vl, vr;
3094   vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
3095   if (vl != vr)
3096     return (vl < vr ? -1 : 1);
3097   /* We compare just begin address.  */
3098   return 0;
3099 }
3100 #endif
3101 \f
3102 /* Functions to process a .rsrc section.  */
3103
3104 static unsigned int sizeof_leaves;
3105 static unsigned int sizeof_strings;
3106 static unsigned int sizeof_tables_and_entries;
3107
3108 static bfd_byte *
3109 rsrc_count_directory (bfd *, bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma);
3110
3111 static bfd_byte *
3112 rsrc_count_entries (bfd *          abfd,
3113                     bfd_boolean    is_name,
3114                     bfd_byte *     datastart,
3115                     bfd_byte *     data,
3116                     bfd_byte *     dataend,
3117                     bfd_vma        rva_bias)
3118 {
3119   unsigned long entry, addr, size;
3120
3121   if (data + 8 >= dataend)
3122     return dataend + 1;
3123
3124   if (is_name)
3125     {
3126       bfd_byte * name;
3127
3128       entry = (long) bfd_get_32 (abfd, data);
3129
3130       if (HighBitSet (entry))
3131         name = datastart + WithoutHighBit (entry);
3132       else
3133         name = datastart + entry - rva_bias;
3134
3135       if (name + 2 >= dataend || name < datastart)
3136         return dataend + 1;
3137
3138       unsigned int len = bfd_get_16 (abfd, name);
3139       if (len == 0 || len > 256)
3140         return dataend + 1;
3141     }
3142
3143   entry = (long) bfd_get_32 (abfd, data + 4);
3144
3145   if (HighBitSet (entry))
3146     {
3147       data = datastart + WithoutHighBit (entry);
3148
3149       if (data <= datastart || data >= dataend)
3150         return dataend + 1;
3151
3152       return rsrc_count_directory (abfd, datastart, data, dataend, rva_bias);
3153     }
3154
3155   if (datastart + entry + 16 >= dataend)
3156     return dataend + 1;
3157
3158   addr = (long) bfd_get_32 (abfd, datastart + entry);
3159   size = (long) bfd_get_32 (abfd, datastart + entry + 4);
3160
3161   return datastart + addr - rva_bias + size;
3162 }
3163
3164 static bfd_byte *
3165 rsrc_count_directory (bfd *          abfd,
3166                       bfd_byte *     datastart,
3167                       bfd_byte *     data,
3168                       bfd_byte *     dataend,
3169                       bfd_vma        rva_bias)
3170 {
3171   unsigned int  num_entries, num_ids;
3172   bfd_byte *    highest_data = data;
3173
3174   if (data + 16 >= dataend)
3175     return dataend + 1;
3176
3177   num_entries  = (int) bfd_get_16 (abfd, data + 12);
3178   num_ids      = (int) bfd_get_16 (abfd, data + 14);
3179
3180   num_entries += num_ids;
3181
3182   data += 16;
3183
3184   while (num_entries --)
3185     {
3186       bfd_byte * entry_end;
3187
3188       entry_end = rsrc_count_entries (abfd, num_entries >= num_ids,
3189                                       datastart, data, dataend, rva_bias);
3190       data += 8;
3191       highest_data = max (highest_data, entry_end);
3192       if (entry_end >= dataend)
3193         break;
3194     }
3195
3196   return max (highest_data, data);
3197 }
3198
3199 typedef struct rsrc_dir_chain
3200 {
3201   unsigned int         num_entries;
3202   struct rsrc_entry *  first_entry;
3203   struct rsrc_entry *  last_entry;
3204 } rsrc_dir_chain;
3205
3206 typedef struct rsrc_directory
3207 {
3208   unsigned int characteristics;
3209   unsigned int time;
3210   unsigned int major;
3211   unsigned int minor;
3212
3213   rsrc_dir_chain names;
3214   rsrc_dir_chain ids;
3215
3216   struct rsrc_entry * entry;
3217 } rsrc_directory;
3218
3219 typedef struct rsrc_string
3220 {
3221   unsigned int  len;
3222   bfd_byte *    string;
3223 } rsrc_string;
3224
3225 typedef struct rsrc_leaf
3226 {
3227   unsigned int  size;
3228   unsigned int  codepage;
3229   bfd_byte *    data;
3230 } rsrc_leaf;
3231
3232 typedef struct rsrc_entry
3233 {
3234   bfd_boolean is_name;
3235   union
3236   {
3237     unsigned int          id;
3238     struct rsrc_string    name;
3239   } name_id;
3240
3241   bfd_boolean is_dir;
3242   union
3243   {
3244     struct rsrc_directory * directory;
3245     struct rsrc_leaf *      leaf;
3246   } value;
3247
3248   struct rsrc_entry *     next_entry;
3249   struct rsrc_directory * parent;
3250 } rsrc_entry;
3251
3252 static bfd_byte *
3253 rsrc_parse_directory (bfd *, rsrc_directory *, bfd_byte *,
3254                       bfd_byte *, bfd_byte *, bfd_vma, rsrc_entry *);
3255
3256 static bfd_byte *
3257 rsrc_parse_entry (bfd *            abfd,
3258                   bfd_boolean      is_name,
3259                   rsrc_entry *     entry,
3260                   bfd_byte *       datastart,
3261                   bfd_byte *       data,
3262                   bfd_byte *       dataend,
3263                   bfd_vma          rva_bias,
3264                   rsrc_directory * parent)
3265 {
3266   unsigned long val, addr, size;
3267
3268   val = bfd_get_32 (abfd, data);
3269
3270   entry->parent = parent;
3271   entry->is_name = is_name;
3272
3273   if (is_name)
3274     {
3275       bfd_byte * address;
3276
3277       if (HighBitSet (val))
3278         {
3279           val = WithoutHighBit (val);
3280
3281           address = datastart + val;
3282         }
3283       else
3284         {
3285           address = datastart + val - rva_bias;
3286         }
3287
3288       if (address + 3 > dataend)
3289         return dataend;
3290
3291       entry->name_id.name.len    = bfd_get_16 (abfd, address);
3292       entry->name_id.name.string = address + 2;
3293     }
3294   else
3295     entry->name_id.id = val;
3296
3297   val = bfd_get_32 (abfd, data + 4);
3298
3299   if (HighBitSet (val))
3300     {
3301       entry->is_dir = TRUE;
3302       entry->value.directory = bfd_malloc (sizeof * entry->value.directory);
3303       if (entry->value.directory == NULL)
3304         return dataend;
3305
3306       return rsrc_parse_directory (abfd, entry->value.directory,
3307                                    datastart,
3308                                    datastart + WithoutHighBit (val),
3309                                    dataend, rva_bias, entry);
3310     }
3311
3312   entry->is_dir = FALSE;
3313   entry->value.leaf = bfd_malloc (sizeof * entry->value.leaf);
3314   if (entry->value.leaf == NULL)
3315     return dataend;
3316
3317   data = datastart + val;
3318   if (data < datastart || data >= dataend)
3319     return dataend;
3320
3321   addr = bfd_get_32 (abfd, data);
3322   size = entry->value.leaf->size = bfd_get_32 (abfd, data + 4);
3323   entry->value.leaf->codepage = bfd_get_32 (abfd, data + 8);
3324   /* FIXME: We assume that the reserved field (data + 12) is OK.  */
3325
3326   entry->value.leaf->data = bfd_malloc (size);
3327   if (entry->value.leaf->data == NULL)
3328     return dataend;
3329
3330   memcpy (entry->value.leaf->data, datastart + addr - rva_bias, size);
3331   return datastart + (addr - rva_bias) + size;
3332 }
3333
3334 static bfd_byte *
3335 rsrc_parse_entries (bfd *            abfd,
3336                     rsrc_dir_chain * chain,
3337                     bfd_boolean      is_name,
3338                     bfd_byte *       highest_data,
3339                     bfd_byte *       datastart,
3340                     bfd_byte *       data,
3341                     bfd_byte *       dataend,
3342                     bfd_vma          rva_bias,
3343                     rsrc_directory * parent)
3344 {
3345   unsigned int i;
3346   rsrc_entry * entry;
3347
3348   if (chain->num_entries == 0)
3349     {
3350       chain->first_entry = chain->last_entry = NULL;
3351       return highest_data;
3352     }
3353
3354   entry = bfd_malloc (sizeof * entry);
3355   if (entry == NULL)
3356     return dataend;
3357
3358   chain->first_entry = entry;
3359
3360   for (i = chain->num_entries; i--;)
3361     {
3362       bfd_byte * entry_end;
3363
3364       entry_end = rsrc_parse_entry (abfd, is_name, entry, datastart,
3365                                     data, dataend, rva_bias, parent);
3366       data += 8;
3367       highest_data = max (entry_end, highest_data);
3368       if (entry_end > dataend)
3369         return dataend;
3370
3371       if (i)
3372         {
3373           entry->next_entry = bfd_malloc (sizeof * entry);
3374           entry = entry->next_entry;
3375           if (entry == NULL)
3376             return dataend;
3377         }
3378       else
3379         entry->next_entry = NULL;
3380     }
3381
3382   chain->last_entry = entry;
3383
3384   return highest_data;
3385 }
3386
3387 static bfd_byte *
3388 rsrc_parse_directory (bfd *            abfd,
3389                       rsrc_directory * table,
3390                       bfd_byte *       datastart,
3391                       bfd_byte *       data,
3392                       bfd_byte *       dataend,
3393                       bfd_vma          rva_bias,
3394                       rsrc_entry *     entry)
3395 {
3396   bfd_byte * highest_data = data;
3397
3398   if (table == NULL)
3399     return dataend;
3400
3401   table->characteristics = bfd_get_32 (abfd, data);
3402   table->time = bfd_get_32 (abfd, data + 4);
3403   table->major = bfd_get_16 (abfd, data + 8);
3404   table->minor = bfd_get_16 (abfd, data + 10);
3405   table->names.num_entries = bfd_get_16 (abfd, data + 12);
3406   table->ids.num_entries = bfd_get_16 (abfd, data + 14);
3407   table->entry = entry;
3408
3409   data += 16;
3410
3411   highest_data = rsrc_parse_entries (abfd, & table->names, TRUE, data,
3412                                      datastart, data, dataend, rva_bias, table);
3413   data += table->names.num_entries * 8;
3414
3415   highest_data = rsrc_parse_entries (abfd, & table->ids, FALSE, highest_data,
3416                                      datastart, data, dataend, rva_bias, table);
3417   data += table->ids.num_entries * 8;
3418
3419   return max (highest_data, data);
3420 }
3421
3422 typedef struct rsrc_write_data
3423 {
3424   bfd *      abfd;
3425   bfd_byte * datastart;
3426   bfd_byte * next_table;
3427   bfd_byte * next_leaf;
3428   bfd_byte * next_string;
3429   bfd_byte * next_data;
3430   bfd_vma    rva_bias;
3431 } rsrc_write_data;
3432
3433 static void
3434 rsrc_write_string (rsrc_write_data * data,
3435                    rsrc_string *     string)
3436 {
3437   bfd_put_16 (data->abfd, string->len, data->next_string);
3438   memcpy (data->next_string + 2, string->string, string->len * 2);
3439   data->next_string += (string->len + 1) * 2;
3440 }
3441
3442 static inline unsigned int
3443 rsrc_compute_rva (rsrc_write_data * data,
3444                   bfd_byte *        addr)
3445 {
3446   return (addr - data->datastart) + data->rva_bias;
3447 }
3448
3449 static void
3450 rsrc_write_leaf (rsrc_write_data * data,
3451                  rsrc_leaf *       leaf)
3452 {
3453   bfd_put_32 (data->abfd, rsrc_compute_rva (data, data->next_data),
3454               data->next_leaf);
3455   bfd_put_32 (data->abfd, leaf->size,     data->next_leaf + 4);
3456   bfd_put_32 (data->abfd, leaf->codepage, data->next_leaf + 8);
3457   bfd_put_32 (data->abfd, 0 /*reserved*/, data->next_leaf + 12);
3458   data->next_leaf += 16;
3459
3460   memcpy (data->next_data, leaf->data, leaf->size);
3461   /* An undocumented feature of Windows resources is that each unit
3462      of raw data is 8-byte aligned...  */
3463   data->next_data += ((leaf->size + 7) & ~7);
3464 }
3465
3466 static void rsrc_write_directory (rsrc_write_data *, rsrc_directory *);
3467
3468 static void
3469 rsrc_write_entry (rsrc_write_data *  data,
3470                   bfd_byte *         where,
3471                   rsrc_entry *       entry)
3472 {
3473   if (entry->is_name)
3474     {
3475       bfd_put_32 (data->abfd,
3476                   SetHighBit (data->next_string - data->datastart),
3477                   where);
3478       rsrc_write_string (data, & entry->name_id.name);
3479     }
3480   else
3481     bfd_put_32 (data->abfd, entry->name_id.id, where);
3482
3483   if (entry->is_dir)
3484     {
3485       bfd_put_32 (data->abfd,
3486                   SetHighBit (data->next_table - data->datastart),
3487                   where + 4);
3488       rsrc_write_directory (data, entry->value.directory);
3489     }
3490   else
3491     {
3492       bfd_put_32 (data->abfd, data->next_leaf - data->datastart, where + 4);
3493       rsrc_write_leaf (data, entry->value.leaf);
3494     }
3495 }
3496
3497 static void
3498 rsrc_compute_region_sizes (rsrc_directory * dir)
3499 {
3500   struct rsrc_entry * entry;
3501
3502   if (dir == NULL)
3503     return;
3504
3505   sizeof_tables_and_entries += 16;
3506
3507   for (entry = dir->names.first_entry; entry != NULL; entry = entry->next_entry)
3508     {
3509       sizeof_tables_and_entries += 8;
3510
3511       sizeof_strings += (entry->name_id.name.len + 1) * 2;
3512
3513       if (entry->is_dir)
3514         rsrc_compute_region_sizes (entry->value.directory);
3515       else
3516         sizeof_leaves += 16;
3517     }
3518
3519   for (entry = dir->ids.first_entry; entry != NULL; entry = entry->next_entry)
3520     {
3521       sizeof_tables_and_entries += 8;
3522
3523       if (entry->is_dir)
3524         rsrc_compute_region_sizes (entry->value.directory);
3525       else
3526         sizeof_leaves += 16;
3527     }
3528 }
3529
3530 static void
3531 rsrc_write_directory (rsrc_write_data * data,
3532                       rsrc_directory *  dir)
3533 {
3534   rsrc_entry * entry;
3535   unsigned int i;
3536   bfd_byte * next_entry;
3537   bfd_byte * nt;
3538
3539   bfd_put_32 (data->abfd, dir->characteristics, data->next_table);
3540   bfd_put_32 (data->abfd, 0 /*dir->time*/, data->next_table + 4);
3541   bfd_put_16 (data->abfd, dir->major, data->next_table + 8);
3542   bfd_put_16 (data->abfd, dir->minor, data->next_table + 10);
3543   bfd_put_16 (data->abfd, dir->names.num_entries, data->next_table + 12);
3544   bfd_put_16 (data->abfd, dir->ids.num_entries, data->next_table + 14);
3545
3546   /* Compute where the entries and the next table will be placed.  */
3547   next_entry = data->next_table + 16;
3548   data->next_table = next_entry + (dir->names.num_entries * 8)
3549     + (dir->ids.num_entries * 8);
3550   nt = data->next_table;
3551
3552   /* Write the entries.  */
3553   for (i = dir->names.num_entries, entry = dir->names.first_entry;
3554        i > 0 && entry != NULL;
3555        i--, entry = entry->next_entry)
3556     {
3557       BFD_ASSERT (entry->is_name);
3558       rsrc_write_entry (data, next_entry, entry);
3559       next_entry += 8;
3560     }
3561   BFD_ASSERT (i == 0);
3562   BFD_ASSERT (entry == NULL);
3563
3564   for (i = dir->ids.num_entries, entry = dir->ids.first_entry;
3565        i > 0 && entry != NULL;
3566        i--, entry = entry->next_entry)
3567     {
3568       BFD_ASSERT (! entry->is_name);
3569       rsrc_write_entry (data, next_entry, entry);
3570       next_entry += 8;
3571     }
3572   BFD_ASSERT (i == 0);
3573   BFD_ASSERT (entry == NULL);
3574   BFD_ASSERT (nt == next_entry);
3575 }
3576
3577 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3578 /* Return the length (number of units) of the first character in S,
3579    putting its 'ucs4_t' representation in *PUC.  */
3580
3581 static unsigned int
3582 #if defined HAVE_WCTYPE_H
3583 u16_mbtouc (wint_t * puc, const unsigned short * s, unsigned int n)
3584 #else
3585 u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n)
3586 #endif
3587 {
3588   unsigned short c = * s;
3589
3590   if (c < 0xd800 || c >= 0xe000)
3591     {
3592       *puc = c;
3593       return 1;
3594     }
3595
3596   if (c < 0xdc00)
3597     {
3598       if (n >= 2)
3599         {
3600           if (s[1] >= 0xdc00 && s[1] < 0xe000)
3601             {
3602               *puc = 0x10000 + ((c - 0xd800) << 10) + (s[1] - 0xdc00);
3603               return 2;
3604             }
3605         }
3606       else
3607         {
3608           /* Incomplete multibyte character.  */
3609           *puc = 0xfffd;
3610           return n;
3611         }
3612     }
3613
3614   /* Invalid multibyte character.  */
3615   *puc = 0xfffd;
3616   return 1;
3617 }
3618 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3619
3620 /* Perform a comparison of two entries.  */
3621 static signed int
3622 rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b)
3623 {
3624   signed int    res;
3625   bfd_byte *    astring;
3626   unsigned int  alen;
3627   bfd_byte *    bstring;
3628   unsigned int  blen;
3629
3630   if (! is_name)
3631     return a->name_id.id - b->name_id.id;
3632
3633   /* We have to perform a case insenstive, unicode string comparison...  */
3634   astring = a->name_id.name.string;
3635   alen    = a->name_id.name.len;
3636   bstring = b->name_id.name.string;
3637   blen    = b->name_id.name.len;
3638
3639 #if defined  __CYGWIN__ || defined __MINGW32__
3640   /* Under Windows hosts (both Cygwin and Mingw types),
3641      unicode == UTF-16 == wchar_t.  The case insensitive string comparison
3642      function however goes by different names in the two environments...  */
3643
3644 #undef rscpcmp
3645 #ifdef __CYGWIN__
3646 #define rscpcmp wcsncasecmp
3647 #endif
3648 #ifdef __MINGW32__
3649 #define rscpcmp wcsnicmp
3650 #endif
3651
3652   res = rscpcmp ((const wchar_t *) astring, (const wchar_t *) bstring,
3653                  min (alen, blen));
3654
3655 #elif defined HAVE_WCHAR_H
3656   {
3657     unsigned int  i;
3658
3659     res = 0;
3660     for (i = min (alen, blen); i--; astring += 2, bstring += 2)
3661       {
3662 #if defined HAVE_WCTYPE_H
3663         wint_t awc;
3664         wint_t bwc;
3665 #else
3666         wchar_t awc;
3667         wchar_t bwc;
3668 #endif
3669
3670         /* Convert UTF-16 unicode characters into wchar_t characters
3671            so that we can then perform a case insensitive comparison.  */
3672         unsigned int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2);
3673         unsigned int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2);
3674
3675         if (Alen != Blen)
3676           return Alen - Blen;
3677
3678 #ifdef HAVE_WCTYPE_H
3679         awc = towlower (awc);
3680         bwc = towlower (bwc);
3681
3682         res = awc - bwc;
3683 #else
3684         res = wcsncasecmp (& awc, & bwc, 1);
3685 #endif
3686         if (res)
3687           break;
3688       }
3689   }
3690 #else
3691   /* Do the best we can - a case sensitive, untranslated comparison.  */
3692   res = memcmp (astring, bstring, min (alen, blen) * 2);
3693 #endif
3694
3695   if (res == 0)
3696     res = alen - blen;
3697
3698   return res;
3699 }
3700
3701 static void
3702 rsrc_print_name (char * buffer, rsrc_string string)
3703 {
3704   unsigned int  i;
3705   bfd_byte *    name = string.string;
3706
3707   for (i = string.len; i--; name += 2)
3708     sprintf (buffer + strlen (buffer), "%.1s", name);
3709 }
3710
3711 static const char *
3712 rsrc_resource_name (rsrc_entry * entry, rsrc_directory * dir)
3713 {
3714   static char buffer [256];
3715   bfd_boolean is_string = FALSE;
3716
3717   buffer[0] = 0;
3718
3719   if (dir != NULL && dir->entry != NULL && dir->entry->parent != NULL
3720       && dir->entry->parent->entry != NULL)
3721     {
3722       strcpy (buffer, "type: ");
3723       if (dir->entry->parent->entry->is_name)
3724         rsrc_print_name (buffer + strlen (buffer),
3725                          dir->entry->parent->entry->name_id.name);
3726       else
3727         {
3728           unsigned int id = dir->entry->parent->entry->name_id.id;
3729
3730           sprintf (buffer + strlen (buffer), "%x", id);
3731           switch (id)
3732             {
3733             case 1: strcat (buffer, " (CURSOR)"); break;
3734             case 2: strcat (buffer, " (BITMAP)"); break;
3735             case 3: strcat (buffer, " (ICON)"); break;
3736             case 4: strcat (buffer, " (MENU)"); break;
3737             case 5: strcat (buffer, " (DIALOG)"); break;
3738             case 6: strcat (buffer, " (STRING)"); is_string = TRUE; break;
3739             case 7: strcat (buffer, " (FONTDIR)"); break;
3740             case 8: strcat (buffer, " (FONT)"); break;
3741             case 9: strcat (buffer, " (ACCELERATOR)"); break;
3742             case 10: strcat (buffer, " (RCDATA)"); break;
3743             case 11: strcat (buffer, " (MESSAGETABLE)"); break;
3744             case 12: strcat (buffer, " (GROUP_CURSOR)"); break;
3745             case 14: strcat (buffer, " (GROUP_ICON)"); break;
3746             case 16: strcat (buffer, " (VERSION)"); break;
3747             case 17: strcat (buffer, " (DLGINCLUDE)"); break;
3748             case 19: strcat (buffer, " (PLUGPLAY)"); break;
3749             case 20: strcat (buffer, " (VXD)"); break;
3750             case 21: strcat (buffer, " (ANICURSOR)"); break;
3751             case 22: strcat (buffer, " (ANIICON)"); break;
3752             case 23: strcat (buffer, " (HTML)"); break;
3753             case 24: strcat (buffer, " (MANIFEST)"); break;
3754             case 240: strcat (buffer, " (DLGINIT)"); break;
3755             case 241: strcat (buffer, " (TOOLBAR)"); break;
3756             }
3757         }
3758     }
3759
3760   if (dir != NULL && dir->entry != NULL)
3761     {
3762       strcat (buffer, " name: ");
3763       if (dir->entry->is_name)
3764         rsrc_print_name (buffer + strlen (buffer), dir->entry->name_id.name);
3765       else
3766         {
3767           unsigned int id = dir->entry->name_id.id;
3768
3769           sprintf (buffer + strlen (buffer), "%x", id);
3770
3771           if (is_string)
3772             sprintf (buffer + strlen (buffer), " (resource id range: %d - %d)",
3773                      (id - 1) << 4, (id << 4) - 1);
3774         }
3775     }
3776
3777   if (entry != NULL)
3778     {
3779       strcat (buffer, " lang: ");
3780
3781       if (entry->is_name)
3782         rsrc_print_name (buffer + strlen (buffer), entry->name_id.name);
3783       else
3784         sprintf (buffer + strlen (buffer), "%x", entry->name_id.id);
3785     }
3786
3787   return buffer;
3788 }
3789
3790 /* *sigh* Windows resource strings are special.  Only the top 28-bits of
3791    their ID is stored in the NAME entry.  The bottom four bits are used as
3792    an index into unicode string table that makes up the data of the leaf.
3793    So identical type-name-lang string resources may not actually be
3794    identical at all.
3795
3796    This function is called when we have detected two string resources with
3797    match top-28-bit IDs.  We have to scan the string tables inside the leaves
3798    and discover if there are any real collisions.  If there are then we report
3799    them and return FALSE.  Otherwise we copy any strings from B into A and
3800    then return TRUE.  */
3801
3802 static bfd_boolean
3803 rsrc_merge_string_entries (rsrc_entry * a ATTRIBUTE_UNUSED,
3804                            rsrc_entry * b ATTRIBUTE_UNUSED)
3805 {
3806   unsigned int copy_needed = 0;
3807   unsigned int i;
3808   bfd_byte * astring;
3809   bfd_byte * bstring;
3810   bfd_byte * new_data;
3811   bfd_byte * nstring;
3812
3813   /* Step one: Find out what we have to do.  */
3814   BFD_ASSERT (! a->is_dir);
3815   astring = a->value.leaf->data;
3816
3817   BFD_ASSERT (! b->is_dir);
3818   bstring = b->value.leaf->data;
3819
3820   for (i = 0; i < 16; i++)
3821     {
3822       unsigned int alen = astring[0] + (astring[1] << 8);
3823       unsigned int blen = bstring[0] + (bstring[1] << 8);
3824
3825       if (alen == 0)
3826         {
3827           copy_needed += blen * 2;
3828         }
3829       else if (blen == 0)
3830         ;
3831       else if (alen != blen)
3832         /* FIXME: Should we continue the loop in order to report other duplicates ?  */
3833         break;
3834       /* alen == blen != 0.  We might have two identical strings.  If so we
3835          can ignore the second one.  There is no need for wchar_t vs UTF-16
3836          theatrics here - we are only interested in (case sensitive) equality.  */
3837       else if (memcmp (astring + 2, bstring + 2, alen * 2) != 0)
3838         break;
3839
3840       astring += (alen + 1) * 2;
3841       bstring += (blen + 1) * 2;
3842     }
3843
3844   if (i != 16)
3845     {
3846       if (a->parent != NULL
3847           && a->parent->entry != NULL
3848           && !a->parent->entry->is_name)
3849         _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3850                             ((a->parent->entry->name_id.id - 1) << 4) + i);
3851       return FALSE;
3852     }
3853
3854   if (copy_needed == 0)
3855     return TRUE;
3856
3857   /* If we reach here then A and B must both have non-colliding strings.
3858      (We never get string resources with fully empty string tables).
3859      We need to allocate an extra COPY_NEEDED bytes in A and then bring
3860      in B's strings.  */
3861   new_data = bfd_malloc (a->value.leaf->size + copy_needed);
3862   if (new_data == NULL)
3863     return FALSE;
3864
3865   nstring = new_data;
3866   astring = a->value.leaf->data;
3867   bstring = b->value.leaf->data;
3868
3869   for (i = 0; i < 16; i++)
3870     {
3871       unsigned int alen = astring[0] + (astring[1] << 8);
3872       unsigned int blen = bstring[0] + (bstring[1] << 8);
3873
3874       if (alen != 0)
3875         {
3876           memcpy (nstring, astring, (alen + 1) * 2);
3877           nstring += (alen + 1) * 2;
3878         }
3879       else if (blen != 0)
3880         {
3881           memcpy (nstring, bstring, (blen + 1) * 2);
3882           nstring += (blen + 1) * 2;
3883         }
3884       else
3885         {
3886           * nstring++ = 0;
3887           * nstring++ = 0;
3888         }
3889
3890       astring += (alen + 1) * 2;
3891       bstring += (blen + 1) * 2;
3892     }
3893
3894   BFD_ASSERT (nstring - new_data == (signed) (a->value.leaf->size + copy_needed));
3895
3896   free (a->value.leaf->data);
3897   a->value.leaf->data = new_data;
3898   a->value.leaf->size += copy_needed;
3899
3900   return TRUE;
3901 }
3902
3903 static void rsrc_merge (rsrc_entry *, rsrc_entry *);
3904
3905 /* Sort the entries in given part of the directory.
3906    We use an old fashioned bubble sort because we are dealing
3907    with lists and we want to handle matches specially.  */
3908
3909 static void
3910 rsrc_sort_entries (rsrc_dir_chain *  chain,
3911                    bfd_boolean       is_name,
3912                    rsrc_directory *  dir)
3913 {
3914   rsrc_entry * entry;
3915   rsrc_entry * next;
3916   rsrc_entry ** points_to_entry;
3917   bfd_boolean swapped;
3918
3919   if (chain->num_entries < 2)
3920     return;
3921
3922   do
3923     {
3924       swapped = FALSE;
3925       points_to_entry = & chain->first_entry;
3926       entry = * points_to_entry;
3927       next  = entry->next_entry;
3928
3929       do
3930         {
3931           signed int cmp = rsrc_cmp (is_name, entry, next);
3932
3933           if (cmp > 0)
3934             {
3935               entry->next_entry = next->next_entry;
3936               next->next_entry = entry;
3937               * points_to_entry = next;
3938               points_to_entry = & next->next_entry;
3939               next = entry->next_entry;
3940               swapped = TRUE;
3941             }
3942           else if (cmp == 0)
3943             {
3944               if (entry->is_dir && next->is_dir)
3945                 {
3946                   /* When we encounter identical directory entries we have to
3947                      merge them together.  The exception to this rule is for
3948                      resource manifests - there can only be one of these,
3949                      even if they differ in language.  Zero-language manifests
3950                      are assumed to be default manifests (provided by the
3951                      Cygwin/MinGW build system) and these can be silently dropped,
3952                      unless that would reduce the number of manifests to zero.
3953                      There should only ever be one non-zero lang manifest -
3954                      if there are more it is an error.  A non-zero lang
3955                      manifest takes precedence over a default manifest.  */
3956                   if (!entry->is_name
3957                       && entry->name_id.id == 1
3958                       && dir != NULL
3959                       && dir->entry != NULL
3960                       && !dir->entry->is_name
3961                       && dir->entry->name_id.id == 0x18)
3962                     {
3963                       if (next->value.directory->names.num_entries == 0
3964                           && next->value.directory->ids.num_entries == 1
3965                           && !next->value.directory->ids.first_entry->is_name
3966                           && next->value.directory->ids.first_entry->name_id.id == 0)
3967                         /* Fall through so that NEXT is dropped.  */
3968                         ;
3969                       else if (entry->value.directory->names.num_entries == 0
3970                                && entry->value.directory->ids.num_entries == 1
3971                                && !entry->value.directory->ids.first_entry->is_name
3972                                && entry->value.directory->ids.first_entry->name_id.id == 0)
3973                         {
3974                           /* Swap ENTRY and NEXT.  Then fall through so that the old ENTRY is dropped.  */
3975                           entry->next_entry = next->next_entry;
3976                           next->next_entry = entry;
3977                           * points_to_entry = next;
3978                           points_to_entry = & next->next_entry;
3979                           next = entry->next_entry;
3980                           swapped = TRUE;
3981                         }
3982                       else
3983                         {
3984                           _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3985                           bfd_set_error (bfd_error_file_truncated);
3986                           return;
3987                         }
3988
3989                       /* Unhook NEXT from the chain.  */
3990                       /* FIXME: memory loss here.  */
3991                       entry->next_entry = next->next_entry;
3992                       chain->num_entries --;
3993                       if (chain->num_entries < 2)
3994                         return;
3995                       next = next->next_entry;
3996                     }
3997                   else
3998                     rsrc_merge (entry, next);
3999                 }
4000               else if (entry->is_dir != next->is_dir)
4001                 {
4002                   _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4003                   bfd_set_error (bfd_error_file_truncated);
4004                   return;
4005                 }
4006               else
4007                 {
4008                   /* Otherwise with identical leaves we issue an error
4009                      message - because there should never be duplicates.
4010                      The exception is Type 18/Name 1/Lang 0 which is the
4011                      defaul manifest - this can just be dropped.  */
4012                   if (!entry->is_name
4013                       && entry->name_id.id == 0
4014                       && dir != NULL
4015                       && dir->entry != NULL
4016                       && !dir->entry->is_name
4017                       && dir->entry->name_id.id == 1
4018                       && dir->entry->parent != NULL
4019                       && dir->entry->parent->entry != NULL
4020                       && !dir->entry->parent->entry->is_name
4021                       && dir->entry->parent->entry->name_id.id == 0x18 /* RT_MANIFEST */)
4022                     ;
4023                   else if (dir != NULL
4024                            && dir->entry != NULL
4025                            && dir->entry->parent != NULL
4026                            && dir->entry->parent->entry != NULL
4027                            && !dir->entry->parent->entry->is_name
4028                            && dir->entry->parent->entry->name_id.id == 0x6 /* RT_STRING */)
4029                     {
4030                       /* Strings need special handling.  */
4031                       if (! rsrc_merge_string_entries (entry, next))
4032                         {
4033                           /* _bfd_error_handler should have been called inside merge_strings.  */
4034                           bfd_set_error (bfd_error_file_truncated);
4035                           return;
4036                         }
4037                     }
4038                   else
4039                     {
4040                       if (dir == NULL
4041                           || dir->entry == NULL
4042                           || dir->entry->parent == NULL
4043                           || dir->entry->parent->entry == NULL)
4044                         _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4045                       else
4046                         _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4047                                             rsrc_resource_name (entry, dir));
4048                       bfd_set_error (bfd_error_file_truncated);
4049                       return;
4050                     }
4051                 }
4052
4053               /* Unhook NEXT from the chain.  */
4054               entry->next_entry = next->next_entry;
4055               chain->num_entries --;
4056               if (chain->num_entries < 2)
4057                 return;
4058               next = next->next_entry;
4059             }
4060           else
4061             {
4062               points_to_entry = & entry->next_entry;
4063               entry = next;
4064               next = next->next_entry;
4065             }
4066         }
4067       while (next);
4068
4069       chain->last_entry = entry;
4070     }
4071   while (swapped);
4072 }
4073
4074 /* Attach B's chain onto A.  */
4075 static void
4076 rsrc_attach_chain (rsrc_dir_chain * achain, rsrc_dir_chain * bchain)
4077 {
4078   if (bchain->num_entries == 0)
4079     return;
4080
4081   achain->num_entries += bchain->num_entries;
4082
4083   if (achain->first_entry == NULL)
4084     {
4085       achain->first_entry = bchain->first_entry;
4086       achain->last_entry  = bchain->last_entry;
4087     }
4088   else
4089     {
4090       achain->last_entry->next_entry = bchain->first_entry;
4091       achain->last_entry = bchain->last_entry;
4092     }
4093
4094   bchain->num_entries = 0;
4095   bchain->first_entry = bchain->last_entry = NULL;
4096 }
4097
4098 static void
4099 rsrc_merge (struct rsrc_entry * a, struct rsrc_entry * b)
4100 {
4101   rsrc_directory * adir;
4102   rsrc_directory * bdir;
4103
4104   BFD_ASSERT (a->is_dir);
4105   BFD_ASSERT (b->is_dir);
4106
4107   adir = a->value.directory;
4108   bdir = b->value.directory;
4109
4110   if (adir->characteristics != bdir->characteristics)
4111     {
4112       _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4113       bfd_set_error (bfd_error_file_truncated);
4114       return;
4115     }
4116
4117   if (adir->major != bdir->major || adir->minor != bdir->minor)
4118     {
4119       _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4120       bfd_set_error (bfd_error_file_truncated);
4121       return;
4122     }
4123
4124   /* Attach B's name chain to A.  */
4125   rsrc_attach_chain (& adir->names, & bdir->names);
4126
4127   /* Attach B's ID chain to A.  */
4128   rsrc_attach_chain (& adir->ids, & bdir->ids);
4129
4130   /* Now sort A's entries.  */
4131   rsrc_sort_entries (& adir->names, TRUE, adir);
4132   rsrc_sort_entries (& adir->ids, FALSE, adir);
4133 }
4134
4135 /* Check the .rsrc section.  If it contains multiple concatenated
4136    resources then we must merge them properly.  Otherwise Windows
4137    will ignore all but the first set.  */
4138
4139 static void
4140 rsrc_process_section (bfd * abfd,
4141                       struct coff_final_link_info * pfinfo)
4142 {
4143   rsrc_directory    new_table;
4144   bfd_size_type     size;
4145   asection *        sec;
4146   pe_data_type *    pe;
4147   bfd_vma           rva_bias;
4148   bfd_byte *        data;
4149   bfd_byte *        datastart;
4150   bfd_byte *        dataend;
4151   bfd_byte *        new_data;
4152   unsigned int      num_resource_sets;
4153   rsrc_directory *  type_tables;
4154   rsrc_write_data   write_data;
4155   unsigned int      indx;
4156   bfd *             input;
4157   unsigned int      num_input_rsrc = 0;
4158   unsigned int      max_num_input_rsrc = 4;
4159   ptrdiff_t *       rsrc_sizes = NULL;
4160
4161   new_table.names.num_entries = 0;
4162   new_table.ids.num_entries = 0;
4163
4164   sec = bfd_get_section_by_name (abfd, ".rsrc");
4165   if (sec == NULL || (size = sec->rawsize) == 0)
4166     return;
4167
4168   pe = pe_data (abfd);
4169   if (pe == NULL)
4170     return;
4171
4172   rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4173
4174   data = bfd_malloc (size);
4175   if (data == NULL)
4176     return;
4177
4178   datastart = data;
4179
4180   if (! bfd_get_section_contents (abfd, sec, data, 0, size))
4181     goto end;
4182
4183   /* Step zero: Scan the input bfds looking for .rsrc sections and record
4184      their lengths.  Note - we rely upon the fact that the linker script
4185      does *not* sort the input .rsrc sections, so that the order in the
4186      linkinfo list matches the order in the output .rsrc section.
4187
4188      We need to know the lengths because each input .rsrc section has padding
4189      at the end of a variable amount.  (It does not appear to be based upon
4190      the section alignment or the file alignment).  We need to skip any
4191      padding bytes when parsing the input .rsrc sections.  */
4192   rsrc_sizes = bfd_malloc (max_num_input_rsrc * sizeof * rsrc_sizes);
4193   if (rsrc_sizes == NULL)
4194     goto end;
4195
4196   for (input = pfinfo->info->input_bfds;
4197        input != NULL;
4198        input = input->link.next)
4199     {
4200       asection * rsrc_sec = bfd_get_section_by_name (input, ".rsrc");
4201
4202       /* PR 18372 - skip discarded .rsrc sections.  */
4203       if (rsrc_sec != NULL && !discarded_section (rsrc_sec))
4204         {
4205           if (num_input_rsrc == max_num_input_rsrc)
4206             {
4207               max_num_input_rsrc += 10;
4208               rsrc_sizes = bfd_realloc (rsrc_sizes, max_num_input_rsrc
4209                                         * sizeof * rsrc_sizes);
4210               if (rsrc_sizes == NULL)
4211                 goto end;
4212             }
4213
4214           BFD_ASSERT (rsrc_sec->size > 0);
4215           rsrc_sizes [num_input_rsrc ++] = rsrc_sec->size;
4216         }
4217     }
4218
4219   if (num_input_rsrc < 2)
4220     goto end;
4221
4222   /* Step one: Walk the section, computing the size of the tables,
4223      leaves and data and decide if we need to do anything.  */
4224   dataend = data + size;
4225   num_resource_sets = 0;
4226
4227   while (data < dataend)
4228     {
4229       bfd_byte * p = data;
4230
4231       data = rsrc_count_directory (abfd, data, data, dataend, rva_bias);
4232
4233       if (data > dataend)
4234         {
4235           /* Corrupted .rsrc section - cannot merge.  */
4236           _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4237                               abfd);
4238           bfd_set_error (bfd_error_file_truncated);
4239           goto end;
4240         }
4241
4242       if ((data - p) > rsrc_sizes [num_resource_sets])
4243         {
4244           _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4245                               abfd);
4246           bfd_set_error (bfd_error_file_truncated);
4247           goto end;
4248         }
4249       /* FIXME: Should we add a check for "data - p" being much smaller
4250          than rsrc_sizes[num_resource_sets] ?  */
4251
4252       data = p + rsrc_sizes[num_resource_sets];
4253       rva_bias += data - p;
4254       ++ num_resource_sets;
4255     }
4256   BFD_ASSERT (num_resource_sets == num_input_rsrc);
4257
4258   /* Step two: Walk the data again, building trees of the resources.  */
4259   data = datastart;
4260   rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4261
4262   type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables);
4263   if (type_tables == NULL)
4264     goto end;
4265
4266   indx = 0;
4267   while (data < dataend)
4268     {
4269       bfd_byte * p = data;
4270
4271       (void) rsrc_parse_directory (abfd, type_tables + indx, data, data,
4272                                    dataend, rva_bias, NULL);
4273       data = p + rsrc_sizes[indx];
4274       rva_bias += data - p;
4275       ++ indx;
4276     }
4277   BFD_ASSERT (indx == num_resource_sets);
4278
4279   /* Step three: Merge the top level tables (there can be only one).
4280
4281      We must ensure that the merged entries are in ascending order.
4282
4283      We also thread the top level table entries from the old tree onto
4284      the new table, so that they can be pulled off later.  */
4285
4286   /* FIXME: Should we verify that all type tables are the same ?  */
4287   new_table.characteristics = type_tables[0].characteristics;
4288   new_table.time            = type_tables[0].time;
4289   new_table.major           = type_tables[0].major;
4290   new_table.minor           = type_tables[0].minor;
4291
4292   /* Chain the NAME entries onto the table.  */
4293   new_table.names.first_entry = NULL;
4294   new_table.names.last_entry = NULL;
4295
4296   for (indx = 0; indx < num_resource_sets; indx++)
4297     rsrc_attach_chain (& new_table.names, & type_tables[indx].names);
4298
4299   rsrc_sort_entries (& new_table.names, TRUE, & new_table);
4300
4301   /* Chain the ID entries onto the table.  */
4302   new_table.ids.first_entry = NULL;
4303   new_table.ids.last_entry = NULL;
4304
4305   for (indx = 0; indx < num_resource_sets; indx++)
4306     rsrc_attach_chain (& new_table.ids, & type_tables[indx].ids);
4307
4308   rsrc_sort_entries (& new_table.ids, FALSE, & new_table);
4309
4310   /* Step four: Create new contents for the .rsrc section.  */
4311   /* Step four point one: Compute the size of each region of the .rsrc section.
4312      We do this now, rather than earlier, as the merging above may have dropped
4313      some entries.  */
4314   sizeof_leaves = sizeof_strings = sizeof_tables_and_entries = 0;
4315   rsrc_compute_region_sizes (& new_table);
4316   /* We increment sizeof_strings to make sure that resource data
4317      starts on an 8-byte boundary.  FIXME: Is this correct ?  */
4318   sizeof_strings = (sizeof_strings + 7) & ~ 7;
4319
4320   new_data = bfd_zalloc (abfd, size);
4321   if (new_data == NULL)
4322     goto end;
4323
4324   write_data.abfd        = abfd;
4325   write_data.datastart   = new_data;
4326   write_data.next_table  = new_data;
4327   write_data.next_leaf   = new_data + sizeof_tables_and_entries;
4328   write_data.next_string = write_data.next_leaf + sizeof_leaves;
4329   write_data.next_data   = write_data.next_string + sizeof_strings;
4330   write_data.rva_bias    = sec->vma - pe->pe_opthdr.ImageBase;
4331
4332   rsrc_write_directory (& write_data, & new_table);
4333
4334   /* Step five: Replace the old contents with the new.
4335      We don't recompute the size as it's too late here to shrink section.
4336      See PR ld/20193 for more details.  */
4337   bfd_set_section_contents (pfinfo->output_bfd, sec, new_data, 0, size);
4338   sec->size = sec->rawsize = size;
4339
4340  end:
4341   /* Step six: Free all the memory that we have used.  */
4342   /* FIXME: Free the resource tree, if we have one.  */
4343   free (datastart);
4344   free (rsrc_sizes);
4345 }
4346
4347 /* Handle the .idata section and other things that need symbol table
4348    access.  */
4349
4350 bfd_boolean
4351 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
4352 {
4353   struct coff_link_hash_entry *h1;
4354   struct bfd_link_info *info = pfinfo->info;
4355   bfd_boolean result = TRUE;
4356
4357   /* There are a few fields that need to be filled in now while we
4358      have symbol table access.
4359
4360      The .idata subsections aren't directly available as sections, but
4361      they are in the symbol table, so get them from there.  */
4362
4363   /* The import directory.  This is the address of .idata$2, with size
4364      of .idata$2 + .idata$3.  */
4365   h1 = coff_link_hash_lookup (coff_hash_table (info),
4366                               ".idata$2", FALSE, FALSE, TRUE);
4367   if (h1 != NULL)
4368     {
4369       /* PR ld/2729: We cannot rely upon all the output sections having been
4370          created properly, so check before referencing them.  Issue a warning
4371          message for any sections tht could not be found.  */
4372       if ((h1->root.type == bfd_link_hash_defined
4373            || h1->root.type == bfd_link_hash_defweak)
4374           && h1->root.u.def.section != NULL
4375           && h1->root.u.def.section->output_section != NULL)
4376         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
4377           (h1->root.u.def.value
4378            + h1->root.u.def.section->output_section->vma
4379            + h1->root.u.def.section->output_offset);
4380       else
4381         {
4382           _bfd_error_handler
4383             (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4384              abfd);
4385           result = FALSE;
4386         }
4387
4388       h1 = coff_link_hash_lookup (coff_hash_table (info),
4389                                   ".idata$4", FALSE, FALSE, TRUE);
4390       if (h1 != NULL
4391           && (h1->root.type == bfd_link_hash_defined
4392            || h1->root.type == bfd_link_hash_defweak)
4393           && h1->root.u.def.section != NULL
4394           && h1->root.u.def.section->output_section != NULL)
4395         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
4396           ((h1->root.u.def.value
4397             + h1->root.u.def.section->output_section->vma
4398             + h1->root.u.def.section->output_offset)
4399            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
4400       else
4401         {
4402           _bfd_error_handler
4403             (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4404              abfd);
4405           result = FALSE;
4406         }
4407
4408       /* The import address table.  This is the size/address of
4409          .idata$5.  */
4410       h1 = coff_link_hash_lookup (coff_hash_table (info),
4411                                   ".idata$5", FALSE, FALSE, TRUE);
4412       if (h1 != NULL
4413           && (h1->root.type == bfd_link_hash_defined
4414            || h1->root.type == bfd_link_hash_defweak)
4415           && h1->root.u.def.section != NULL
4416           && h1->root.u.def.section->output_section != NULL)
4417         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4418           (h1->root.u.def.value
4419            + h1->root.u.def.section->output_section->vma
4420            + h1->root.u.def.section->output_offset);
4421       else
4422         {
4423           _bfd_error_handler
4424             (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4425              abfd);
4426           result = FALSE;
4427         }
4428
4429       h1 = coff_link_hash_lookup (coff_hash_table (info),
4430                                   ".idata$6", FALSE, FALSE, TRUE);
4431       if (h1 != NULL
4432           && (h1->root.type == bfd_link_hash_defined
4433            || h1->root.type == bfd_link_hash_defweak)
4434           && h1->root.u.def.section != NULL
4435           && h1->root.u.def.section->output_section != NULL)
4436         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4437           ((h1->root.u.def.value
4438             + h1->root.u.def.section->output_section->vma
4439             + h1->root.u.def.section->output_offset)
4440            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
4441       else
4442         {
4443           _bfd_error_handler
4444             (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4445              abfd);
4446           result = FALSE;
4447         }
4448     }
4449   else
4450     {
4451       h1 = coff_link_hash_lookup (coff_hash_table (info),
4452                                   "__IAT_start__", FALSE, FALSE, TRUE);
4453       if (h1 != NULL
4454           && (h1->root.type == bfd_link_hash_defined
4455            || h1->root.type == bfd_link_hash_defweak)
4456           && h1->root.u.def.section != NULL
4457           && h1->root.u.def.section->output_section != NULL)
4458         {
4459           bfd_vma iat_va;
4460
4461           iat_va =
4462             (h1->root.u.def.value
4463              + h1->root.u.def.section->output_section->vma
4464              + h1->root.u.def.section->output_offset);
4465
4466           h1 = coff_link_hash_lookup (coff_hash_table (info),
4467                                       "__IAT_end__", FALSE, FALSE, TRUE);
4468           if (h1 != NULL
4469               && (h1->root.type == bfd_link_hash_defined
4470                || h1->root.type == bfd_link_hash_defweak)
4471               && h1->root.u.def.section != NULL
4472               && h1->root.u.def.section->output_section != NULL)
4473             {
4474               pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4475                 ((h1->root.u.def.value
4476                   + h1->root.u.def.section->output_section->vma
4477                   + h1->root.u.def.section->output_offset)
4478                  - iat_va);
4479               if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
4480                 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4481                   iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
4482             }
4483           else
4484             {
4485               _bfd_error_handler
4486                 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4487                    " because .idata$6 is missing"), abfd);
4488               result = FALSE;
4489             }
4490         }
4491     }
4492
4493   h1 = coff_link_hash_lookup (coff_hash_table (info),
4494                               (bfd_get_symbol_leading_char (abfd) != 0
4495                                ? "__tls_used" : "_tls_used"),
4496                               FALSE, FALSE, TRUE);
4497   if (h1 != NULL)
4498     {
4499       if ((h1->root.type == bfd_link_hash_defined
4500            || h1->root.type == bfd_link_hash_defweak)
4501           && h1->root.u.def.section != NULL
4502           && h1->root.u.def.section->output_section != NULL)
4503         pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
4504           (h1->root.u.def.value
4505            + h1->root.u.def.section->output_section->vma
4506            + h1->root.u.def.section->output_offset
4507            - pe_data (abfd)->pe_opthdr.ImageBase);
4508       else
4509         {
4510           _bfd_error_handler
4511             (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4512              abfd);
4513           result = FALSE;
4514         }
4515      /* According to PECOFF sepcifications by Microsoft version 8.2
4516         the TLS data directory consists of 4 pointers, followed
4517         by two 4-byte integer. This implies that the total size
4518         is different for 32-bit and 64-bit executables.  */
4519 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4520       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
4521 #else
4522       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
4523 #endif
4524     }
4525
4526 /* If there is a .pdata section and we have linked pdata finally, we
4527      need to sort the entries ascending.  */
4528 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4529   {
4530     asection *sec = bfd_get_section_by_name (abfd, ".pdata");
4531
4532     if (sec)
4533       {
4534         bfd_size_type x = sec->rawsize;
4535         bfd_byte *tmp_data = NULL;
4536
4537         if (x)
4538           tmp_data = bfd_malloc (x);
4539
4540         if (tmp_data != NULL)
4541           {
4542             if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
4543               {
4544                 qsort (tmp_data,
4545                        (size_t) (x / 12),
4546                        12, sort_x64_pdata);
4547                 bfd_set_section_contents (pfinfo->output_bfd, sec,
4548                                           tmp_data, 0, x);
4549               }
4550             free (tmp_data);
4551           }
4552         else
4553           result = FALSE;
4554       }
4555   }
4556 #endif
4557
4558   rsrc_process_section (abfd, pfinfo);
4559
4560   /* If we couldn't find idata$2, we either have an excessively
4561      trivial program or are in DEEP trouble; we have to assume trivial
4562      program....  */
4563   return result;
4564 }