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   /* Only use a real timestamp if the option was chosen.  */
 881   if ((pe_data (abfd)->insert_timestamp))
 882     H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
 883   else
 884     H_PUT_32 (abfd, 0, filehdr_out->f_timdat);
 885
 886   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
 887                       filehdr_out->f_symptr);
 888   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 889   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 890   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 891
 892   /* Put in extra dos header stuff.  This data remains essentially
 893      constant, it just has to be tacked on to the beginning of all exes
 894      for NT.  */
 895   H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
 896   H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
 897   H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
 898   H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
 899   H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
 900   H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
 901   H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
 902   H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
 903   H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
 904   H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
 905   H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
 906   H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
 907   H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
 908   H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
 909
 910   for (idx = 0; idx < 4; idx++)
 911     H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
 912
 913   H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
 914   H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
 915
 916   for (idx = 0; idx < 10; idx++)
 917     H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
 918
 919   H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
 920
 921   for (idx = 0; idx < 16; idx++)
 922     H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
 923               filehdr_out->dos_message[idx]);
 924
 925   /* Also put in the NT signature.  */
 926   H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
 927
 928   return FILHSZ;
 929 }
 930
 931 unsigned int
 932 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
 933 {
 934   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 935   FILHDR *filehdr_out = (FILHDR *) out;
 936
 937   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
 938   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 939   H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
 940   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
 941   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 942   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 943   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 944
 945   return FILHSZ;
 946 }
 947
 948 unsigned int
 949 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
 950 {
 951   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 952   SCNHDR *scnhdr_ext = (SCNHDR *) out;
 953   unsigned int ret = SCNHSZ;
 954   bfd_vma ps;
 955   bfd_vma ss;
 956
 957   memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
 958
 959   PUT_SCNHDR_VADDR (abfd,
 960                     ((scnhdr_int->s_vaddr
 961                       - pe_data (abfd)->pe_opthdr.ImageBase)
 962                      & 0xffffffff),
 963                     scnhdr_ext->s_vaddr);
 964
 965   /* NT wants the size data to be rounded up to the next
 966      NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
 967      sometimes).  */
 968   if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
 969     {
 970       if (bfd_pei_p (abfd))
 971         {
 972           ps = scnhdr_int->s_size;
 973           ss = 0;
 974         }
 975       else
 976        {
 977          ps = 0;
 978          ss = scnhdr_int->s_size;
 979        }
 980     }
 981   else
 982     {
 983       if (bfd_pei_p (abfd))
 984         ps = scnhdr_int->s_paddr;
 985       else
 986         ps = 0;
 987
 988       ss = scnhdr_int->s_size;
 989     }
 990
 991   PUT_SCNHDR_SIZE (abfd, ss,
 992                    scnhdr_ext->s_size);
 993
 994   /* s_paddr in PE is really the virtual size.  */
 995   PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
 996
 997   PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
 998                      scnhdr_ext->s_scnptr);
 999   PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
1000                      scnhdr_ext->s_relptr);
1001   PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
1002                       scnhdr_ext->s_lnnoptr);
1003
1004   {
1005     /* Extra flags must be set when dealing with PE.  All sections should also
1006        have the IMAGE_SCN_MEM_READ (0x40000000) flag set.  In addition, the
1007        .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
1008        sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
1009        (this is especially important when dealing with the .idata section since
1010        the addresses for routines from .dlls must be overwritten).  If .reloc
1011        section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
1012        (0x02000000).  Also, the resource data should also be read and
1013        writable.  */
1014
1015     /* FIXME: Alignment is also encoded in this field, at least on PPC and
1016        ARM-WINCE.  Although - how do we get the original alignment field
1017        back ?  */
1018
1019     typedef struct
1020     {
1021       char section_name[SCNNMLEN];
1022       unsigned long     must_have;
1023     }
1024     pe_required_section_flags;
1025
1026     pe_required_section_flags known_sections [] =
1027       {
1028         { ".arch",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
1029         { ".bss",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1030         { ".data",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1031         { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1032         { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1033         { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1034         { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1035         { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
1036         { ".rsrc",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1037         { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
1038         { ".tls",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1039         { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1040       };
1041
1042     pe_required_section_flags * p;
1043
1044     /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1045        we know exactly what this specific section wants so we remove it
1046        and then allow the must_have field to add it back in if necessary.
1047        However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1048        default WP_TEXT file flag has been cleared.  WP_TEXT may be cleared
1049        by ld --enable-auto-import (if auto-import is actually needed),
1050        by ld --omagic, or by obcopy --writable-text.  */
1051
1052     for (p = known_sections;
1053          p < known_sections + ARRAY_SIZE (known_sections);
1054          p++)
1055       if (memcmp (scnhdr_int->s_name, p->section_name, SCNNMLEN) == 0)
1056         {
1057           if (memcmp (scnhdr_int->s_name, ".text", sizeof ".text")
1058               || (bfd_get_file_flags (abfd) & WP_TEXT))
1059             scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
1060           scnhdr_int->s_flags |= p->must_have;
1061           break;
1062         }
1063
1064     H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1065   }
1066
1067   if (coff_data (abfd)->link_info
1068       && ! bfd_link_relocatable (coff_data (abfd)->link_info)
1069       && ! bfd_link_pic (coff_data (abfd)->link_info)
1070       && memcmp (scnhdr_int->s_name, ".text", sizeof ".text") == 0)
1071     {
1072       /* By inference from looking at MS output, the 32 bit field
1073          which is the combination of the number_of_relocs and
1074          number_of_linenos is used for the line number count in
1075          executables.  A 16-bit field won't do for cc1.  The MS
1076          document says that the number of relocs is zero for
1077          executables, but the 17-th bit has been observed to be there.
1078          Overflow is not an issue: a 4G-line program will overflow a
1079          bunch of other fields long before this!  */
1080       H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
1081       H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
1082     }
1083   else
1084     {
1085       if (scnhdr_int->s_nlnno <= 0xffff)
1086         H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
1087       else
1088         {
1089           /* xgettext:c-format */
1090           _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1091                               abfd, scnhdr_int->s_nlnno);
1092           bfd_set_error (bfd_error_file_truncated);
1093           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1094           ret = 0;
1095         }
1096
1097       /* Although we could encode 0xffff relocs here, we do not, to be
1098          consistent with other parts of bfd. Also it lets us warn, as
1099          we should never see 0xffff here w/o having the overflow flag
1100          set.  */
1101       if (scnhdr_int->s_nreloc < 0xffff)
1102         H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1103       else
1104         {
1105           /* PE can deal with large #s of relocs, but not here.  */
1106           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1107           scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1108           H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1109         }
1110     }
1111   return ret;
1112 }
1113
1114 void
1115 _bfd_XXi_swap_debugdir_in (bfd * abfd, void * ext1, void * in1)
1116 {
1117   struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) ext1;
1118   struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) in1;
1119
1120   in->Characteristics = H_GET_32(abfd, ext->Characteristics);
1121   in->TimeDateStamp = H_GET_32(abfd, ext->TimeDateStamp);
1122   in->MajorVersion = H_GET_16(abfd, ext->MajorVersion);
1123   in->MinorVersion = H_GET_16(abfd, ext->MinorVersion);
1124   in->Type = H_GET_32(abfd, ext->Type);
1125   in->SizeOfData = H_GET_32(abfd, ext->SizeOfData);
1126   in->AddressOfRawData = H_GET_32(abfd, ext->AddressOfRawData);
1127   in->PointerToRawData = H_GET_32(abfd, ext->PointerToRawData);
1128 }
1129
1130 unsigned int
1131 _bfd_XXi_swap_debugdir_out (bfd * abfd, void * inp, void * extp)
1132 {
1133   struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) extp;
1134   struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) inp;
1135
1136   H_PUT_32(abfd, in->Characteristics, ext->Characteristics);
1137   H_PUT_32(abfd, in->TimeDateStamp, ext->TimeDateStamp);
1138   H_PUT_16(abfd, in->MajorVersion, ext->MajorVersion);
1139   H_PUT_16(abfd, in->MinorVersion, ext->MinorVersion);
1140   H_PUT_32(abfd, in->Type, ext->Type);
1141   H_PUT_32(abfd, in->SizeOfData, ext->SizeOfData);
1142   H_PUT_32(abfd, in->AddressOfRawData, ext->AddressOfRawData);
1143   H_PUT_32(abfd, in->PointerToRawData, ext->PointerToRawData);
1144
1145   return sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
1146 }
1147
1148 CODEVIEW_INFO *
1149 _bfd_XXi_slurp_codeview_record (bfd * abfd, file_ptr where, unsigned long length, CODEVIEW_INFO *cvinfo)
1150 {
1151   char buffer[256+1];
1152
1153   if (bfd_seek (abfd, where, SEEK_SET) != 0)
1154     return NULL;
1155
1156   if (bfd_bread (buffer, 256, abfd) < 4)
1157     return NULL;
1158
1159   /* Ensure null termination of filename.  */
1160   buffer[256] = '\0';
1161
1162   cvinfo->CVSignature = H_GET_32 (abfd, buffer);
1163   cvinfo->Age = 0;
1164
1165   if ((cvinfo->CVSignature == CVINFO_PDB70_CVSIGNATURE)
1166       && (length > sizeof (CV_INFO_PDB70)))
1167     {
1168       CV_INFO_PDB70 *cvinfo70 = (CV_INFO_PDB70 *)(buffer);
1169
1170       cvinfo->Age = H_GET_32(abfd, cvinfo70->Age);
1171
1172       /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1173          by 8 single bytes.  Byte swap them so we can conveniently treat the GUID
1174          as 16 bytes in big-endian order.  */
1175       bfd_putb32 (bfd_getl32 (cvinfo70->Signature), cvinfo->Signature);
1176       bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[4])), &(cvinfo->Signature[4]));
1177       bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[6])), &(cvinfo->Signature[6]));
1178       memcpy (&(cvinfo->Signature[8]), &(cvinfo70->Signature[8]), 8);
1179
1180       cvinfo->SignatureLength = CV_INFO_SIGNATURE_LENGTH;
1181       // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1182
1183       return cvinfo;
1184     }
1185   else if ((cvinfo->CVSignature == CVINFO_PDB20_CVSIGNATURE)
1186            && (length > sizeof (CV_INFO_PDB20)))
1187     {
1188       CV_INFO_PDB20 *cvinfo20 = (CV_INFO_PDB20 *)(buffer);
1189       cvinfo->Age = H_GET_32(abfd, cvinfo20->Age);
1190       memcpy (cvinfo->Signature, cvinfo20->Signature, 4);
1191       cvinfo->SignatureLength = 4;
1192       // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1193
1194       return cvinfo;
1195     }
1196
1197   return NULL;
1198 }
1199
1200 unsigned int
1201 _bfd_XXi_write_codeview_record (bfd * abfd, file_ptr where, CODEVIEW_INFO *cvinfo)
1202 {
1203   const bfd_size_type size = sizeof (CV_INFO_PDB70) + 1;
1204   bfd_size_type written;
1205   CV_INFO_PDB70 *cvinfo70;
1206   char * buffer;
1207
1208   if (bfd_seek (abfd, where, SEEK_SET) != 0)
1209     return 0;
1210
1211   buffer = xmalloc (size);
1212   cvinfo70 = (CV_INFO_PDB70 *) buffer;
1213   H_PUT_32 (abfd, CVINFO_PDB70_CVSIGNATURE, cvinfo70->CvSignature);
1214
1215   /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1216      in little-endian order, followed by 8 single bytes.  */
1217   bfd_putl32 (bfd_getb32 (cvinfo->Signature), cvinfo70->Signature);
1218   bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[4])), &(cvinfo70->Signature[4]));
1219   bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[6])), &(cvinfo70->Signature[6]));
1220   memcpy (&(cvinfo70->Signature[8]), &(cvinfo->Signature[8]), 8);
1221
1222   H_PUT_32 (abfd, cvinfo->Age, cvinfo70->Age);
1223   cvinfo70->PdbFileName[0] = '\0';
1224
1225   written = bfd_bwrite (buffer, size, abfd);
1226
1227   free (buffer);
1228
1229   return written == size ? size : 0;
1230 }
1231
1232 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1233 {
1234   N_("Export Directory [.edata (or where ever we found it)]"),
1235   N_("Import Directory [parts of .idata]"),
1236   N_("Resource Directory [.rsrc]"),
1237   N_("Exception Directory [.pdata]"),
1238   N_("Security Directory"),
1239   N_("Base Relocation Directory [.reloc]"),
1240   N_("Debug Directory"),
1241   N_("Description Directory"),
1242   N_("Special Directory"),
1243   N_("Thread Storage Directory [.tls]"),
1244   N_("Load Configuration Directory"),
1245   N_("Bound Import Directory"),
1246   N_("Import Address Table Directory"),
1247   N_("Delay Import Directory"),
1248   N_("CLR Runtime Header"),
1249   N_("Reserved")
1250 };
1251
1252 #ifdef POWERPC_LE_PE
1253 /* The code for the PPC really falls in the "architecture dependent"
1254    category.  However, it's not clear that anyone will ever care, so
1255    we're ignoring the issue for now; if/when PPC matters, some of this
1256    may need to go into peicode.h, or arguments passed to enable the
1257    PPC- specific code.  */
1258 #endif
1259
1260 static bfd_boolean
1261 pe_print_idata (bfd * abfd, void * vfile)
1262 {
1263   FILE *file = (FILE *) vfile;
1264   bfd_byte *data;
1265   asection *section;
1266   bfd_signed_vma adj;
1267
1268 #ifdef POWERPC_LE_PE
1269   asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1270 #endif
1271
1272   bfd_size_type datasize = 0;
1273   bfd_size_type dataoff;
1274   bfd_size_type i;
1275   int onaline = 20;
1276
1277   pe_data_type *pe = pe_data (abfd);
1278   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1279
1280   bfd_vma addr;
1281
1282   addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1283
1284   if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1285     {
1286       /* Maybe the extra header isn't there.  Look for the section.  */
1287       section = bfd_get_section_by_name (abfd, ".idata");
1288       if (section == NULL)
1289         return TRUE;
1290
1291       addr = section->vma;
1292       datasize = section->size;
1293       if (datasize == 0)
1294         return TRUE;
1295     }
1296   else
1297     {
1298       addr += extra->ImageBase;
1299       for (section = abfd->sections; section != NULL; section = section->next)
1300         {
1301           datasize = section->size;
1302           if (addr >= section->vma && addr < section->vma + datasize)
1303             break;
1304         }
1305
1306       if (section == NULL)
1307         {
1308           fprintf (file,
1309                    _("\nThere is an import table, but the section containing it could not be found\n"));
1310           return TRUE;
1311         }
1312       else if (!(section->flags & SEC_HAS_CONTENTS))
1313         {
1314           fprintf (file,
1315                    _("\nThere is an import table in %s, but that section has no contents\n"),
1316                    section->name);
1317           return TRUE;
1318         }
1319     }
1320
1321   /* xgettext:c-format */
1322   fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1323            section->name, (unsigned long) addr);
1324
1325   dataoff = addr - section->vma;
1326
1327 #ifdef POWERPC_LE_PE
1328   if (rel_section != 0 && rel_section->size != 0)
1329     {
1330       /* The toc address can be found by taking the starting address,
1331          which on the PPC locates a function descriptor. The
1332          descriptor consists of the function code starting address
1333          followed by the address of the toc. The starting address we
1334          get from the bfd, and the descriptor is supposed to be in the
1335          .reldata section.  */
1336
1337       bfd_vma loadable_toc_address;
1338       bfd_vma toc_address;
1339       bfd_vma start_address;
1340       bfd_byte *data;
1341       bfd_vma offset;
1342
1343       if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1344         {
1345           if (data != NULL)
1346             free (data);
1347           return FALSE;
1348         }
1349
1350       offset = abfd->start_address - rel_section->vma;
1351
1352       if (offset >= rel_section->size || offset + 8 > rel_section->size)
1353         {
1354           if (data != NULL)
1355             free (data);
1356           return FALSE;
1357         }
1358
1359       start_address = bfd_get_32 (abfd, data + offset);
1360       loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1361       toc_address = loadable_toc_address - 32768;
1362
1363       fprintf (file,
1364                _("\nFunction descriptor located at the start address: %04lx\n"),
1365                (unsigned long int) (abfd->start_address));
1366       fprintf (file,
1367                /* xgettext:c-format */
1368                _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1369                start_address, loadable_toc_address, toc_address);
1370       if (data != NULL)
1371         free (data);
1372     }
1373   else
1374     {
1375       fprintf (file,
1376                _("\nNo reldata section! Function descriptor not decoded.\n"));
1377     }
1378 #endif
1379
1380   fprintf (file,
1381            _("\nThe Import Tables (interpreted %s section contents)\n"),
1382            section->name);
1383   fprintf (file,
1384            _("\
1385  vma:            Hint    Time      Forward  DLL       First\n\
1386                  Table   Stamp     Chain    Name      Thunk\n"));
1387
1388   /* Read the whole section.  Some of the fields might be before dataoff.  */
1389   if (!bfd_malloc_and_get_section (abfd, section, &data))
1390     {
1391       if (data != NULL)
1392         free (data);
1393       return FALSE;
1394     }
1395
1396   adj = section->vma - extra->ImageBase;
1397
1398   /* Print all image import descriptors.  */
1399   for (i = dataoff; i + onaline <= datasize; i += onaline)
1400     {
1401       bfd_vma hint_addr;
1402       bfd_vma time_stamp;
1403       bfd_vma forward_chain;
1404       bfd_vma dll_name;
1405       bfd_vma first_thunk;
1406       int idx = 0;
1407       bfd_size_type j;
1408       char *dll;
1409
1410       /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress).  */
1411       fprintf (file, " %08lx\t", (unsigned long) (i + adj));
1412       hint_addr = bfd_get_32 (abfd, data + i);
1413       time_stamp = bfd_get_32 (abfd, data + i + 4);
1414       forward_chain = bfd_get_32 (abfd, data + i + 8);
1415       dll_name = bfd_get_32 (abfd, data + i + 12);
1416       first_thunk = bfd_get_32 (abfd, data + i + 16);
1417
1418       fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1419                (unsigned long) hint_addr,
1420                (unsigned long) time_stamp,
1421                (unsigned long) forward_chain,
1422                (unsigned long) dll_name,
1423                (unsigned long) first_thunk);
1424
1425       if (hint_addr == 0 && first_thunk == 0)
1426         break;
1427
1428       if (dll_name - adj >= section->size)
1429         break;
1430
1431       dll = (char *) data + dll_name - adj;
1432       /* PR 17512 file: 078-12277-0.004.  */
1433       bfd_size_type maxlen = (char *)(data + datasize) - dll - 1;
1434       fprintf (file, _("\n\tDLL Name: %.*s\n"), (int) maxlen, dll);
1435
1436       /* PR 21546: When the Hint Address is zero,
1437          we try the First Thunk instead.  */
1438       if (hint_addr == 0)
1439         hint_addr = first_thunk;
1440
1441       if (hint_addr != 0 && hint_addr - adj < datasize)
1442         {
1443           bfd_byte *ft_data;
1444           asection *ft_section;
1445           bfd_vma ft_addr;
1446           bfd_size_type ft_datasize;
1447           int ft_idx;
1448           int ft_allocated;
1449
1450           fprintf (file, _("\tvma:  Hint/Ord Member-Name Bound-To\n"));
1451
1452           idx = hint_addr - adj;
1453
1454           ft_addr = first_thunk + extra->ImageBase;
1455           ft_idx = first_thunk - adj;
1456           ft_data = data + ft_idx;
1457           ft_datasize = datasize - ft_idx;
1458           ft_allocated = 0;
1459
1460           if (first_thunk != hint_addr)
1461             {
1462               /* Find the section which contains the first thunk.  */
1463               for (ft_section = abfd->sections;
1464                    ft_section != NULL;
1465                    ft_section = ft_section->next)
1466                 {
1467                   if (ft_addr >= ft_section->vma
1468                       && ft_addr < ft_section->vma + ft_section->size)
1469                     break;
1470                 }
1471
1472               if (ft_section == NULL)
1473                 {
1474                   fprintf (file,
1475                        _("\nThere is a first thunk, but the section containing it could not be found\n"));
1476                   continue;
1477                 }
1478
1479               /* Now check to see if this section is the same as our current
1480                  section.  If it is not then we will have to load its data in.  */
1481               if (ft_section != section)
1482                 {
1483                   ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1484                   ft_datasize = ft_section->size - ft_idx;
1485                   ft_data = (bfd_byte *) bfd_malloc (ft_datasize);
1486                   if (ft_data == NULL)
1487                     continue;
1488
1489                   /* Read ft_datasize bytes starting at offset ft_idx.  */
1490                   if (!bfd_get_section_contents (abfd, ft_section, ft_data,
1491                                                  (bfd_vma) ft_idx, ft_datasize))
1492                     {
1493                       free (ft_data);
1494                       continue;
1495                     }
1496                   ft_allocated = 1;
1497                 }
1498             }
1499
1500           /* Print HintName vector entries.  */
1501 #ifdef COFF_WITH_pex64
1502           for (j = 0; idx + j + 8 <= datasize; j += 8)
1503             {
1504               bfd_size_type amt;
1505               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1506               unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1507
1508               if (!member && !member_high)
1509                 break;
1510
1511               amt = member - adj;
1512
1513               if (HighBitSet (member_high))
1514                 fprintf (file, "\t%lx%08lx\t %4lx%08lx  <none>",
1515                          member_high, member,
1516                          WithoutHighBit (member_high), member);
1517               /* PR binutils/17512: Handle corrupt PE data.  */
1518               else if (amt >= datasize || amt + 2 >= datasize)
1519                 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
1520               else
1521                 {
1522                   int ordinal;
1523                   char *member_name;
1524
1525                   ordinal = bfd_get_16 (abfd, data + amt);
1526                   member_name = (char *) data + amt + 2;
1527                   fprintf (file, "\t%04lx\t %4d  %.*s",member, ordinal,
1528                            (int) (datasize - (amt + 2)), member_name);
1529                 }
1530
1531               /* If the time stamp is not zero, the import address
1532                  table holds actual addresses.  */
1533               if (time_stamp != 0
1534                   && first_thunk != 0
1535                   && first_thunk != hint_addr
1536                   && j + 4 <= ft_datasize)
1537                 fprintf (file, "\t%04lx",
1538                          (unsigned long) bfd_get_32 (abfd, ft_data + j));
1539               fprintf (file, "\n");
1540             }
1541 #else
1542           for (j = 0; idx + j + 4 <= datasize; j += 4)
1543             {
1544               bfd_size_type amt;
1545               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1546
1547               /* Print single IMAGE_IMPORT_BY_NAME vector.  */
1548               if (member == 0)
1549                 break;
1550
1551               amt = member - adj;
1552
1553               if (HighBitSet (member))
1554                 fprintf (file, "\t%04lx\t %4lu  <none>",
1555                          member, WithoutHighBit (member));
1556               /* PR binutils/17512: Handle corrupt PE data.  */
1557               else if (amt >= datasize || amt + 2 >= datasize)
1558                 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
1559               else
1560                 {
1561                   int ordinal;
1562                   char *member_name;
1563
1564                   ordinal = bfd_get_16 (abfd, data + amt);
1565                   member_name = (char *) data + amt + 2;
1566                   fprintf (file, "\t%04lx\t %4d  %.*s",
1567                            member, ordinal,
1568                            (int) (datasize - (amt + 2)), member_name);
1569                 }
1570
1571               /* If the time stamp is not zero, the import address
1572                  table holds actual addresses.  */
1573               if (time_stamp != 0
1574                   && first_thunk != 0
1575                   && first_thunk != hint_addr
1576                   && j + 4 <= ft_datasize)
1577                 fprintf (file, "\t%04lx",
1578                          (unsigned long) bfd_get_32 (abfd, ft_data + j));
1579
1580               fprintf (file, "\n");
1581             }
1582 #endif
1583           if (ft_allocated)
1584             free (ft_data);
1585         }
1586
1587       fprintf (file, "\n");
1588     }
1589
1590   free (data);
1591
1592   return TRUE;
1593 }
1594
1595 static bfd_boolean
1596 pe_print_edata (bfd * abfd, void * vfile)
1597 {
1598   FILE *file = (FILE *) vfile;
1599   bfd_byte *data;
1600   asection *section;
1601   bfd_size_type datasize = 0;
1602   bfd_size_type dataoff;
1603   bfd_size_type i;
1604   bfd_vma       adj;
1605   struct EDT_type
1606   {
1607     long export_flags;          /* Reserved - should be zero.  */
1608     long time_stamp;
1609     short major_ver;
1610     short minor_ver;
1611     bfd_vma name;               /* RVA - relative to image base.  */
1612     long base;                  /* Ordinal base.  */
1613     unsigned long num_functions;/* Number in the export address table.  */
1614     unsigned long num_names;    /* Number in the name pointer table.  */
1615     bfd_vma eat_addr;           /* RVA to the export address table.  */
1616     bfd_vma npt_addr;           /* RVA to the Export Name Pointer Table.  */
1617     bfd_vma ot_addr;            /* RVA to the Ordinal Table.  */
1618   } edt;
1619
1620   pe_data_type *pe = pe_data (abfd);
1621   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1622
1623   bfd_vma addr;
1624
1625   addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1626
1627   if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1628     {
1629       /* Maybe the extra header isn't there.  Look for the section.  */
1630       section = bfd_get_section_by_name (abfd, ".edata");
1631       if (section == NULL)
1632         return TRUE;
1633
1634       addr = section->vma;
1635       dataoff = 0;
1636       datasize = section->size;
1637       if (datasize == 0)
1638         return TRUE;
1639     }
1640   else
1641     {
1642       addr += extra->ImageBase;
1643
1644       for (section = abfd->sections; section != NULL; section = section->next)
1645         if (addr >= section->vma && addr < section->vma + section->size)
1646           break;
1647
1648       if (section == NULL)
1649         {
1650           fprintf (file,
1651                    _("\nThere is an export table, but the section containing it could not be found\n"));
1652           return TRUE;
1653         }
1654       else if (!(section->flags & SEC_HAS_CONTENTS))
1655         {
1656           fprintf (file,
1657                    _("\nThere is an export table in %s, but that section has no contents\n"),
1658                    section->name);
1659           return TRUE;
1660         }
1661
1662       dataoff = addr - section->vma;
1663       datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1664       if (dataoff > section->size
1665           || datasize > section->size - dataoff)
1666         {
1667           fprintf (file,
1668                    _("\nThere is an export table in %s, but it does not fit into that section\n"),
1669                    section->name);
1670           return TRUE;
1671         }
1672     }
1673
1674   /* PR 17512: Handle corrupt PE binaries.  */
1675   if (datasize < 40)
1676     {
1677       fprintf (file,
1678                /* xgettext:c-format */
1679                _("\nThere is an export table in %s, but it is too small (%d)\n"),
1680                section->name, (int) datasize);
1681       return TRUE;
1682     }
1683
1684   /* xgettext:c-format */
1685   fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1686            section->name, (unsigned long) addr);
1687
1688   data = (bfd_byte *) bfd_malloc (datasize);
1689   if (data == NULL)
1690     return FALSE;
1691
1692   if (! bfd_get_section_contents (abfd, section, data,
1693                                   (file_ptr) dataoff, datasize))
1694     return FALSE;
1695
1696   /* Go get Export Directory Table.  */
1697   edt.export_flags   = bfd_get_32 (abfd, data +  0);
1698   edt.time_stamp     = bfd_get_32 (abfd, data +  4);
1699   edt.major_ver      = bfd_get_16 (abfd, data +  8);
1700   edt.minor_ver      = bfd_get_16 (abfd, data + 10);
1701   edt.name           = bfd_get_32 (abfd, data + 12);
1702   edt.base           = bfd_get_32 (abfd, data + 16);
1703   edt.num_functions  = bfd_get_32 (abfd, data + 20);
1704   edt.num_names      = bfd_get_32 (abfd, data + 24);
1705   edt.eat_addr       = bfd_get_32 (abfd, data + 28);
1706   edt.npt_addr       = bfd_get_32 (abfd, data + 32);
1707   edt.ot_addr        = bfd_get_32 (abfd, data + 36);
1708
1709   adj = section->vma - extra->ImageBase + dataoff;
1710
1711   /* Dump the EDT first.  */
1712   fprintf (file,
1713            _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1714            section->name);
1715
1716   fprintf (file,
1717            _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1718
1719   fprintf (file,
1720            _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1721
1722   fprintf (file,
1723            /* xgettext:c-format */
1724            _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1725
1726   fprintf (file,
1727            _("Name \t\t\t\t"));
1728   bfd_fprintf_vma (abfd, file, edt.name);
1729
1730   if ((edt.name >= adj) && (edt.name < adj + datasize))
1731     fprintf (file, " %.*s\n",
1732              (int) (datasize - (edt.name - adj)),
1733              data + edt.name - adj);
1734   else
1735     fprintf (file, "(outside .edata section)\n");
1736
1737   fprintf (file,
1738            _("Ordinal Base \t\t\t%ld\n"), edt.base);
1739
1740   fprintf (file,
1741            _("Number in:\n"));
1742
1743   fprintf (file,
1744            _("\tExport Address Table \t\t%08lx\n"),
1745            edt.num_functions);
1746
1747   fprintf (file,
1748            _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1749
1750   fprintf (file,
1751            _("Table Addresses\n"));
1752
1753   fprintf (file,
1754            _("\tExport Address Table \t\t"));
1755   bfd_fprintf_vma (abfd, file, edt.eat_addr);
1756   fprintf (file, "\n");
1757
1758   fprintf (file,
1759            _("\tName Pointer Table \t\t"));
1760   bfd_fprintf_vma (abfd, file, edt.npt_addr);
1761   fprintf (file, "\n");
1762
1763   fprintf (file,
1764            _("\tOrdinal Table \t\t\t"));
1765   bfd_fprintf_vma (abfd, file, edt.ot_addr);
1766   fprintf (file, "\n");
1767
1768   /* The next table to find is the Export Address Table. It's basically
1769      a list of pointers that either locate a function in this dll, or
1770      forward the call to another dll. Something like:
1771       typedef union
1772       {
1773         long export_rva;
1774         long forwarder_rva;
1775       } export_address_table_entry;  */
1776
1777   fprintf (file,
1778           _("\nExport Address Table -- Ordinal Base %ld\n"),
1779           edt.base);
1780
1781   /* PR 17512: Handle corrupt PE binaries.  */
1782   /* PR 17512 file: 140-165018-0.004.  */
1783   if (edt.eat_addr - adj >= datasize
1784       /* PR 17512: file: 092b1829 */
1785       || (edt.num_functions + 1) * 4 < edt.num_functions
1786       || edt.eat_addr - adj + (edt.num_functions + 1) * 4 > datasize)
1787     fprintf (file, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1788              (long) edt.eat_addr,
1789              (long) edt.num_functions);
1790   else for (i = 0; i < edt.num_functions; ++i)
1791     {
1792       bfd_vma eat_member = bfd_get_32 (abfd,
1793                                        data + edt.eat_addr + (i * 4) - adj);
1794       if (eat_member == 0)
1795         continue;
1796
1797       if (eat_member - adj <= datasize)
1798         {
1799           /* This rva is to a name (forwarding function) in our section.  */
1800           /* Should locate a function descriptor.  */
1801           fprintf (file,
1802                    "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1803                    (long) i,
1804                    (long) (i + edt.base),
1805                    (unsigned long) eat_member,
1806                    _("Forwarder RVA"),
1807                    (int)(datasize - (eat_member - adj)),
1808                    data + eat_member - adj);
1809         }
1810       else
1811         {
1812           /* Should locate a function descriptor in the reldata section.  */
1813           fprintf (file,
1814                    "\t[%4ld] +base[%4ld] %04lx %s\n",
1815                    (long) i,
1816                    (long) (i + edt.base),
1817                    (unsigned long) eat_member,
1818                    _("Export RVA"));
1819         }
1820     }
1821
1822   /* The Export Name Pointer Table is paired with the Export Ordinal Table.  */
1823   /* Dump them in parallel for clarity.  */
1824   fprintf (file,
1825            _("\n[Ordinal/Name Pointer] Table\n"));
1826
1827   /* PR 17512: Handle corrupt PE binaries.  */
1828   if (edt.npt_addr + (edt.num_names * 4) - adj >= datasize
1829       /* PR 17512: file: bb68816e.  */
1830       || edt.num_names * 4 < edt.num_names
1831       || (data + edt.npt_addr - adj) < data)
1832     /* xgettext:c-format */
1833     fprintf (file, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1834              (long) edt.npt_addr,
1835              (long) edt.num_names);
1836   /* PR 17512: file: 140-147171-0.004.  */
1837   else if (edt.ot_addr + (edt.num_names * 2) - adj >= datasize
1838            || data + edt.ot_addr - adj < data)
1839     /* xgettext:c-format */
1840     fprintf (file, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1841              (long) edt.ot_addr,
1842              (long) edt.num_names);
1843   else for (i = 0; i < edt.num_names; ++i)
1844     {
1845       bfd_vma  name_ptr;
1846       bfd_vma  ord;
1847
1848       ord = bfd_get_16 (abfd, data + edt.ot_addr + (i * 2) - adj);
1849       name_ptr = bfd_get_32 (abfd, data + edt.npt_addr + (i * 4) - adj);
1850
1851       if ((name_ptr - adj) >= datasize)
1852         {
1853           /* xgettext:c-format */
1854           fprintf (file, _("\t[%4ld] <corrupt offset: %lx>\n"),
1855                    (long) ord, (long) name_ptr);
1856         }
1857       else
1858         {
1859           char * name = (char *) data + name_ptr - adj;
1860
1861           fprintf (file, "\t[%4ld] %.*s\n", (long) ord,
1862                    (int)((char *)(data + datasize) - name), name);
1863         }
1864     }
1865
1866   free (data);
1867
1868   return TRUE;
1869 }
1870
1871 /* This really is architecture dependent.  On IA-64, a .pdata entry
1872    consists of three dwords containing relative virtual addresses that
1873    specify the start and end address of the code range the entry
1874    covers and the address of the corresponding unwind info data.
1875
1876    On ARM and SH-4, a compressed PDATA structure is used :
1877    _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1878    _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1879    See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1880
1881    This is the version for uncompressed data.  */
1882
1883 static bfd_boolean
1884 pe_print_pdata (bfd * abfd, void * vfile)
1885 {
1886 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1887 # define PDATA_ROW_SIZE (3 * 8)
1888 #else
1889 # define PDATA_ROW_SIZE (5 * 4)
1890 #endif
1891   FILE *file = (FILE *) vfile;
1892   bfd_byte *data = 0;
1893   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1894   bfd_size_type datasize = 0;
1895   bfd_size_type i;
1896   bfd_size_type start, stop;
1897   int onaline = PDATA_ROW_SIZE;
1898
1899   if (section == NULL
1900       || coff_section_data (abfd, section) == NULL
1901       || pei_section_data (abfd, section) == NULL)
1902     return TRUE;
1903
1904   stop = pei_section_data (abfd, section)->virt_size;
1905   if ((stop % onaline) != 0)
1906     fprintf (file,
1907              /* xgettext:c-format */
1908              _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1909              (long) stop, onaline);
1910
1911   fprintf (file,
1912            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1913 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1914   fprintf (file,
1915            _(" vma:\t\t\tBegin Address    End Address      Unwind Info\n"));
1916 #else
1917   fprintf (file, _("\
1918  vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n\
1919      \t\tAddress  Address  Handler  Data     Address    Mask\n"));
1920 #endif
1921
1922   datasize = section->size;
1923   if (datasize == 0)
1924     return TRUE;
1925
1926   /* PR 17512: file: 002-193900-0.004.  */
1927   if (datasize < stop)
1928     {
1929       /* xgettext:c-format */
1930       fprintf (file, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1931                (long) stop, (long) datasize);
1932       return FALSE;
1933     }
1934
1935   if (! bfd_malloc_and_get_section (abfd, section, &data))
1936     {
1937       if (data != NULL)
1938         free (data);
1939       return FALSE;
1940     }
1941
1942   start = 0;
1943
1944   for (i = start; i < stop; i += onaline)
1945     {
1946       bfd_vma begin_addr;
1947       bfd_vma end_addr;
1948       bfd_vma eh_handler;
1949       bfd_vma eh_data;
1950       bfd_vma prolog_end_addr;
1951 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1952       int em_data;
1953 #endif
1954
1955       if (i + PDATA_ROW_SIZE > stop)
1956         break;
1957
1958       begin_addr      = GET_PDATA_ENTRY (abfd, data + i     );
1959       end_addr        = GET_PDATA_ENTRY (abfd, data + i +  4);
1960       eh_handler      = GET_PDATA_ENTRY (abfd, data + i +  8);
1961       eh_data         = GET_PDATA_ENTRY (abfd, data + i + 12);
1962       prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1963
1964       if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1965           && eh_data == 0 && prolog_end_addr == 0)
1966         /* We are probably into the padding of the section now.  */
1967         break;
1968
1969 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1970       em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1971 #endif
1972       eh_handler &= ~(bfd_vma) 0x3;
1973       prolog_end_addr &= ~(bfd_vma) 0x3;
1974
1975       fputc (' ', file);
1976       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1977       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1978       bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1979       bfd_fprintf_vma (abfd, file, eh_handler);
1980 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1981       fputc (' ', file);
1982       bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1983       bfd_fprintf_vma (abfd, file, prolog_end_addr);
1984       fprintf (file, "   %x", em_data);
1985 #endif
1986
1987 #ifdef POWERPC_LE_PE
1988       if (eh_handler == 0 && eh_data != 0)
1989         {
1990           /* Special bits here, although the meaning may be a little
1991              mysterious. The only one I know for sure is 0x03
1992              Code Significance
1993              0x00 None
1994              0x01 Register Save Millicode
1995              0x02 Register Restore Millicode
1996              0x03 Glue Code Sequence.  */
1997           switch (eh_data)
1998             {
1999             case 0x01:
2000               fprintf (file, _(" Register save millicode"));
2001               break;
2002             case 0x02:
2003               fprintf (file, _(" Register restore millicode"));
2004               break;
2005             case 0x03:
2006               fprintf (file, _(" Glue code sequence"));
2007               break;
2008             default:
2009               break;
2010             }
2011         }
2012 #endif
2013       fprintf (file, "\n");
2014     }
2015
2016   free (data);
2017
2018   return TRUE;
2019 #undef PDATA_ROW_SIZE
2020 }
2021
2022 typedef struct sym_cache
2023 {
2024   int        symcount;
2025   asymbol ** syms;
2026 } sym_cache;
2027
2028 static asymbol **
2029 slurp_symtab (bfd *abfd, sym_cache *psc)
2030 {
2031   asymbol ** sy = NULL;
2032   long storage;
2033
2034   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
2035     {
2036       psc->symcount = 0;
2037       return NULL;
2038     }
2039
2040   storage = bfd_get_symtab_upper_bound (abfd);
2041   if (storage < 0)
2042     return NULL;
2043   if (storage)
2044     {
2045       sy = (asymbol **) bfd_malloc (storage);
2046       if (sy == NULL)
2047         return NULL;
2048     }
2049
2050   psc->symcount = bfd_canonicalize_symtab (abfd, sy);
2051   if (psc->symcount < 0)
2052     return NULL;
2053   return sy;
2054 }
2055
2056 static const char *
2057 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
2058 {
2059   int i;
2060
2061   if (psc->syms == 0)
2062     psc->syms = slurp_symtab (abfd, psc);
2063
2064   for (i = 0; i < psc->symcount; i++)
2065     {
2066       if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
2067         return psc->syms[i]->name;
2068     }
2069
2070   return NULL;
2071 }
2072
2073 static void
2074 cleanup_syms (sym_cache *psc)
2075 {
2076   psc->symcount = 0;
2077   free (psc->syms);
2078   psc->syms = NULL;
2079 }
2080
2081 /* This is the version for "compressed" pdata.  */
2082
2083 bfd_boolean
2084 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
2085 {
2086 # define PDATA_ROW_SIZE (2 * 4)
2087   FILE *file = (FILE *) vfile;
2088   bfd_byte *data = NULL;
2089   asection *section = bfd_get_section_by_name (abfd, ".pdata");
2090   bfd_size_type datasize = 0;
2091   bfd_size_type i;
2092   bfd_size_type start, stop;
2093   int onaline = PDATA_ROW_SIZE;
2094   struct sym_cache cache = {0, 0} ;
2095
2096   if (section == NULL
2097       || coff_section_data (abfd, section) == NULL
2098       || pei_section_data (abfd, section) == NULL)
2099     return TRUE;
2100
2101   stop = pei_section_data (abfd, section)->virt_size;
2102   if ((stop % onaline) != 0)
2103     fprintf (file,
2104              /* xgettext:c-format */
2105              _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2106              (long) stop, onaline);
2107
2108   fprintf (file,
2109            _("\nThe Function Table (interpreted .pdata section contents)\n"));
2110
2111   fprintf (file, _("\
2112  vma:\t\tBegin    Prolog   Function Flags    Exception EH\n\
2113      \t\tAddress  Length   Length   32b exc  Handler   Data\n"));
2114
2115   datasize = section->size;
2116   if (datasize == 0)
2117     return TRUE;
2118
2119   if (! bfd_malloc_and_get_section (abfd, section, &data))
2120     {
2121       if (data != NULL)
2122         free (data);
2123       return FALSE;
2124     }
2125
2126   start = 0;
2127
2128   for (i = start; i < stop; i += onaline)
2129     {
2130       bfd_vma begin_addr;
2131       bfd_vma other_data;
2132       bfd_vma prolog_length, function_length;
2133       int flag32bit, exception_flag;
2134       asection *tsection;
2135
2136       if (i + PDATA_ROW_SIZE > stop)
2137         break;
2138
2139       begin_addr = GET_PDATA_ENTRY (abfd, data + i     );
2140       other_data = GET_PDATA_ENTRY (abfd, data + i +  4);
2141
2142       if (begin_addr == 0 && other_data == 0)
2143         /* We are probably into the padding of the section now.  */
2144         break;
2145
2146       prolog_length = (other_data & 0x000000FF);
2147       function_length = (other_data & 0x3FFFFF00) >> 8;
2148       flag32bit = (int)((other_data & 0x40000000) >> 30);
2149       exception_flag = (int)((other_data & 0x80000000) >> 31);
2150
2151       fputc (' ', file);
2152       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
2153       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
2154       bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
2155       bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
2156       fprintf (file, "%2d  %2d   ", flag32bit, exception_flag);
2157
2158       /* Get the exception handler's address and the data passed from the
2159          .text section. This is really the data that belongs with the .pdata
2160          but got "compressed" out for the ARM and SH4 architectures.  */
2161       tsection = bfd_get_section_by_name (abfd, ".text");
2162       if (tsection && coff_section_data (abfd, tsection)
2163           && pei_section_data (abfd, tsection))
2164         {
2165           bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
2166           bfd_byte *tdata;
2167
2168           tdata = (bfd_byte *) bfd_malloc (8);
2169           if (tdata)
2170             {
2171               if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
2172                 {
2173                   bfd_vma eh, eh_data;
2174
2175                   eh = bfd_get_32 (abfd, tdata);
2176                   eh_data = bfd_get_32 (abfd, tdata + 4);
2177                   fprintf (file, "%08x  ", (unsigned int) eh);
2178                   fprintf (file, "%08x", (unsigned int) eh_data);
2179                   if (eh != 0)
2180                     {
2181                       const char *s = my_symbol_for_address (abfd, eh, &cache);
2182
2183                       if (s)
2184                         fprintf (file, " (%s) ", s);
2185                     }
2186                 }
2187               free (tdata);
2188             }
2189         }
2190
2191       fprintf (file, "\n");
2192     }
2193
2194   free (data);
2195
2196   cleanup_syms (& cache);
2197
2198   return TRUE;
2199 #undef PDATA_ROW_SIZE
2200 }
2201
2202 \f
2203 #define IMAGE_REL_BASED_HIGHADJ 4
2204 static const char * const tbl[] =
2205 {
2206   "ABSOLUTE",
2207   "HIGH",
2208   "LOW",
2209   "HIGHLOW",
2210   "HIGHADJ",
2211   "MIPS_JMPADDR",
2212   "SECTION",
2213   "REL32",
2214   "RESERVED1",
2215   "MIPS_JMPADDR16",
2216   "DIR64",
2217   "HIGH3ADJ",
2218   "UNKNOWN",   /* MUST be last.  */
2219 };
2220
2221 static bfd_boolean
2222 pe_print_reloc (bfd * abfd, void * vfile)
2223 {
2224   FILE *file = (FILE *) vfile;
2225   bfd_byte *data = 0;
2226   asection *section = bfd_get_section_by_name (abfd, ".reloc");
2227   bfd_byte *p, *end;
2228
2229   if (section == NULL || section->size == 0 || !(section->flags & SEC_HAS_CONTENTS))
2230     return TRUE;
2231
2232   fprintf (file,
2233            _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2234
2235   if (! bfd_malloc_and_get_section (abfd, section, &data))
2236     {
2237       if (data != NULL)
2238         free (data);
2239       return FALSE;
2240     }
2241
2242   p = data;
2243   end = data + section->size;
2244   while (p + 8 <= end)
2245     {
2246       int j;
2247       bfd_vma virtual_address;
2248       unsigned long number, size;
2249       bfd_byte *chunk_end;
2250
2251       /* The .reloc section is a sequence of blocks, with a header consisting
2252          of two 32 bit quantities, followed by a number of 16 bit entries.  */
2253       virtual_address = bfd_get_32 (abfd, p);
2254       size = bfd_get_32 (abfd, p + 4);
2255       p += 8;
2256       number = (size - 8) / 2;
2257
2258       if (size == 0)
2259         break;
2260
2261       fprintf (file,
2262                /* xgettext:c-format */
2263                _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2264                (unsigned long) virtual_address, size, size, number);
2265
2266       chunk_end = p - 8 + size;
2267       if (chunk_end > end)
2268         chunk_end = end;
2269       j = 0;
2270       while (p + 2 <= chunk_end)
2271         {
2272           unsigned short e = bfd_get_16 (abfd, p);
2273           unsigned int t = (e & 0xF000) >> 12;
2274           int off = e & 0x0FFF;
2275
2276           if (t >= sizeof (tbl) / sizeof (tbl[0]))
2277             t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
2278
2279           fprintf (file,
2280                    /* xgettext:c-format */
2281                    _("\treloc %4d offset %4x [%4lx] %s"),
2282                    j, off, (unsigned long) (off + virtual_address), tbl[t]);
2283
2284           p += 2;
2285           j++;
2286
2287           /* HIGHADJ takes an argument, - the next record *is* the
2288              low 16 bits of addend.  */
2289           if (t == IMAGE_REL_BASED_HIGHADJ && p + 2 <= chunk_end)
2290             {
2291               fprintf (file, " (%4x)", (unsigned int) bfd_get_16 (abfd, p));
2292               p += 2;
2293               j++;
2294             }
2295
2296           fprintf (file, "\n");
2297         }
2298     }
2299
2300   free (data);
2301
2302   return TRUE;
2303 }
2304 \f
2305 /* A data structure describing the regions of a .rsrc section.
2306    Some fields are filled in as the section is parsed.  */
2307
2308 typedef struct rsrc_regions
2309 {
2310   bfd_byte * section_start;
2311   bfd_byte * section_end;
2312   bfd_byte * strings_start;
2313   bfd_byte * resource_start;
2314 } rsrc_regions;
2315
2316 static bfd_byte *
2317 rsrc_print_resource_directory (FILE * , bfd *, unsigned int, bfd_byte *,
2318                                rsrc_regions *, bfd_vma);
2319
2320 /* Print the resource entry at DATA, with the text indented by INDENT.
2321    Recusively calls rsrc_print_resource_directory to print the contents
2322    of directory entries.
2323    Returns the address of the end of the data associated with the entry
2324    or section_end + 1 upon failure.  */
2325
2326 static bfd_byte *
2327 rsrc_print_resource_entries (FILE *         file,
2328                              bfd *          abfd,
2329                              unsigned int   indent,
2330                              bfd_boolean    is_name,
2331                              bfd_byte *     data,
2332                              rsrc_regions * regions,
2333                              bfd_vma        rva_bias)
2334 {
2335   unsigned long entry, addr, size;
2336   bfd_byte * leaf;
2337
2338   if (data + 8 >= regions->section_end)
2339     return regions->section_end + 1;
2340
2341   /* xgettext:c-format */
2342   fprintf (file, _("%03x %*.s Entry: "), (int)(data - regions->section_start), indent, " ");
2343
2344   entry = (unsigned long) bfd_get_32 (abfd, data);
2345   if (is_name)
2346     {
2347       bfd_byte * name;
2348
2349       /* Note - the documentation says that this field is an RVA value
2350          but windres appears to produce a section relative offset with
2351          the top bit set.  Support both styles for now.  */
2352       if (HighBitSet (entry))
2353         name = regions->section_start + WithoutHighBit (entry);
2354       else
2355         name = regions->section_start + entry - rva_bias;
2356
2357       if (name + 2 < regions->section_end && name > regions->section_start)
2358         {
2359           unsigned int len;
2360
2361           if (regions->strings_start == NULL)
2362             regions->strings_start = name;
2363
2364           len = bfd_get_16 (abfd, name);
2365
2366           fprintf (file, _("name: [val: %08lx len %d]: "), entry, len);
2367
2368           if (name + 2 + len * 2 < regions->section_end)
2369             {
2370               /* This strange loop is to cope with multibyte characters.  */
2371               while (len --)
2372                 {
2373                   char c;
2374
2375                   name += 2;
2376                   c = * name;
2377                   /* Avoid printing control characters.  */
2378                   if (c > 0 && c < 32)
2379                     fprintf (file, "^%c", c + 64);
2380                   else
2381                     fprintf (file, "%.1s", name);
2382                 }
2383             }
2384           else
2385             {
2386               fprintf (file, _("<corrupt string length: %#x>\n"), len);
2387               /* PR binutils/17512: Do not try to continue decoding a
2388                  corrupted resource section.  It is likely to end up with
2389                  reams of extraneous output.  FIXME: We could probably
2390                  continue if we disable the printing of strings...  */
2391               return regions->section_end + 1;
2392             }
2393         }
2394       else
2395         {
2396           fprintf (file, _("<corrupt string offset: %#lx>\n"), entry);
2397           return regions->section_end + 1;
2398         }
2399     }
2400   else
2401     fprintf (file, _("ID: %#08lx"), entry);
2402
2403   entry = (long) bfd_get_32 (abfd, data + 4);
2404   fprintf (file, _(", Value: %#08lx\n"), entry);
2405
2406   if (HighBitSet  (entry))
2407     {
2408       data = regions->section_start + WithoutHighBit (entry);
2409       if (data <= regions->section_start || data > regions->section_end)
2410         return regions->section_end + 1;
2411
2412       /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2413          in the resource table.  We need some way to detect this.  */
2414       return rsrc_print_resource_directory (file, abfd, indent + 1, data,
2415                                             regions, rva_bias);
2416     }
2417
2418   leaf = regions->section_start + entry;
2419
2420   if (leaf + 16 >= regions->section_end
2421       /* PR 17512: file: 055dff7e.  */
2422       || leaf < regions->section_start)
2423     return regions->section_end + 1;
2424
2425   /* xgettext:c-format */
2426   fprintf (file, _("%03x %*.s  Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2427            (int) (entry), indent, " ",
2428            addr = (long) bfd_get_32 (abfd, leaf),
2429            size = (long) bfd_get_32 (abfd, leaf + 4),
2430            (int) bfd_get_32 (abfd, leaf + 8));
2431
2432   /* Check that the reserved entry is 0.  */
2433   if (bfd_get_32 (abfd, leaf + 12) != 0
2434       /* And that the data address/size is valid too.  */
2435       || (regions->section_start + (addr - rva_bias) + size > regions->section_end))
2436     return regions->section_end + 1;
2437
2438   if (regions->resource_start == NULL)
2439     regions->resource_start = regions->section_start + (addr - rva_bias);
2440
2441   return regions->section_start + (addr - rva_bias) + size;
2442 }
2443
2444 #define max(a,b) ((a) > (b) ? (a) : (b))
2445 #define min(a,b) ((a) < (b) ? (a) : (b))
2446
2447 static bfd_byte *
2448 rsrc_print_resource_directory (FILE *         file,
2449                                bfd *          abfd,
2450                                unsigned int   indent,
2451                                bfd_byte *     data,
2452                                rsrc_regions * regions,
2453                                bfd_vma        rva_bias)
2454 {
2455   unsigned int num_names, num_ids;
2456   bfd_byte * highest_data = data;
2457
2458   if (data + 16 >= regions->section_end)
2459     return regions->section_end + 1;
2460
2461   fprintf (file, "%03x %*.s ", (int)(data - regions->section_start), indent, " ");
2462   switch (indent)
2463     {
2464     case 0: fprintf (file, "Type"); break;
2465     case 2: fprintf (file, "Name"); break;
2466     case 4: fprintf (file, "Language"); break;
2467     default:
2468       fprintf (file, _("<unknown directory type: %d>\n"), indent);
2469       /* FIXME: For now we end the printing here.  If in the
2470          future more directory types are added to the RSRC spec
2471          then we will need to change this.  */
2472       return regions->section_end + 1;
2473     }
2474
2475   /* xgettext:c-format */
2476   fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2477            (int) bfd_get_32 (abfd, data),
2478            (long) bfd_get_32 (abfd, data + 4),
2479            (int)  bfd_get_16 (abfd, data + 8),
2480            (int)  bfd_get_16 (abfd, data + 10),
2481            num_names = (int) bfd_get_16 (abfd, data + 12),
2482            num_ids =   (int) bfd_get_16 (abfd, data + 14));
2483   data += 16;
2484
2485   while (num_names --)
2486     {
2487       bfd_byte * entry_end;
2488
2489       entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE,
2490                                                data, regions, rva_bias);
2491       data += 8;
2492       highest_data = max (highest_data, entry_end);
2493       if (entry_end >= regions->section_end)
2494         return entry_end;
2495     }
2496
2497   while (num_ids --)
2498     {
2499       bfd_byte * entry_end;
2500
2501       entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE,
2502                                                data, regions, rva_bias);
2503       data += 8;
2504       highest_data = max (highest_data, entry_end);
2505       if (entry_end >= regions->section_end)
2506         return entry_end;
2507     }
2508
2509   return max (highest_data, data);
2510 }
2511
2512 /* Display the contents of a .rsrc section.  We do not try to
2513    reproduce the resources, windres does that.  Instead we dump
2514    the tables in a human readable format.  */
2515
2516 static bfd_boolean
2517 rsrc_print_section (bfd * abfd, void * vfile)
2518 {
2519   bfd_vma rva_bias;
2520   pe_data_type * pe;
2521   FILE * file = (FILE *) vfile;
2522   bfd_size_type datasize;
2523   asection * section;
2524   bfd_byte * data;
2525   rsrc_regions regions;
2526
2527   pe = pe_data (abfd);
2528   if (pe == NULL)
2529     return TRUE;
2530
2531   section = bfd_get_section_by_name (abfd, ".rsrc");
2532   if (section == NULL)
2533     return TRUE;
2534   if (!(section->flags & SEC_HAS_CONTENTS))
2535     return TRUE;
2536
2537   datasize = section->size;
2538   if (datasize == 0)
2539     return TRUE;
2540
2541   rva_bias = section->vma - pe->pe_opthdr.ImageBase;
2542
2543   if (! bfd_malloc_and_get_section (abfd, section, & data))
2544     {
2545       if (data != NULL)
2546         free (data);
2547       return FALSE;
2548     }
2549
2550   regions.section_start = data;
2551   regions.section_end = data + datasize;
2552   regions.strings_start = NULL;
2553   regions.resource_start = NULL;
2554
2555   fflush (file);
2556   fprintf (file, "\nThe .rsrc Resource Directory section:\n");
2557
2558   while (data < regions.section_end)
2559     {
2560       bfd_byte * p = data;
2561
2562       data = rsrc_print_resource_directory (file, abfd, 0, data, & regions, rva_bias);
2563
2564       if (data == regions.section_end + 1)
2565         fprintf (file, _("Corrupt .rsrc section detected!\n"));
2566       else
2567         {
2568           /* Align data before continuing.  */
2569           int align = (1 << section->alignment_power) - 1;
2570
2571           data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align);
2572           rva_bias += data - p;
2573
2574           /* For reasons that are unclear .rsrc sections are sometimes created
2575              aligned to a 1^3 boundary even when their alignment is set at
2576              1^2.  Catch that case here before we issue a spurious warning
2577              message.  */
2578           if (data == (regions.section_end - 4))
2579             data = regions.section_end;
2580           else if (data < regions.section_end)
2581             {
2582               /* If the extra data is all zeros then do not complain.
2583                  This is just padding so that the section meets the
2584                  page size requirements.  */
2585               while (++ data < regions.section_end)
2586                 if (*data != 0)
2587                   break;
2588               if (data < regions.section_end)
2589                 fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2590             }
2591         }
2592     }
2593
2594   if (regions.strings_start != NULL)
2595     fprintf (file, _(" String table starts at offset: %#03x\n"),
2596              (int) (regions.strings_start - regions.section_start));
2597   if (regions.resource_start != NULL)
2598     fprintf (file, _(" Resources start at offset: %#03x\n"),
2599              (int) (regions.resource_start - regions.section_start));
2600
2601   free (regions.section_start);
2602   return TRUE;
2603 }
2604
2605 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2606
2607 static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] =
2608 {
2609   "Unknown",
2610   "COFF",
2611   "CodeView",
2612   "FPO",
2613   "Misc",
2614   "Exception",
2615   "Fixup",
2616   "OMAP-to-SRC",
2617   "OMAP-from-SRC",
2618   "Borland",
2619   "Reserved",
2620   "CLSID",
2621 };
2622
2623 static bfd_boolean
2624 pe_print_debugdata (bfd * abfd, void * vfile)
2625 {
2626   FILE *file = (FILE *) vfile;
2627   pe_data_type *pe = pe_data (abfd);
2628   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
2629   asection *section;
2630   bfd_byte *data = 0;
2631   bfd_size_type dataoff;
2632   unsigned int i;
2633
2634   bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
2635   bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
2636
2637   if (size == 0)
2638     return TRUE;
2639
2640   addr += extra->ImageBase;
2641   for (section = abfd->sections; section != NULL; section = section->next)
2642     {
2643       if ((addr >= section->vma) && (addr < (section->vma + section->size)))
2644         break;
2645     }
2646
2647   if (section == NULL)
2648     {
2649       fprintf (file,
2650                _("\nThere is a debug directory, but the section containing it could not be found\n"));
2651       return TRUE;
2652     }
2653   else if (!(section->flags & SEC_HAS_CONTENTS))
2654     {
2655       fprintf (file,
2656                _("\nThere is a debug directory in %s, but that section has no contents\n"),
2657                section->name);
2658       return TRUE;
2659     }
2660   else if (section->size < size)
2661     {
2662       fprintf (file,
2663                _("\nError: section %s contains the debug data starting address but it is too small\n"),
2664                section->name);
2665       return FALSE;
2666     }
2667
2668   fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2669            section->name, (unsigned long) addr);
2670
2671   dataoff = addr - section->vma;
2672
2673   if (size > (section->size - dataoff))
2674     {
2675       fprintf (file, _("The debug data size field in the data directory is too big for the section"));
2676       return FALSE;
2677     }
2678
2679   fprintf (file,
2680            _("Type                Size     Rva      Offset\n"));
2681
2682   /* Read the whole section.  */
2683   if (!bfd_malloc_and_get_section (abfd, section, &data))
2684     {
2685       if (data != NULL)
2686         free (data);
2687       return FALSE;
2688     }
2689
2690   for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2691     {
2692       const char *type_name;
2693       struct external_IMAGE_DEBUG_DIRECTORY *ext
2694         = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
2695       struct internal_IMAGE_DEBUG_DIRECTORY idd;
2696
2697       _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
2698
2699       if ((idd.Type) >= IMAGE_NUMBEROF_DEBUG_TYPES)
2700         type_name = debug_type_names[0];
2701       else
2702         type_name = debug_type_names[idd.Type];
2703
2704       fprintf (file, " %2ld  %14s %08lx %08lx %08lx\n",
2705                idd.Type, type_name, idd.SizeOfData,
2706                idd.AddressOfRawData, idd.PointerToRawData);
2707
2708       if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
2709         {
2710           char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1];
2711           /* PR 17512: file: 065-29434-0.001:0.1
2712              We need to use a 32-bit aligned buffer
2713              to safely read in a codeview record.  */
2714           char buffer[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO);
2715
2716           CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
2717
2718           /* The debug entry doesn't have to have to be in a section,
2719              in which case AddressOfRawData is 0, so always use PointerToRawData.  */
2720           if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData,
2721                                                idd.SizeOfData, cvinfo))
2722             continue;
2723
2724           for (i = 0; i < cvinfo->SignatureLength; i++)
2725             sprintf (&signature[i*2], "%02x", cvinfo->Signature[i] & 0xff);
2726
2727           /* xgettext:c-format */
2728           fprintf (file, _("(format %c%c%c%c signature %s age %ld)\n"),
2729                    buffer[0], buffer[1], buffer[2], buffer[3],
2730                    signature, cvinfo->Age);
2731         }
2732     }
2733
2734   if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0)
2735     fprintf (file,
2736             _("The debug directory size is not a multiple of the debug directory entry size\n"));
2737
2738   return TRUE;
2739 }
2740
2741 /* Print out the program headers.  */
2742
2743 bfd_boolean
2744 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2745 {
2746   FILE *file = (FILE *) vfile;
2747   int j;
2748   pe_data_type *pe = pe_data (abfd);
2749   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2750   const char *subsystem_name = NULL;
2751   const char *name;
2752
2753   /* The MS dumpbin program reportedly ands with 0xff0f before
2754      printing the characteristics field.  Not sure why.  No reason to
2755      emulate it here.  */
2756   fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2757 #undef PF
2758 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2759   PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2760   PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2761   PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2762   PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2763   PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2764   PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2765   PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2766   PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2767   PF (IMAGE_FILE_SYSTEM, "system file");
2768   PF (IMAGE_FILE_DLL, "DLL");
2769   PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2770 #undef PF
2771
2772   /* ctime implies '\n'.  */
2773   {
2774     time_t t = pe->coff.timestamp;
2775     fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2776   }
2777
2778 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2779 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2780 #endif
2781 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2782 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2783 #endif
2784 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2785 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2786 #endif
2787
2788   switch (i->Magic)
2789     {
2790     case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2791       name = "PE32";
2792       break;
2793     case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2794       name = "PE32+";
2795       break;
2796     case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2797       name = "ROM";
2798       break;
2799     default:
2800       name = NULL;
2801       break;
2802     }
2803   fprintf (file, "Magic\t\t\t%04x", i->Magic);
2804   if (name)
2805     fprintf (file, "\t(%s)",name);
2806   fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2807   fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2808   fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2809   fprintf (file, "SizeOfInitializedData\t%08lx\n",
2810            (unsigned long) i->SizeOfInitializedData);
2811   fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2812            (unsigned long) i->SizeOfUninitializedData);
2813   fprintf (file, "AddressOfEntryPoint\t");
2814   bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2815   fprintf (file, "\nBaseOfCode\t\t");
2816   bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2817 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2818   /* PE32+ does not have BaseOfData member!  */
2819   fprintf (file, "\nBaseOfData\t\t");
2820   bfd_fprintf_vma (abfd, file, i->BaseOfData);
2821 #endif
2822
2823   fprintf (file, "\nImageBase\t\t");
2824   bfd_fprintf_vma (abfd, file, i->ImageBase);
2825   fprintf (file, "\nSectionAlignment\t");
2826   bfd_fprintf_vma (abfd, file, i->SectionAlignment);
2827   fprintf (file, "\nFileAlignment\t\t");
2828   bfd_fprintf_vma (abfd, file, i->FileAlignment);
2829   fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2830   fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2831   fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2832   fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2833   fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2834   fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2835   fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2836   fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2837   fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2838   fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2839
2840   switch (i->Subsystem)
2841     {
2842     case IMAGE_SUBSYSTEM_UNKNOWN:
2843       subsystem_name = "unspecified";
2844       break;
2845     case IMAGE_SUBSYSTEM_NATIVE:
2846       subsystem_name = "NT native";
2847       break;
2848     case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2849       subsystem_name = "Windows GUI";
2850       break;
2851     case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2852       subsystem_name = "Windows CUI";
2853       break;
2854     case IMAGE_SUBSYSTEM_POSIX_CUI:
2855       subsystem_name = "POSIX CUI";
2856       break;
2857     case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2858       subsystem_name = "Wince CUI";
2859       break;
2860     // These are from UEFI Platform Initialization Specification 1.1.
2861     case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2862       subsystem_name = "EFI application";
2863       break;
2864     case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2865       subsystem_name = "EFI boot service driver";
2866       break;
2867     case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2868       subsystem_name = "EFI runtime driver";
2869       break;
2870     case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2871       subsystem_name = "SAL runtime driver";
2872       break;
2873     // This is from revision 8.0 of the MS PE/COFF spec
2874     case IMAGE_SUBSYSTEM_XBOX:
2875       subsystem_name = "XBOX";
2876       break;
2877     // Added default case for clarity - subsystem_name is NULL anyway.
2878     default:
2879       subsystem_name = NULL;
2880     }
2881
2882   fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2883   if (subsystem_name)
2884     fprintf (file, "\t(%s)", subsystem_name);
2885   fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2886   fprintf (file, "SizeOfStackReserve\t");
2887   bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
2888   fprintf (file, "\nSizeOfStackCommit\t");
2889   bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
2890   fprintf (file, "\nSizeOfHeapReserve\t");
2891   bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
2892   fprintf (file, "\nSizeOfHeapCommit\t");
2893   bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
2894   fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2895   fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2896            (unsigned long) i->NumberOfRvaAndSizes);
2897
2898   fprintf (file, "\nThe Data Directory\n");
2899   for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2900     {
2901       fprintf (file, "Entry %1x ", j);
2902       bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
2903       fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2904       fprintf (file, "%s\n", dir_names[j]);
2905     }
2906
2907   pe_print_idata (abfd, vfile);
2908   pe_print_edata (abfd, vfile);
2909   if (bfd_coff_have_print_pdata (abfd))
2910     bfd_coff_print_pdata (abfd, vfile);
2911   else
2912     pe_print_pdata (abfd, vfile);
2913   pe_print_reloc (abfd, vfile);
2914   pe_print_debugdata (abfd, file);
2915
2916   rsrc_print_section (abfd, vfile);
2917
2918   return TRUE;
2919 }
2920
2921 static bfd_boolean
2922 is_vma_in_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
2923 {
2924   bfd_vma addr = * (bfd_vma *) obj;
2925   return (addr >= sect->vma) && (addr < (sect->vma + sect->size));
2926 }
2927
2928 static asection *
2929 find_section_by_vma (bfd *abfd, bfd_vma addr)
2930 {
2931   return bfd_sections_find_if (abfd, is_vma_in_section, (void *) & addr);
2932 }
2933
2934 /* Copy any private info we understand from the input bfd
2935    to the output bfd.  */
2936
2937 bfd_boolean
2938 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2939 {
2940   pe_data_type *ipe, *ope;
2941
2942   /* One day we may try to grok other private data.  */
2943   if (ibfd->xvec->flavour != bfd_target_coff_flavour
2944       || obfd->xvec->flavour != bfd_target_coff_flavour)
2945     return TRUE;
2946
2947   ipe = pe_data (ibfd);
2948   ope = pe_data (obfd);
2949
2950   /* pe_opthdr is copied in copy_object.  */
2951   ope->dll = ipe->dll;
2952
2953   /* Don't copy input subsystem if output is different from input.  */
2954   if (obfd->xvec != ibfd->xvec)
2955     ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2956
2957   /* For strip: if we removed .reloc, we'll make a real mess of things
2958      if we don't remove this entry as well.  */
2959   if (! pe_data (obfd)->has_reloc_section)
2960     {
2961       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2962       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2963     }
2964
2965   /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2966      But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2967      won't be added.  */
2968   if (! pe_data (ibfd)->has_reloc_section
2969       && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
2970     pe_data (obfd)->dont_strip_reloc = 1;
2971
2972   /* The file offsets contained in the debug directory need rewriting.  */
2973   if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size != 0)
2974     {
2975       bfd_vma addr = ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].VirtualAddress
2976         + ope->pe_opthdr.ImageBase;
2977       asection *section = find_section_by_vma (obfd, addr);
2978       bfd_byte *data;
2979
2980       if (section && bfd_malloc_and_get_section (obfd, section, &data))
2981         {
2982           unsigned int i;
2983           struct external_IMAGE_DEBUG_DIRECTORY *dd =
2984             (struct external_IMAGE_DEBUG_DIRECTORY *)(data + (addr - section->vma));
2985
2986           /* PR 17512: file: 0f15796a.  */
2987           if ((unsigned long) ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
2988               > section->size - (addr - section->vma))
2989             {
2990               /* xgettext:c-format */
2991               _bfd_error_handler
2992                 (_("%pB: Data Directory size (%lx) "
2993                    "exceeds space left in section (%" PRIx64 ")"),
2994                  obfd, ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size,
2995                  (uint64_t) (section->size - (addr - section->vma)));
2996               free (data);
2997               return FALSE;
2998             }
2999
3000           for (i = 0; i < ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
3001                  / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
3002             {
3003               asection *ddsection;
3004               struct external_IMAGE_DEBUG_DIRECTORY *edd = &(dd[i]);
3005               struct internal_IMAGE_DEBUG_DIRECTORY idd;
3006
3007               _bfd_XXi_swap_debugdir_in (obfd, edd, &idd);
3008
3009               if (idd.AddressOfRawData == 0)
3010                 continue; /* RVA 0 means only offset is valid, not handled yet.  */
3011
3012               ddsection = find_section_by_vma (obfd, idd.AddressOfRawData + ope->pe_opthdr.ImageBase);
3013               if (!ddsection)
3014                 continue; /* Not in a section! */
3015
3016               idd.PointerToRawData = ddsection->filepos + (idd.AddressOfRawData
3017                                                            + ope->pe_opthdr.ImageBase) - ddsection->vma;
3018
3019               _bfd_XXi_swap_debugdir_out (obfd, &idd, edd);
3020             }
3021
3022           if (!bfd_set_section_contents (obfd, section, data, 0, section->size))
3023             {
3024               _bfd_error_handler (_("failed to update file offsets in debug directory"));
3025               free (data);
3026               return FALSE;
3027             }
3028           free (data);
3029         }
3030       else if (section)
3031         {
3032           _bfd_error_handler (_("%pB: failed to read debug data section"), obfd);
3033           return FALSE;
3034         }
3035     }
3036
3037   return TRUE;
3038 }
3039
3040 /* Copy private section data.  */
3041
3042 bfd_boolean
3043 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
3044                                        asection *isec,
3045                                        bfd *obfd,
3046                                        asection *osec)
3047 {
3048   if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
3049       || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
3050     return TRUE;
3051
3052   if (coff_section_data (ibfd, isec) != NULL
3053       && pei_section_data (ibfd, isec) != NULL)
3054     {
3055       if (coff_section_data (obfd, osec) == NULL)
3056         {
3057           bfd_size_type amt = sizeof (struct coff_section_tdata);
3058           osec->used_by_bfd = bfd_zalloc (obfd, amt);
3059           if (osec->used_by_bfd == NULL)
3060             return FALSE;
3061         }
3062
3063       if (pei_section_data (obfd, osec) == NULL)
3064         {
3065           bfd_size_type amt = sizeof (struct pei_section_tdata);
3066           coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
3067           if (coff_section_data (obfd, osec)->tdata == NULL)
3068             return FALSE;
3069         }
3070
3071       pei_section_data (obfd, osec)->virt_size =
3072         pei_section_data (ibfd, isec)->virt_size;
3073       pei_section_data (obfd, osec)->pe_flags =
3074         pei_section_data (ibfd, isec)->pe_flags;
3075     }
3076
3077   return TRUE;
3078 }
3079
3080 void
3081 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
3082 {
3083   coff_get_symbol_info (abfd, symbol, ret);
3084 }
3085
3086 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3087 static int
3088 sort_x64_pdata (const void *l, const void *r)
3089 {
3090   const char *lp = (const char *) l;
3091   const char *rp = (const char *) r;
3092   bfd_vma vl, vr;
3093   vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
3094   if (vl != vr)
3095     return (vl < vr ? -1 : 1);
3096   /* We compare just begin address.  */
3097   return 0;
3098 }
3099 #endif
3100 \f
3101 /* Functions to process a .rsrc section.  */
3102
3103 static unsigned int sizeof_leaves;
3104 static unsigned int sizeof_strings;
3105 static unsigned int sizeof_tables_and_entries;
3106
3107 static bfd_byte *
3108 rsrc_count_directory (bfd *, bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma);
3109
3110 static bfd_byte *
3111 rsrc_count_entries (bfd *          abfd,
3112                     bfd_boolean    is_name,
3113                     bfd_byte *     datastart,
3114                     bfd_byte *     data,
3115                     bfd_byte *     dataend,
3116                     bfd_vma        rva_bias)
3117 {
3118   unsigned long entry, addr, size;
3119
3120   if (data + 8 >= dataend)
3121     return dataend + 1;
3122
3123   if (is_name)
3124     {
3125       bfd_byte * name;
3126
3127       entry = (long) bfd_get_32 (abfd, data);
3128
3129       if (HighBitSet (entry))
3130         name = datastart + WithoutHighBit (entry);
3131       else
3132         name = datastart + entry - rva_bias;
3133
3134       if (name + 2 >= dataend || name < datastart)
3135         return dataend + 1;
3136
3137       unsigned int len = bfd_get_16 (abfd, name);
3138       if (len == 0 || len > 256)
3139         return dataend + 1;
3140     }
3141
3142   entry = (long) bfd_get_32 (abfd, data + 4);
3143
3144   if (HighBitSet (entry))
3145     {
3146       data = datastart + WithoutHighBit (entry);
3147
3148       if (data <= datastart || data >= dataend)
3149         return dataend + 1;
3150
3151       return rsrc_count_directory (abfd, datastart, data, dataend, rva_bias);
3152     }
3153
3154   if (datastart + entry + 16 >= dataend)
3155     return dataend + 1;
3156
3157   addr = (long) bfd_get_32 (abfd, datastart + entry);
3158   size = (long) bfd_get_32 (abfd, datastart + entry + 4);
3159
3160   return datastart + addr - rva_bias + size;
3161 }
3162
3163 static bfd_byte *
3164 rsrc_count_directory (bfd *          abfd,
3165                       bfd_byte *     datastart,
3166                       bfd_byte *     data,
3167                       bfd_byte *     dataend,
3168                       bfd_vma        rva_bias)
3169 {
3170   unsigned int  num_entries, num_ids;
3171   bfd_byte *    highest_data = data;
3172
3173   if (data + 16 >= dataend)
3174     return dataend + 1;
3175
3176   num_entries  = (int) bfd_get_16 (abfd, data + 12);
3177   num_ids      = (int) bfd_get_16 (abfd, data + 14);
3178
3179   num_entries += num_ids;
3180
3181   data += 16;
3182
3183   while (num_entries --)
3184     {
3185       bfd_byte * entry_end;
3186
3187       entry_end = rsrc_count_entries (abfd, num_entries >= num_ids,
3188                                       datastart, data, dataend, rva_bias);
3189       data += 8;
3190       highest_data = max (highest_data, entry_end);
3191       if (entry_end >= dataend)
3192         break;
3193     }
3194
3195   return max (highest_data, data);
3196 }
3197
3198 typedef struct rsrc_dir_chain
3199 {
3200   unsigned int         num_entries;
3201   struct rsrc_entry *  first_entry;
3202   struct rsrc_entry *  last_entry;
3203 } rsrc_dir_chain;
3204
3205 typedef struct rsrc_directory
3206 {
3207   unsigned int characteristics;
3208   unsigned int time;
3209   unsigned int major;
3210   unsigned int minor;
3211
3212   rsrc_dir_chain names;
3213   rsrc_dir_chain ids;
3214
3215   struct rsrc_entry * entry;
3216 } rsrc_directory;
3217
3218 typedef struct rsrc_string
3219 {
3220   unsigned int  len;
3221   bfd_byte *    string;
3222 } rsrc_string;
3223
3224 typedef struct rsrc_leaf
3225 {
3226   unsigned int  size;
3227   unsigned int  codepage;
3228   bfd_byte *    data;
3229 } rsrc_leaf;
3230
3231 typedef struct rsrc_entry
3232 {
3233   bfd_boolean is_name;
3234   union
3235   {
3236     unsigned int          id;
3237     struct rsrc_string    name;
3238   } name_id;
3239
3240   bfd_boolean is_dir;
3241   union
3242   {
3243     struct rsrc_directory * directory;
3244     struct rsrc_leaf *      leaf;
3245   } value;
3246
3247   struct rsrc_entry *     next_entry;
3248   struct rsrc_directory * parent;
3249 } rsrc_entry;
3250
3251 static bfd_byte *
3252 rsrc_parse_directory (bfd *, rsrc_directory *, bfd_byte *,
3253                       bfd_byte *, bfd_byte *, bfd_vma, rsrc_entry *);
3254
3255 static bfd_byte *
3256 rsrc_parse_entry (bfd *            abfd,
3257                   bfd_boolean      is_name,
3258                   rsrc_entry *     entry,
3259                   bfd_byte *       datastart,
3260                   bfd_byte *       data,
3261                   bfd_byte *       dataend,
3262                   bfd_vma          rva_bias,
3263                   rsrc_directory * parent)
3264 {
3265   unsigned long val, addr, size;
3266
3267   val = bfd_get_32 (abfd, data);
3268
3269   entry->parent = parent;
3270   entry->is_name = is_name;
3271
3272   if (is_name)
3273     {
3274       bfd_byte * address;
3275
3276       if (HighBitSet (val))
3277         {
3278           val = WithoutHighBit (val);
3279
3280           address = datastart + val;
3281         }
3282       else
3283         {
3284           address = datastart + val - rva_bias;
3285         }
3286
3287       if (address + 3 > dataend)
3288         return dataend;
3289
3290       entry->name_id.name.len    = bfd_get_16 (abfd, address);
3291       entry->name_id.name.string = address + 2;
3292     }
3293   else
3294     entry->name_id.id = val;
3295
3296   val = bfd_get_32 (abfd, data + 4);
3297
3298   if (HighBitSet (val))
3299     {
3300       entry->is_dir = TRUE;
3301       entry->value.directory = bfd_malloc (sizeof * entry->value.directory);
3302       if (entry->value.directory == NULL)
3303         return dataend;
3304
3305       return rsrc_parse_directory (abfd, entry->value.directory,
3306                                    datastart,
3307                                    datastart + WithoutHighBit (val),
3308                                    dataend, rva_bias, entry);
3309     }
3310
3311   entry->is_dir = FALSE;
3312   entry->value.leaf = bfd_malloc (sizeof * entry->value.leaf);
3313   if (entry->value.leaf == NULL)
3314     return dataend;
3315
3316   data = datastart + val;
3317   if (data < datastart || data >= dataend)
3318     return dataend;
3319
3320   addr = bfd_get_32 (abfd, data);
3321   size = entry->value.leaf->size = bfd_get_32 (abfd, data + 4);
3322   entry->value.leaf->codepage = bfd_get_32 (abfd, data + 8);
3323   /* FIXME: We assume that the reserved field (data + 12) is OK.  */
3324
3325   entry->value.leaf->data = bfd_malloc (size);
3326   if (entry->value.leaf->data == NULL)
3327     return dataend;
3328
3329   memcpy (entry->value.leaf->data, datastart + addr - rva_bias, size);
3330   return datastart + (addr - rva_bias) + size;
3331 }
3332
3333 static bfd_byte *
3334 rsrc_parse_entries (bfd *            abfd,
3335                     rsrc_dir_chain * chain,
3336                     bfd_boolean      is_name,
3337                     bfd_byte *       highest_data,
3338                     bfd_byte *       datastart,
3339                     bfd_byte *       data,
3340                     bfd_byte *       dataend,
3341                     bfd_vma          rva_bias,
3342                     rsrc_directory * parent)
3343 {
3344   unsigned int i;
3345   rsrc_entry * entry;
3346
3347   if (chain->num_entries == 0)
3348     {
3349       chain->first_entry = chain->last_entry = NULL;
3350       return highest_data;
3351     }
3352
3353   entry = bfd_malloc (sizeof * entry);
3354   if (entry == NULL)
3355     return dataend;
3356
3357   chain->first_entry = entry;
3358
3359   for (i = chain->num_entries; i--;)
3360     {
3361       bfd_byte * entry_end;
3362
3363       entry_end = rsrc_parse_entry (abfd, is_name, entry, datastart,
3364                                     data, dataend, rva_bias, parent);
3365       data += 8;
3366       highest_data = max (entry_end, highest_data);
3367       if (entry_end > dataend)
3368         return dataend;
3369
3370       if (i)
3371         {
3372           entry->next_entry = bfd_malloc (sizeof * entry);
3373           entry = entry->next_entry;
3374           if (entry == NULL)
3375             return dataend;
3376         }
3377       else
3378         entry->next_entry = NULL;
3379     }
3380
3381   chain->last_entry = entry;
3382
3383   return highest_data;
3384 }
3385
3386 static bfd_byte *
3387 rsrc_parse_directory (bfd *            abfd,
3388                       rsrc_directory * table,
3389                       bfd_byte *       datastart,
3390                       bfd_byte *       data,
3391                       bfd_byte *       dataend,
3392                       bfd_vma          rva_bias,
3393                       rsrc_entry *     entry)
3394 {
3395   bfd_byte * highest_data = data;
3396
3397   if (table == NULL)
3398     return dataend;
3399
3400   table->characteristics = bfd_get_32 (abfd, data);
3401   table->time = bfd_get_32 (abfd, data + 4);
3402   table->major = bfd_get_16 (abfd, data + 8);
3403   table->minor = bfd_get_16 (abfd, data + 10);
3404   table->names.num_entries = bfd_get_16 (abfd, data + 12);
3405   table->ids.num_entries = bfd_get_16 (abfd, data + 14);
3406   table->entry = entry;
3407
3408   data += 16;
3409
3410   highest_data = rsrc_parse_entries (abfd, & table->names, TRUE, data,
3411                                      datastart, data, dataend, rva_bias, table);
3412   data += table->names.num_entries * 8;
3413
3414   highest_data = rsrc_parse_entries (abfd, & table->ids, FALSE, highest_data,
3415                                      datastart, data, dataend, rva_bias, table);
3416   data += table->ids.num_entries * 8;
3417
3418   return max (highest_data, data);
3419 }
3420
3421 typedef struct rsrc_write_data
3422 {
3423   bfd *      abfd;
3424   bfd_byte * datastart;
3425   bfd_byte * next_table;
3426   bfd_byte * next_leaf;
3427   bfd_byte * next_string;
3428   bfd_byte * next_data;
3429   bfd_vma    rva_bias;
3430 } rsrc_write_data;
3431
3432 static void
3433 rsrc_write_string (rsrc_write_data * data,
3434                    rsrc_string *     string)
3435 {
3436   bfd_put_16 (data->abfd, string->len, data->next_string);
3437   memcpy (data->next_string + 2, string->string, string->len * 2);
3438   data->next_string += (string->len + 1) * 2;
3439 }
3440
3441 static inline unsigned int
3442 rsrc_compute_rva (rsrc_write_data * data,
3443                   bfd_byte *        addr)
3444 {
3445   return (addr - data->datastart) + data->rva_bias;
3446 }
3447
3448 static void
3449 rsrc_write_leaf (rsrc_write_data * data,
3450                  rsrc_leaf *       leaf)
3451 {
3452   bfd_put_32 (data->abfd, rsrc_compute_rva (data, data->next_data),
3453               data->next_leaf);
3454   bfd_put_32 (data->abfd, leaf->size,     data->next_leaf + 4);
3455   bfd_put_32 (data->abfd, leaf->codepage, data->next_leaf + 8);
3456   bfd_put_32 (data->abfd, 0 /*reserved*/, data->next_leaf + 12);
3457   data->next_leaf += 16;
3458
3459   memcpy (data->next_data, leaf->data, leaf->size);
3460   /* An undocumented feature of Windows resources is that each unit
3461      of raw data is 8-byte aligned...  */
3462   data->next_data += ((leaf->size + 7) & ~7);
3463 }
3464
3465 static void rsrc_write_directory (rsrc_write_data *, rsrc_directory *);
3466
3467 static void
3468 rsrc_write_entry (rsrc_write_data *  data,
3469                   bfd_byte *         where,
3470                   rsrc_entry *       entry)
3471 {
3472   if (entry->is_name)
3473     {
3474       bfd_put_32 (data->abfd,
3475                   SetHighBit (data->next_string - data->datastart),
3476                   where);
3477       rsrc_write_string (data, & entry->name_id.name);
3478     }
3479   else
3480     bfd_put_32 (data->abfd, entry->name_id.id, where);
3481
3482   if (entry->is_dir)
3483     {
3484       bfd_put_32 (data->abfd,
3485                   SetHighBit (data->next_table - data->datastart),
3486                   where + 4);
3487       rsrc_write_directory (data, entry->value.directory);
3488     }
3489   else
3490     {
3491       bfd_put_32 (data->abfd, data->next_leaf - data->datastart, where + 4);
3492       rsrc_write_leaf (data, entry->value.leaf);
3493     }
3494 }
3495
3496 static void
3497 rsrc_compute_region_sizes (rsrc_directory * dir)
3498 {
3499   struct rsrc_entry * entry;
3500
3501   if (dir == NULL)
3502     return;
3503
3504   sizeof_tables_and_entries += 16;
3505
3506   for (entry = dir->names.first_entry; entry != NULL; entry = entry->next_entry)
3507     {
3508       sizeof_tables_and_entries += 8;
3509
3510       sizeof_strings += (entry->name_id.name.len + 1) * 2;
3511
3512       if (entry->is_dir)
3513         rsrc_compute_region_sizes (entry->value.directory);
3514       else
3515         sizeof_leaves += 16;
3516     }
3517
3518   for (entry = dir->ids.first_entry; entry != NULL; entry = entry->next_entry)
3519     {
3520       sizeof_tables_and_entries += 8;
3521
3522       if (entry->is_dir)
3523         rsrc_compute_region_sizes (entry->value.directory);
3524       else
3525         sizeof_leaves += 16;
3526     }
3527 }
3528
3529 static void
3530 rsrc_write_directory (rsrc_write_data * data,
3531                       rsrc_directory *  dir)
3532 {
3533   rsrc_entry * entry;
3534   unsigned int i;
3535   bfd_byte * next_entry;
3536   bfd_byte * nt;
3537
3538   bfd_put_32 (data->abfd, dir->characteristics, data->next_table);
3539   bfd_put_32 (data->abfd, 0 /*dir->time*/, data->next_table + 4);
3540   bfd_put_16 (data->abfd, dir->major, data->next_table + 8);
3541   bfd_put_16 (data->abfd, dir->minor, data->next_table + 10);
3542   bfd_put_16 (data->abfd, dir->names.num_entries, data->next_table + 12);
3543   bfd_put_16 (data->abfd, dir->ids.num_entries, data->next_table + 14);
3544
3545   /* Compute where the entries and the next table will be placed.  */
3546   next_entry = data->next_table + 16;
3547   data->next_table = next_entry + (dir->names.num_entries * 8)
3548     + (dir->ids.num_entries * 8);
3549   nt = data->next_table;
3550
3551   /* Write the entries.  */
3552   for (i = dir->names.num_entries, entry = dir->names.first_entry;
3553        i > 0 && entry != NULL;
3554        i--, entry = entry->next_entry)
3555     {
3556       BFD_ASSERT (entry->is_name);
3557       rsrc_write_entry (data, next_entry, entry);
3558       next_entry += 8;
3559     }
3560   BFD_ASSERT (i == 0);
3561   BFD_ASSERT (entry == NULL);
3562
3563   for (i = dir->ids.num_entries, entry = dir->ids.first_entry;
3564        i > 0 && entry != NULL;
3565        i--, entry = entry->next_entry)
3566     {
3567       BFD_ASSERT (! entry->is_name);
3568       rsrc_write_entry (data, next_entry, entry);
3569       next_entry += 8;
3570     }
3571   BFD_ASSERT (i == 0);
3572   BFD_ASSERT (entry == NULL);
3573   BFD_ASSERT (nt == next_entry);
3574 }
3575
3576 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3577 /* Return the length (number of units) of the first character in S,
3578    putting its 'ucs4_t' representation in *PUC.  */
3579
3580 static unsigned int
3581 #if defined HAVE_WCTYPE_H
3582 u16_mbtouc (wint_t * puc, const unsigned short * s, unsigned int n)
3583 #else
3584 u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n)
3585 #endif
3586 {
3587   unsigned short c = * s;
3588
3589   if (c < 0xd800 || c >= 0xe000)
3590     {
3591       *puc = c;
3592       return 1;
3593     }
3594
3595   if (c < 0xdc00)
3596     {
3597       if (n >= 2)
3598         {
3599           if (s[1] >= 0xdc00 && s[1] < 0xe000)
3600             {
3601               *puc = 0x10000 + ((c - 0xd800) << 10) + (s[1] - 0xdc00);
3602               return 2;
3603             }
3604         }
3605       else
3606         {
3607           /* Incomplete multibyte character.  */
3608           *puc = 0xfffd;
3609           return n;
3610         }
3611     }
3612
3613   /* Invalid multibyte character.  */
3614   *puc = 0xfffd;
3615   return 1;
3616 }
3617 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3618
3619 /* Perform a comparison of two entries.  */
3620 static signed int
3621 rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b)
3622 {
3623   signed int    res;
3624   bfd_byte *    astring;
3625   unsigned int  alen;
3626   bfd_byte *    bstring;
3627   unsigned int  blen;
3628
3629   if (! is_name)
3630     return a->name_id.id - b->name_id.id;
3631
3632   /* We have to perform a case insenstive, unicode string comparison...  */
3633   astring = a->name_id.name.string;
3634   alen    = a->name_id.name.len;
3635   bstring = b->name_id.name.string;
3636   blen    = b->name_id.name.len;
3637
3638 #if defined  __CYGWIN__ || defined __MINGW32__
3639   /* Under Windows hosts (both Cygwin and Mingw types),
3640      unicode == UTF-16 == wchar_t.  The case insensitive string comparison
3641      function however goes by different names in the two environments...  */
3642
3643 #undef rscpcmp
3644 #ifdef __CYGWIN__
3645 #define rscpcmp wcsncasecmp
3646 #endif
3647 #ifdef __MINGW32__
3648 #define rscpcmp wcsnicmp
3649 #endif
3650
3651   res = rscpcmp ((const wchar_t *) astring, (const wchar_t *) bstring,
3652                  min (alen, blen));
3653
3654 #elif defined HAVE_WCHAR_H
3655   {
3656     unsigned int  i;
3657
3658     res = 0;
3659     for (i = min (alen, blen); i--; astring += 2, bstring += 2)
3660       {
3661 #if defined HAVE_WCTYPE_H
3662         wint_t awc;
3663         wint_t bwc;
3664 #else
3665         wchar_t awc;
3666         wchar_t bwc;
3667 #endif
3668
3669         /* Convert UTF-16 unicode characters into wchar_t characters
3670            so that we can then perform a case insensitive comparison.  */
3671         unsigned int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2);
3672         unsigned int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2);
3673
3674         if (Alen != Blen)
3675           return Alen - Blen;
3676
3677 #ifdef HAVE_WCTYPE_H
3678         awc = towlower (awc);
3679         bwc = towlower (bwc);
3680
3681         res = awc - bwc;
3682 #else
3683         res = wcsncasecmp (& awc, & bwc, 1);
3684 #endif
3685         if (res)
3686           break;
3687       }
3688   }
3689 #else
3690   /* Do the best we can - a case sensitive, untranslated comparison.  */
3691   res = memcmp (astring, bstring, min (alen, blen) * 2);
3692 #endif
3693
3694   if (res == 0)
3695     res = alen - blen;
3696
3697   return res;
3698 }
3699
3700 static void
3701 rsrc_print_name (char * buffer, rsrc_string string)
3702 {
3703   unsigned int  i;
3704   bfd_byte *    name = string.string;
3705
3706   for (i = string.len; i--; name += 2)
3707     sprintf (buffer + strlen (buffer), "%.1s", name);
3708 }
3709
3710 static const char *
3711 rsrc_resource_name (rsrc_entry * entry, rsrc_directory * dir)
3712 {
3713   static char buffer [256];
3714   bfd_boolean is_string = FALSE;
3715
3716   buffer[0] = 0;
3717
3718   if (dir != NULL && dir->entry != NULL && dir->entry->parent != NULL
3719       && dir->entry->parent->entry != NULL)
3720     {
3721       strcpy (buffer, "type: ");
3722       if (dir->entry->parent->entry->is_name)
3723         rsrc_print_name (buffer + strlen (buffer),
3724                          dir->entry->parent->entry->name_id.name);
3725       else
3726         {
3727           unsigned int id = dir->entry->parent->entry->name_id.id;
3728
3729           sprintf (buffer + strlen (buffer), "%x", id);
3730           switch (id)
3731             {
3732             case 1: strcat (buffer, " (CURSOR)"); break;
3733             case 2: strcat (buffer, " (BITMAP)"); break;
3734             case 3: strcat (buffer, " (ICON)"); break;
3735             case 4: strcat (buffer, " (MENU)"); break;
3736             case 5: strcat (buffer, " (DIALOG)"); break;
3737             case 6: strcat (buffer, " (STRING)"); is_string = TRUE; break;
3738             case 7: strcat (buffer, " (FONTDIR)"); break;
3739             case 8: strcat (buffer, " (FONT)"); break;
3740             case 9: strcat (buffer, " (ACCELERATOR)"); break;
3741             case 10: strcat (buffer, " (RCDATA)"); break;
3742             case 11: strcat (buffer, " (MESSAGETABLE)"); break;
3743             case 12: strcat (buffer, " (GROUP_CURSOR)"); break;
3744             case 14: strcat (buffer, " (GROUP_ICON)"); break;
3745             case 16: strcat (buffer, " (VERSION)"); break;
3746             case 17: strcat (buffer, " (DLGINCLUDE)"); break;
3747             case 19: strcat (buffer, " (PLUGPLAY)"); break;
3748             case 20: strcat (buffer, " (VXD)"); break;
3749             case 21: strcat (buffer, " (ANICURSOR)"); break;
3750             case 22: strcat (buffer, " (ANIICON)"); break;
3751             case 23: strcat (buffer, " (HTML)"); break;
3752             case 24: strcat (buffer, " (MANIFEST)"); break;
3753             case 240: strcat (buffer, " (DLGINIT)"); break;
3754             case 241: strcat (buffer, " (TOOLBAR)"); break;
3755             }
3756         }
3757     }
3758
3759   if (dir != NULL && dir->entry != NULL)
3760     {
3761       strcat (buffer, " name: ");
3762       if (dir->entry->is_name)
3763         rsrc_print_name (buffer + strlen (buffer), dir->entry->name_id.name);
3764       else
3765         {
3766           unsigned int id = dir->entry->name_id.id;
3767
3768           sprintf (buffer + strlen (buffer), "%x", id);
3769
3770           if (is_string)
3771             sprintf (buffer + strlen (buffer), " (resource id range: %d - %d)",
3772                      (id - 1) << 4, (id << 4) - 1);
3773         }
3774     }
3775
3776   if (entry != NULL)
3777     {
3778       strcat (buffer, " lang: ");
3779
3780       if (entry->is_name)
3781         rsrc_print_name (buffer + strlen (buffer), entry->name_id.name);
3782       else
3783         sprintf (buffer + strlen (buffer), "%x", entry->name_id.id);
3784     }
3785
3786   return buffer;
3787 }
3788
3789 /* *sigh* Windows resource strings are special.  Only the top 28-bits of
3790    their ID is stored in the NAME entry.  The bottom four bits are used as
3791    an index into unicode string table that makes up the data of the leaf.
3792    So identical type-name-lang string resources may not actually be
3793    identical at all.
3794
3795    This function is called when we have detected two string resources with
3796    match top-28-bit IDs.  We have to scan the string tables inside the leaves
3797    and discover if there are any real collisions.  If there are then we report
3798    them and return FALSE.  Otherwise we copy any strings from B into A and
3799    then return TRUE.  */
3800
3801 static bfd_boolean
3802 rsrc_merge_string_entries (rsrc_entry * a ATTRIBUTE_UNUSED,
3803                            rsrc_entry * b ATTRIBUTE_UNUSED)
3804 {
3805   unsigned int copy_needed = 0;
3806   unsigned int i;
3807   bfd_byte * astring;
3808   bfd_byte * bstring;
3809   bfd_byte * new_data;
3810   bfd_byte * nstring;
3811
3812   /* Step one: Find out what we have to do.  */
3813   BFD_ASSERT (! a->is_dir);
3814   astring = a->value.leaf->data;
3815
3816   BFD_ASSERT (! b->is_dir);
3817   bstring = b->value.leaf->data;
3818
3819   for (i = 0; i < 16; i++)
3820     {
3821       unsigned int alen = astring[0] + (astring[1] << 8);
3822       unsigned int blen = bstring[0] + (bstring[1] << 8);
3823
3824       if (alen == 0)
3825         {
3826           copy_needed += blen * 2;
3827         }
3828       else if (blen == 0)
3829         ;
3830       else if (alen != blen)
3831         /* FIXME: Should we continue the loop in order to report other duplicates ?  */
3832         break;
3833       /* alen == blen != 0.  We might have two identical strings.  If so we
3834          can ignore the second one.  There is no need for wchar_t vs UTF-16
3835          theatrics here - we are only interested in (case sensitive) equality.  */
3836       else if (memcmp (astring + 2, bstring + 2, alen * 2) != 0)
3837         break;
3838
3839       astring += (alen + 1) * 2;
3840       bstring += (blen + 1) * 2;
3841     }
3842
3843   if (i != 16)
3844     {
3845       if (a->parent != NULL
3846           && a->parent->entry != NULL
3847           && !a->parent->entry->is_name)
3848         _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3849                             ((a->parent->entry->name_id.id - 1) << 4) + i);
3850       return FALSE;
3851     }
3852
3853   if (copy_needed == 0)
3854     return TRUE;
3855
3856   /* If we reach here then A and B must both have non-colliding strings.
3857      (We never get string resources with fully empty string tables).
3858      We need to allocate an extra COPY_NEEDED bytes in A and then bring
3859      in B's strings.  */
3860   new_data = bfd_malloc (a->value.leaf->size + copy_needed);
3861   if (new_data == NULL)
3862     return FALSE;
3863
3864   nstring = new_data;
3865   astring = a->value.leaf->data;
3866   bstring = b->value.leaf->data;
3867
3868   for (i = 0; i < 16; i++)
3869     {
3870       unsigned int alen = astring[0] + (astring[1] << 8);
3871       unsigned int blen = bstring[0] + (bstring[1] << 8);
3872
3873       if (alen != 0)
3874         {
3875           memcpy (nstring, astring, (alen + 1) * 2);
3876           nstring += (alen + 1) * 2;
3877         }
3878       else if (blen != 0)
3879         {
3880           memcpy (nstring, bstring, (blen + 1) * 2);
3881           nstring += (blen + 1) * 2;
3882         }
3883       else
3884         {
3885           * nstring++ = 0;
3886           * nstring++ = 0;
3887         }
3888
3889       astring += (alen + 1) * 2;
3890       bstring += (blen + 1) * 2;
3891     }
3892
3893   BFD_ASSERT (nstring - new_data == (signed) (a->value.leaf->size + copy_needed));
3894
3895   free (a->value.leaf->data);
3896   a->value.leaf->data = new_data;
3897   a->value.leaf->size += copy_needed;
3898
3899   return TRUE;
3900 }
3901
3902 static void rsrc_merge (rsrc_entry *, rsrc_entry *);
3903
3904 /* Sort the entries in given part of the directory.
3905    We use an old fashioned bubble sort because we are dealing
3906    with lists and we want to handle matches specially.  */
3907
3908 static void
3909 rsrc_sort_entries (rsrc_dir_chain *  chain,
3910                    bfd_boolean       is_name,
3911                    rsrc_directory *  dir)
3912 {
3913   rsrc_entry * entry;
3914   rsrc_entry * next;
3915   rsrc_entry ** points_to_entry;
3916   bfd_boolean swapped;
3917
3918   if (chain->num_entries < 2)
3919     return;
3920
3921   do
3922     {
3923       swapped = FALSE;
3924       points_to_entry = & chain->first_entry;
3925       entry = * points_to_entry;
3926       next  = entry->next_entry;
3927
3928       do
3929         {
3930           signed int cmp = rsrc_cmp (is_name, entry, next);
3931
3932           if (cmp > 0)
3933             {
3934               entry->next_entry = next->next_entry;
3935               next->next_entry = entry;
3936               * points_to_entry = next;
3937               points_to_entry = & next->next_entry;
3938               next = entry->next_entry;
3939               swapped = TRUE;
3940             }
3941           else if (cmp == 0)
3942             {
3943               if (entry->is_dir && next->is_dir)
3944                 {
3945                   /* When we encounter identical directory entries we have to
3946                      merge them together.  The exception to this rule is for
3947                      resource manifests - there can only be one of these,
3948                      even if they differ in language.  Zero-language manifests
3949                      are assumed to be default manifests (provided by the
3950                      Cygwin/MinGW build system) and these can be silently dropped,
3951                      unless that would reduce the number of manifests to zero.
3952                      There should only ever be one non-zero lang manifest -
3953                      if there are more it is an error.  A non-zero lang
3954                      manifest takes precedence over a default manifest.  */
3955                   if (!entry->is_name
3956                       && entry->name_id.id == 1
3957                       && dir != NULL
3958                       && dir->entry != NULL
3959                       && !dir->entry->is_name
3960                       && dir->entry->name_id.id == 0x18)
3961                     {
3962                       if (next->value.directory->names.num_entries == 0
3963                           && next->value.directory->ids.num_entries == 1
3964                           && !next->value.directory->ids.first_entry->is_name
3965                           && next->value.directory->ids.first_entry->name_id.id == 0)
3966                         /* Fall through so that NEXT is dropped.  */
3967                         ;
3968                       else if (entry->value.directory->names.num_entries == 0
3969                                && entry->value.directory->ids.num_entries == 1
3970                                && !entry->value.directory->ids.first_entry->is_name
3971                                && entry->value.directory->ids.first_entry->name_id.id == 0)
3972                         {
3973                           /* Swap ENTRY and NEXT.  Then fall through so that the old ENTRY is dropped.  */
3974                           entry->next_entry = next->next_entry;
3975                           next->next_entry = entry;
3976                           * points_to_entry = next;
3977                           points_to_entry = & next->next_entry;
3978                           next = entry->next_entry;
3979                           swapped = TRUE;
3980                         }
3981                       else
3982                         {
3983                           _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3984                           bfd_set_error (bfd_error_file_truncated);
3985                           return;
3986                         }
3987
3988                       /* Unhook NEXT from the chain.  */
3989                       /* FIXME: memory loss here.  */
3990                       entry->next_entry = next->next_entry;
3991                       chain->num_entries --;
3992                       if (chain->num_entries < 2)
3993                         return;
3994                       next = next->next_entry;
3995                     }
3996                   else
3997                     rsrc_merge (entry, next);
3998                 }
3999               else if (entry->is_dir != next->is_dir)
4000                 {
4001                   _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4002                   bfd_set_error (bfd_error_file_truncated);
4003                   return;
4004                 }
4005               else
4006                 {
4007                   /* Otherwise with identical leaves we issue an error
4008                      message - because there should never be duplicates.
4009                      The exception is Type 18/Name 1/Lang 0 which is the
4010                      defaul manifest - this can just be dropped.  */
4011                   if (!entry->is_name
4012                       && entry->name_id.id == 0
4013                       && dir != NULL
4014                       && dir->entry != NULL
4015                       && !dir->entry->is_name
4016                       && dir->entry->name_id.id == 1
4017                       && dir->entry->parent != NULL
4018                       && dir->entry->parent->entry != NULL
4019                       && !dir->entry->parent->entry->is_name
4020                       && dir->entry->parent->entry->name_id.id == 0x18 /* RT_MANIFEST */)
4021                     ;
4022                   else if (dir != NULL
4023                            && dir->entry != NULL
4024                            && dir->entry->parent != NULL
4025                            && dir->entry->parent->entry != NULL
4026                            && !dir->entry->parent->entry->is_name
4027                            && dir->entry->parent->entry->name_id.id == 0x6 /* RT_STRING */)
4028                     {
4029                       /* Strings need special handling.  */
4030                       if (! rsrc_merge_string_entries (entry, next))
4031                         {
4032                           /* _bfd_error_handler should have been called inside merge_strings.  */
4033                           bfd_set_error (bfd_error_file_truncated);
4034                           return;
4035                         }
4036                     }
4037                   else
4038                     {
4039                       if (dir == NULL
4040                           || dir->entry == NULL
4041                           || dir->entry->parent == NULL
4042                           || dir->entry->parent->entry == NULL)
4043                         _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4044                       else
4045                         _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4046                                             rsrc_resource_name (entry, dir));
4047                       bfd_set_error (bfd_error_file_truncated);
4048                       return;
4049                     }
4050                 }
4051
4052               /* Unhook NEXT from the chain.  */
4053               entry->next_entry = next->next_entry;
4054               chain->num_entries --;
4055               if (chain->num_entries < 2)
4056                 return;
4057               next = next->next_entry;
4058             }
4059           else
4060             {
4061               points_to_entry = & entry->next_entry;
4062               entry = next;
4063               next = next->next_entry;
4064             }
4065         }
4066       while (next);
4067
4068       chain->last_entry = entry;
4069     }
4070   while (swapped);
4071 }
4072
4073 /* Attach B's chain onto A.  */
4074 static void
4075 rsrc_attach_chain (rsrc_dir_chain * achain, rsrc_dir_chain * bchain)
4076 {
4077   if (bchain->num_entries == 0)
4078     return;
4079
4080   achain->num_entries += bchain->num_entries;
4081
4082   if (achain->first_entry == NULL)
4083     {
4084       achain->first_entry = bchain->first_entry;
4085       achain->last_entry  = bchain->last_entry;
4086     }
4087   else
4088     {
4089       achain->last_entry->next_entry = bchain->first_entry;
4090       achain->last_entry = bchain->last_entry;
4091     }
4092
4093   bchain->num_entries = 0;
4094   bchain->first_entry = bchain->last_entry = NULL;
4095 }
4096
4097 static void
4098 rsrc_merge (struct rsrc_entry * a, struct rsrc_entry * b)
4099 {
4100   rsrc_directory * adir;
4101   rsrc_directory * bdir;
4102
4103   BFD_ASSERT (a->is_dir);
4104   BFD_ASSERT (b->is_dir);
4105
4106   adir = a->value.directory;
4107   bdir = b->value.directory;
4108
4109   if (adir->characteristics != bdir->characteristics)
4110     {
4111       _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4112       bfd_set_error (bfd_error_file_truncated);
4113       return;
4114     }
4115
4116   if (adir->major != bdir->major || adir->minor != bdir->minor)
4117     {
4118       _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4119       bfd_set_error (bfd_error_file_truncated);
4120       return;
4121     }
4122
4123   /* Attach B's name chain to A.  */
4124   rsrc_attach_chain (& adir->names, & bdir->names);
4125
4126   /* Attach B's ID chain to A.  */
4127   rsrc_attach_chain (& adir->ids, & bdir->ids);
4128
4129   /* Now sort A's entries.  */
4130   rsrc_sort_entries (& adir->names, TRUE, adir);
4131   rsrc_sort_entries (& adir->ids, FALSE, adir);
4132 }
4133
4134 /* Check the .rsrc section.  If it contains multiple concatenated
4135    resources then we must merge them properly.  Otherwise Windows
4136    will ignore all but the first set.  */
4137
4138 static void
4139 rsrc_process_section (bfd * abfd,
4140                       struct coff_final_link_info * pfinfo)
4141 {
4142   rsrc_directory    new_table;
4143   bfd_size_type     size;
4144   asection *        sec;
4145   pe_data_type *    pe;
4146   bfd_vma           rva_bias;
4147   bfd_byte *        data;
4148   bfd_byte *        datastart;
4149   bfd_byte *        dataend;
4150   bfd_byte *        new_data;
4151   unsigned int      num_resource_sets;
4152   rsrc_directory *  type_tables;
4153   rsrc_write_data   write_data;
4154   unsigned int      indx;
4155   bfd *             input;
4156   unsigned int      num_input_rsrc = 0;
4157   unsigned int      max_num_input_rsrc = 4;
4158   ptrdiff_t *       rsrc_sizes = NULL;
4159
4160   new_table.names.num_entries = 0;
4161   new_table.ids.num_entries = 0;
4162
4163   sec = bfd_get_section_by_name (abfd, ".rsrc");
4164   if (sec == NULL || (size = sec->rawsize) == 0)
4165     return;
4166
4167   pe = pe_data (abfd);
4168   if (pe == NULL)
4169     return;
4170
4171   rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4172
4173   data = bfd_malloc (size);
4174   if (data == NULL)
4175     return;
4176
4177   datastart = data;
4178
4179   if (! bfd_get_section_contents (abfd, sec, data, 0, size))
4180     goto end;
4181
4182   /* Step zero: Scan the input bfds looking for .rsrc sections and record
4183      their lengths.  Note - we rely upon the fact that the linker script
4184      does *not* sort the input .rsrc sections, so that the order in the
4185      linkinfo list matches the order in the output .rsrc section.
4186
4187      We need to know the lengths because each input .rsrc section has padding
4188      at the end of a variable amount.  (It does not appear to be based upon
4189      the section alignment or the file alignment).  We need to skip any
4190      padding bytes when parsing the input .rsrc sections.  */
4191   rsrc_sizes = bfd_malloc (max_num_input_rsrc * sizeof * rsrc_sizes);
4192   if (rsrc_sizes == NULL)
4193     goto end;
4194
4195   for (input = pfinfo->info->input_bfds;
4196        input != NULL;
4197        input = input->link.next)
4198     {
4199       asection * rsrc_sec = bfd_get_section_by_name (input, ".rsrc");
4200
4201       /* PR 18372 - skip discarded .rsrc sections.  */
4202       if (rsrc_sec != NULL && !discarded_section (rsrc_sec))
4203         {
4204           if (num_input_rsrc == max_num_input_rsrc)
4205             {
4206               max_num_input_rsrc += 10;
4207               rsrc_sizes = bfd_realloc (rsrc_sizes, max_num_input_rsrc
4208                                         * sizeof * rsrc_sizes);
4209               if (rsrc_sizes == NULL)
4210                 goto end;
4211             }
4212
4213           BFD_ASSERT (rsrc_sec->size > 0);
4214           rsrc_sizes [num_input_rsrc ++] = rsrc_sec->size;
4215         }
4216     }
4217
4218   if (num_input_rsrc < 2)
4219     goto end;
4220
4221   /* Step one: Walk the section, computing the size of the tables,
4222      leaves and data and decide if we need to do anything.  */
4223   dataend = data + size;
4224   num_resource_sets = 0;
4225
4226   while (data < dataend)
4227     {
4228       bfd_byte * p = data;
4229
4230       data = rsrc_count_directory (abfd, data, data, dataend, rva_bias);
4231
4232       if (data > dataend)
4233         {
4234           /* Corrupted .rsrc section - cannot merge.  */
4235           _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4236                               abfd);
4237           bfd_set_error (bfd_error_file_truncated);
4238           goto end;
4239         }
4240
4241       if ((data - p) > rsrc_sizes [num_resource_sets])
4242         {
4243           _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4244                               abfd);
4245           bfd_set_error (bfd_error_file_truncated);
4246           goto end;
4247         }
4248       /* FIXME: Should we add a check for "data - p" being much smaller
4249          than rsrc_sizes[num_resource_sets] ?  */
4250
4251       data = p + rsrc_sizes[num_resource_sets];
4252       rva_bias += data - p;
4253       ++ num_resource_sets;
4254     }
4255   BFD_ASSERT (num_resource_sets == num_input_rsrc);
4256
4257   /* Step two: Walk the data again, building trees of the resources.  */
4258   data = datastart;
4259   rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4260
4261   type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables);
4262   if (type_tables == NULL)
4263     goto end;
4264
4265   indx = 0;
4266   while (data < dataend)
4267     {
4268       bfd_byte * p = data;
4269
4270       (void) rsrc_parse_directory (abfd, type_tables + indx, data, data,
4271                                    dataend, rva_bias, NULL);
4272       data = p + rsrc_sizes[indx];
4273       rva_bias += data - p;
4274       ++ indx;
4275     }
4276   BFD_ASSERT (indx == num_resource_sets);
4277
4278   /* Step three: Merge the top level tables (there can be only one).
4279
4280      We must ensure that the merged entries are in ascending order.
4281
4282      We also thread the top level table entries from the old tree onto
4283      the new table, so that they can be pulled off later.  */
4284
4285   /* FIXME: Should we verify that all type tables are the same ?  */
4286   new_table.characteristics = type_tables[0].characteristics;
4287   new_table.time            = type_tables[0].time;
4288   new_table.major           = type_tables[0].major;
4289   new_table.minor           = type_tables[0].minor;
4290
4291   /* Chain the NAME entries onto the table.  */
4292   new_table.names.first_entry = NULL;
4293   new_table.names.last_entry = NULL;
4294
4295   for (indx = 0; indx < num_resource_sets; indx++)
4296     rsrc_attach_chain (& new_table.names, & type_tables[indx].names);
4297
4298   rsrc_sort_entries (& new_table.names, TRUE, & new_table);
4299
4300   /* Chain the ID entries onto the table.  */
4301   new_table.ids.first_entry = NULL;
4302   new_table.ids.last_entry = NULL;
4303
4304   for (indx = 0; indx < num_resource_sets; indx++)
4305     rsrc_attach_chain (& new_table.ids, & type_tables[indx].ids);
4306
4307   rsrc_sort_entries (& new_table.ids, FALSE, & new_table);
4308
4309   /* Step four: Create new contents for the .rsrc section.  */
4310   /* Step four point one: Compute the size of each region of the .rsrc section.
4311      We do this now, rather than earlier, as the merging above may have dropped
4312      some entries.  */
4313   sizeof_leaves = sizeof_strings = sizeof_tables_and_entries = 0;
4314   rsrc_compute_region_sizes (& new_table);
4315   /* We increment sizeof_strings to make sure that resource data
4316      starts on an 8-byte boundary.  FIXME: Is this correct ?  */
4317   sizeof_strings = (sizeof_strings + 7) & ~ 7;
4318
4319   new_data = bfd_zalloc (abfd, size);
4320   if (new_data == NULL)
4321     goto end;
4322
4323   write_data.abfd        = abfd;
4324   write_data.datastart   = new_data;
4325   write_data.next_table  = new_data;
4326   write_data.next_leaf   = new_data + sizeof_tables_and_entries;
4327   write_data.next_string = write_data.next_leaf + sizeof_leaves;
4328   write_data.next_data   = write_data.next_string + sizeof_strings;
4329   write_data.rva_bias    = sec->vma - pe->pe_opthdr.ImageBase;
4330
4331   rsrc_write_directory (& write_data, & new_table);
4332
4333   /* Step five: Replace the old contents with the new.
4334      We don't recompute the size as it's too late here to shrink section.
4335      See PR ld/20193 for more details.  */
4336   bfd_set_section_contents (pfinfo->output_bfd, sec, new_data, 0, size);
4337   sec->size = sec->rawsize = size;
4338
4339  end:
4340   /* Step six: Free all the memory that we have used.  */
4341   /* FIXME: Free the resource tree, if we have one.  */
4342   free (datastart);
4343   free (rsrc_sizes);
4344 }
4345
4346 /* Handle the .idata section and other things that need symbol table
4347    access.  */
4348
4349 bfd_boolean
4350 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
4351 {
4352   struct coff_link_hash_entry *h1;
4353   struct bfd_link_info *info = pfinfo->info;
4354   bfd_boolean result = TRUE;
4355
4356   /* There are a few fields that need to be filled in now while we
4357      have symbol table access.
4358
4359      The .idata subsections aren't directly available as sections, but
4360      they are in the symbol table, so get them from there.  */
4361
4362   /* The import directory.  This is the address of .idata$2, with size
4363      of .idata$2 + .idata$3.  */
4364   h1 = coff_link_hash_lookup (coff_hash_table (info),
4365                               ".idata$2", FALSE, FALSE, TRUE);
4366   if (h1 != NULL)
4367     {
4368       /* PR ld/2729: We cannot rely upon all the output sections having been
4369          created properly, so check before referencing them.  Issue a warning
4370          message for any sections tht could not be found.  */
4371       if ((h1->root.type == bfd_link_hash_defined
4372            || h1->root.type == bfd_link_hash_defweak)
4373           && h1->root.u.def.section != NULL
4374           && h1->root.u.def.section->output_section != NULL)
4375         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
4376           (h1->root.u.def.value
4377            + h1->root.u.def.section->output_section->vma
4378            + h1->root.u.def.section->output_offset);
4379       else
4380         {
4381           _bfd_error_handler
4382             (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4383              abfd);
4384           result = FALSE;
4385         }
4386
4387       h1 = coff_link_hash_lookup (coff_hash_table (info),
4388                                   ".idata$4", FALSE, FALSE, TRUE);
4389       if (h1 != NULL
4390           && (h1->root.type == bfd_link_hash_defined
4391            || h1->root.type == bfd_link_hash_defweak)
4392           && h1->root.u.def.section != NULL
4393           && h1->root.u.def.section->output_section != NULL)
4394         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
4395           ((h1->root.u.def.value
4396             + h1->root.u.def.section->output_section->vma
4397             + h1->root.u.def.section->output_offset)
4398            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
4399       else
4400         {
4401           _bfd_error_handler
4402             (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4403              abfd);
4404           result = FALSE;
4405         }
4406
4407       /* The import address table.  This is the size/address of
4408          .idata$5.  */
4409       h1 = coff_link_hash_lookup (coff_hash_table (info),
4410                                   ".idata$5", FALSE, FALSE, TRUE);
4411       if (h1 != NULL
4412           && (h1->root.type == bfd_link_hash_defined
4413            || h1->root.type == bfd_link_hash_defweak)
4414           && h1->root.u.def.section != NULL
4415           && h1->root.u.def.section->output_section != NULL)
4416         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4417           (h1->root.u.def.value
4418            + h1->root.u.def.section->output_section->vma
4419            + h1->root.u.def.section->output_offset);
4420       else
4421         {
4422           _bfd_error_handler
4423             (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4424              abfd);
4425           result = FALSE;
4426         }
4427
4428       h1 = coff_link_hash_lookup (coff_hash_table (info),
4429                                   ".idata$6", FALSE, FALSE, TRUE);
4430       if (h1 != NULL
4431           && (h1->root.type == bfd_link_hash_defined
4432            || h1->root.type == bfd_link_hash_defweak)
4433           && h1->root.u.def.section != NULL
4434           && h1->root.u.def.section->output_section != NULL)
4435         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4436           ((h1->root.u.def.value
4437             + h1->root.u.def.section->output_section->vma
4438             + h1->root.u.def.section->output_offset)
4439            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
4440       else
4441         {
4442           _bfd_error_handler
4443             (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4444              abfd);
4445           result = FALSE;
4446         }
4447     }
4448   else
4449     {
4450       h1 = coff_link_hash_lookup (coff_hash_table (info),
4451                                   "__IAT_start__", FALSE, FALSE, TRUE);
4452       if (h1 != NULL
4453           && (h1->root.type == bfd_link_hash_defined
4454            || h1->root.type == bfd_link_hash_defweak)
4455           && h1->root.u.def.section != NULL
4456           && h1->root.u.def.section->output_section != NULL)
4457         {
4458           bfd_vma iat_va;
4459
4460           iat_va =
4461             (h1->root.u.def.value
4462              + h1->root.u.def.section->output_section->vma
4463              + h1->root.u.def.section->output_offset);
4464
4465           h1 = coff_link_hash_lookup (coff_hash_table (info),
4466                                       "__IAT_end__", FALSE, FALSE, TRUE);
4467           if (h1 != NULL
4468               && (h1->root.type == bfd_link_hash_defined
4469                || h1->root.type == bfd_link_hash_defweak)
4470               && h1->root.u.def.section != NULL
4471               && h1->root.u.def.section->output_section != NULL)
4472             {
4473               pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4474                 ((h1->root.u.def.value
4475                   + h1->root.u.def.section->output_section->vma
4476                   + h1->root.u.def.section->output_offset)
4477                  - iat_va);
4478               if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
4479                 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4480                   iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
4481             }
4482           else
4483             {
4484               _bfd_error_handler
4485                 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4486                    " because .idata$6 is missing"), abfd);
4487               result = FALSE;
4488             }
4489         }
4490     }
4491
4492   h1 = coff_link_hash_lookup (coff_hash_table (info),
4493                               (bfd_get_symbol_leading_char (abfd) != 0
4494                                ? "__tls_used" : "_tls_used"),
4495                               FALSE, FALSE, TRUE);
4496   if (h1 != NULL)
4497     {
4498       if ((h1->root.type == bfd_link_hash_defined
4499            || h1->root.type == bfd_link_hash_defweak)
4500           && h1->root.u.def.section != NULL
4501           && h1->root.u.def.section->output_section != NULL)
4502         pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
4503           (h1->root.u.def.value
4504            + h1->root.u.def.section->output_section->vma
4505            + h1->root.u.def.section->output_offset
4506            - pe_data (abfd)->pe_opthdr.ImageBase);
4507       else
4508         {
4509           _bfd_error_handler
4510             (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4511              abfd);
4512           result = FALSE;
4513         }
4514      /* According to PECOFF sepcifications by Microsoft version 8.2
4515         the TLS data directory consists of 4 pointers, followed
4516         by two 4-byte integer. This implies that the total size
4517         is different for 32-bit and 64-bit executables.  */
4518 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4519       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
4520 #else
4521       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
4522 #endif
4523     }
4524
4525 /* If there is a .pdata section and we have linked pdata finally, we
4526      need to sort the entries ascending.  */
4527 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4528   {
4529     asection *sec = bfd_get_section_by_name (abfd, ".pdata");
4530
4531     if (sec)
4532       {
4533         bfd_size_type x = sec->rawsize;
4534         bfd_byte *tmp_data = NULL;
4535
4536         if (x)
4537           tmp_data = bfd_malloc (x);
4538
4539         if (tmp_data != NULL)
4540           {
4541             if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
4542               {
4543                 qsort (tmp_data,
4544                        (size_t) (x / 12),
4545                        12, sort_x64_pdata);
4546                 bfd_set_section_contents (pfinfo->output_bfd, sec,
4547                                           tmp_data, 0, x);
4548               }
4549             free (tmp_data);
4550           }
4551         else
4552           result = FALSE;
4553       }
4554   }
4555 #endif
4556
4557   rsrc_process_section (abfd, pfinfo);
4558
4559   /* If we couldn't find idata$2, we either have an excessively
4560      trivial program or are in DEEP trouble; we have to assume trivial
4561      program....  */
4562   return result;
4563 }