bfd/peXXigen.c

   1 /* Support for the generic parts of PE/PEI; the common executable parts.
   2    Copyright (C) 1995-2019 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     unsigned 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"
 533              " data-directory entries: %u"), abfd, a->NumberOfRvaAndSizes);
 534         bfd_set_error (bfd_error_bad_value);
 535
 536         /* Paranoia: If the number is corrupt, then assume that the
 537            actual entries themselves might be corrupt as well.  */
 538         a->NumberOfRvaAndSizes = 0;
 539       }
 540
 541     for (idx = 0; idx < a->NumberOfRvaAndSizes; idx++)
 542       {
 543         /* If data directory is empty, rva also should be 0.  */
 544         int size =
 545           H_GET_32 (abfd, src->DataDirectory[idx][1]);
 546
 547         a->DataDirectory[idx].Size = size;
 548
 549         if (size)
 550           a->DataDirectory[idx].VirtualAddress =
 551             H_GET_32 (abfd, src->DataDirectory[idx][0]);
 552         else
 553           a->DataDirectory[idx].VirtualAddress = 0;
 554       }
 555
 556     while (idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
 557       {
 558         a->DataDirectory[idx].Size = 0;
 559         a->DataDirectory[idx].VirtualAddress = 0;
 560         idx ++;
 561       }
 562   }
 563
 564   if (aouthdr_int->entry)
 565     {
 566       aouthdr_int->entry += a->ImageBase;
 567 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 568       aouthdr_int->entry &= 0xffffffff;
 569 #endif
 570     }
 571
 572   if (aouthdr_int->tsize)
 573     {
 574       aouthdr_int->text_start += a->ImageBase;
 575 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 576       aouthdr_int->text_start &= 0xffffffff;
 577 #endif
 578     }
 579
 580 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 581   /* PE32+ does not have data_start member!  */
 582   if (aouthdr_int->dsize)
 583     {
 584       aouthdr_int->data_start += a->ImageBase;
 585       aouthdr_int->data_start &= 0xffffffff;
 586     }
 587 #endif
 588
 589 #ifdef POWERPC_LE_PE
 590   /* These three fields are normally set up by ppc_relocate_section.
 591      In the case of reading a file in, we can pick them up from the
 592      DataDirectory.  */
 593   first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
 594   thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
 595   import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
 596 #endif
 597 }
 598
 599 /* A support function for below.  */
 600
 601 static void
 602 add_data_entry (bfd * abfd,
 603                 struct internal_extra_pe_aouthdr *aout,
 604                 int idx,
 605                 char *name,
 606                 bfd_vma base)
 607 {
 608   asection *sec = bfd_get_section_by_name (abfd, name);
 609
 610   /* Add import directory information if it exists.  */
 611   if ((sec != NULL)
 612       && (coff_section_data (abfd, sec) != NULL)
 613       && (pei_section_data (abfd, sec) != NULL))
 614     {
 615       /* If data directory is empty, rva also should be 0.  */
 616       int size = pei_section_data (abfd, sec)->virt_size;
 617       aout->DataDirectory[idx].Size = size;
 618
 619       if (size)
 620         {
 621           aout->DataDirectory[idx].VirtualAddress =
 622             (sec->vma - base) & 0xffffffff;
 623           sec->flags |= SEC_DATA;
 624         }
 625     }
 626 }
 627
 628 unsigned int
 629 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
 630 {
 631   struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
 632   pe_data_type *pe = pe_data (abfd);
 633   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
 634   PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
 635   bfd_vma sa, fa, ib;
 636   IMAGE_DATA_DIRECTORY idata2, idata5, tls;
 637
 638   sa = extra->SectionAlignment;
 639   fa = extra->FileAlignment;
 640   ib = extra->ImageBase;
 641
 642   idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
 643   idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
 644   tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
 645
 646   if (aouthdr_in->tsize)
 647     {
 648       aouthdr_in->text_start -= ib;
 649 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 650       aouthdr_in->text_start &= 0xffffffff;
 651 #endif
 652     }
 653
 654   if (aouthdr_in->dsize)
 655     {
 656       aouthdr_in->data_start -= ib;
 657 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 658       aouthdr_in->data_start &= 0xffffffff;
 659 #endif
 660     }
 661
 662   if (aouthdr_in->entry)
 663     {
 664       aouthdr_in->entry -= ib;
 665 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 666       aouthdr_in->entry &= 0xffffffff;
 667 #endif
 668     }
 669
 670 #define FA(x) (((x) + fa -1 ) & (- fa))
 671 #define SA(x) (((x) + sa -1 ) & (- sa))
 672
 673   /* We like to have the sizes aligned.  */
 674   aouthdr_in->bsize = FA (aouthdr_in->bsize);
 675
 676   extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
 677
 678   add_data_entry (abfd, extra, PE_EXPORT_TABLE, ".edata", ib);
 679   add_data_entry (abfd, extra, PE_RESOURCE_TABLE, ".rsrc", ib);
 680   add_data_entry (abfd, extra, PE_EXCEPTION_TABLE, ".pdata", ib);
 681
 682   /* In theory we do not need to call add_data_entry for .idata$2 or
 683      .idata$5.  It will be done in bfd_coff_final_link where all the
 684      required information is available.  If however, we are not going
 685      to perform a final link, eg because we have been invoked by objcopy
 686      or strip, then we need to make sure that these Data Directory
 687      entries are initialised properly.
 688
 689      So - we copy the input values into the output values, and then, if
 690      a final link is going to be performed, it can overwrite them.  */
 691   extra->DataDirectory[PE_IMPORT_TABLE]  = idata2;
 692   extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
 693   extra->DataDirectory[PE_TLS_TABLE] = tls;
 694
 695   if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
 696     /* Until other .idata fixes are made (pending patch), the entry for
 697        .idata is needed for backwards compatibility.  FIXME.  */
 698     add_data_entry (abfd, extra, PE_IMPORT_TABLE, ".idata", ib);
 699
 700   /* For some reason, the virtual size (which is what's set by
 701      add_data_entry) for .reloc is not the same as the size recorded
 702      in this slot by MSVC; it doesn't seem to cause problems (so far),
 703      but since it's the best we've got, use it.  It does do the right
 704      thing for .pdata.  */
 705   if (pe->has_reloc_section)
 706     add_data_entry (abfd, extra, PE_BASE_RELOCATION_TABLE, ".reloc", ib);
 707
 708   {
 709     asection *sec;
 710     bfd_vma hsize = 0;
 711     bfd_vma dsize = 0;
 712     bfd_vma isize = 0;
 713     bfd_vma tsize = 0;
 714
 715     for (sec = abfd->sections; sec; sec = sec->next)
 716       {
 717         int rounded = FA (sec->size);
 718
 719         /* The first non-zero section filepos is the header size.
 720            Sections without contents will have a filepos of 0.  */
 721         if (hsize == 0)
 722           hsize = sec->filepos;
 723         if (sec->flags & SEC_DATA)
 724           dsize += rounded;
 725         if (sec->flags & SEC_CODE)
 726           tsize += rounded;
 727         /* The image size is the total VIRTUAL size (which is what is
 728            in the virt_size field).  Files have been seen (from MSVC
 729            5.0 link.exe) where the file size of the .data segment is
 730            quite small compared to the virtual size.  Without this
 731            fix, strip munges the file.
 732
 733            FIXME: We need to handle holes between sections, which may
 734            happpen when we covert from another format.  We just use
 735            the virtual address and virtual size of the last section
 736            for the image size.  */
 737         if (coff_section_data (abfd, sec) != NULL
 738             && pei_section_data (abfd, sec) != NULL)
 739           isize = (sec->vma - extra->ImageBase
 740                    + SA (FA (pei_section_data (abfd, sec)->virt_size)));
 741       }
 742
 743     aouthdr_in->dsize = dsize;
 744     aouthdr_in->tsize = tsize;
 745     extra->SizeOfHeaders = hsize;
 746     extra->SizeOfImage = isize;
 747   }
 748
 749   H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
 750
 751 /* e.g. 219510000 is linker version 2.19  */
 752 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
 753
 754   /* This piece of magic sets the "linker version" field to
 755      LINKER_VERSION.  */
 756   H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
 757             aouthdr_out->standard.vstamp);
 758
 759   PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
 760   PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
 761   PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
 762   PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
 763   PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
 764                           aouthdr_out->standard.text_start);
 765
 766 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
 767   /* PE32+ does not have data_start member!  */
 768   PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
 769                           aouthdr_out->standard.data_start);
 770 #endif
 771
 772   PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
 773   H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
 774   H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
 775   H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
 776             aouthdr_out->MajorOperatingSystemVersion);
 777   H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
 778             aouthdr_out->MinorOperatingSystemVersion);
 779   H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
 780   H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
 781   H_PUT_16 (abfd, extra->MajorSubsystemVersion,
 782             aouthdr_out->MajorSubsystemVersion);
 783   H_PUT_16 (abfd, extra->MinorSubsystemVersion,
 784             aouthdr_out->MinorSubsystemVersion);
 785   H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
 786   H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
 787   H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
 788   H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
 789   H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
 790   H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
 791   PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
 792                                     aouthdr_out->SizeOfStackReserve);
 793   PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
 794                                    aouthdr_out->SizeOfStackCommit);
 795   PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
 796                                    aouthdr_out->SizeOfHeapReserve);
 797   PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
 798                                   aouthdr_out->SizeOfHeapCommit);
 799   H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
 800   H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
 801             aouthdr_out->NumberOfRvaAndSizes);
 802   {
 803     int idx;
 804
 805     for (idx = 0; idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; idx++)
 806       {
 807         H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
 808                   aouthdr_out->DataDirectory[idx][0]);
 809         H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
 810                   aouthdr_out->DataDirectory[idx][1]);
 811       }
 812   }
 813
 814   return AOUTSZ;
 815 }
 816
 817 unsigned int
 818 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
 819 {
 820   int idx;
 821   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 822   struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
 823
 824   if (pe_data (abfd)->has_reloc_section
 825       || pe_data (abfd)->dont_strip_reloc)
 826     filehdr_in->f_flags &= ~F_RELFLG;
 827
 828   if (pe_data (abfd)->dll)
 829     filehdr_in->f_flags |= F_DLL;
 830
 831   filehdr_in->pe.e_magic    = IMAGE_DOS_SIGNATURE;
 832   filehdr_in->pe.e_cblp     = 0x90;
 833   filehdr_in->pe.e_cp       = 0x3;
 834   filehdr_in->pe.e_crlc     = 0x0;
 835   filehdr_in->pe.e_cparhdr  = 0x4;
 836   filehdr_in->pe.e_minalloc = 0x0;
 837   filehdr_in->pe.e_maxalloc = 0xffff;
 838   filehdr_in->pe.e_ss       = 0x0;
 839   filehdr_in->pe.e_sp       = 0xb8;
 840   filehdr_in->pe.e_csum     = 0x0;
 841   filehdr_in->pe.e_ip       = 0x0;
 842   filehdr_in->pe.e_cs       = 0x0;
 843   filehdr_in->pe.e_lfarlc   = 0x40;
 844   filehdr_in->pe.e_ovno     = 0x0;
 845
 846   for (idx = 0; idx < 4; idx++)
 847     filehdr_in->pe.e_res[idx] = 0x0;
 848
 849   filehdr_in->pe.e_oemid   = 0x0;
 850   filehdr_in->pe.e_oeminfo = 0x0;
 851
 852   for (idx = 0; idx < 10; idx++)
 853     filehdr_in->pe.e_res2[idx] = 0x0;
 854
 855   filehdr_in->pe.e_lfanew = 0x80;
 856
 857   /* This next collection of data are mostly just characters.  It
 858      appears to be constant within the headers put on NT exes.  */
 859   filehdr_in->pe.dos_message[0]  = 0x0eba1f0e;
 860   filehdr_in->pe.dos_message[1]  = 0xcd09b400;
 861   filehdr_in->pe.dos_message[2]  = 0x4c01b821;
 862   filehdr_in->pe.dos_message[3]  = 0x685421cd;
 863   filehdr_in->pe.dos_message[4]  = 0x70207369;
 864   filehdr_in->pe.dos_message[5]  = 0x72676f72;
 865   filehdr_in->pe.dos_message[6]  = 0x63206d61;
 866   filehdr_in->pe.dos_message[7]  = 0x6f6e6e61;
 867   filehdr_in->pe.dos_message[8]  = 0x65622074;
 868   filehdr_in->pe.dos_message[9]  = 0x6e757220;
 869   filehdr_in->pe.dos_message[10] = 0x206e6920;
 870   filehdr_in->pe.dos_message[11] = 0x20534f44;
 871   filehdr_in->pe.dos_message[12] = 0x65646f6d;
 872   filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
 873   filehdr_in->pe.dos_message[14] = 0x24;
 874   filehdr_in->pe.dos_message[15] = 0x0;
 875   filehdr_in->pe.nt_signature = IMAGE_NT_SIGNATURE;
 876
 877   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
 878   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 879
 880   /* Use a real timestamp by default, unless the no-insert-timestamp
 881      option was chosen.  */
 882   if ((pe_data (abfd)->insert_timestamp))
 883     H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
 884   else
 885     H_PUT_32 (abfd, 0, filehdr_out->f_timdat);
 886
 887   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
 888                       filehdr_out->f_symptr);
 889   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 890   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 891   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 892
 893   /* Put in extra dos header stuff.  This data remains essentially
 894      constant, it just has to be tacked on to the beginning of all exes
 895      for NT.  */
 896   H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
 897   H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
 898   H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
 899   H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
 900   H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
 901   H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
 902   H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
 903   H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
 904   H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
 905   H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
 906   H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
 907   H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
 908   H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
 909   H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
 910
 911   for (idx = 0; idx < 4; idx++)
 912     H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
 913
 914   H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
 915   H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
 916
 917   for (idx = 0; idx < 10; idx++)
 918     H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
 919
 920   H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
 921
 922   for (idx = 0; idx < 16; idx++)
 923     H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
 924               filehdr_out->dos_message[idx]);
 925
 926   /* Also put in the NT signature.  */
 927   H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
 928
 929   return FILHSZ;
 930 }
 931
 932 unsigned int
 933 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
 934 {
 935   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 936   FILHDR *filehdr_out = (FILHDR *) out;
 937
 938   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
 939   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 940   H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
 941   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
 942   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 943   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 944   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 945
 946   return FILHSZ;
 947 }
 948
 949 unsigned int
 950 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
 951 {
 952   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 953   SCNHDR *scnhdr_ext = (SCNHDR *) out;
 954   unsigned int ret = SCNHSZ;
 955   bfd_vma ps;
 956   bfd_vma ss;
 957
 958   memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
 959
 960   PUT_SCNHDR_VADDR (abfd,
 961                     ((scnhdr_int->s_vaddr
 962                       - pe_data (abfd)->pe_opthdr.ImageBase)
 963                      & 0xffffffff),
 964                     scnhdr_ext->s_vaddr);
 965
 966   /* NT wants the size data to be rounded up to the next
 967      NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
 968      sometimes).  */
 969   if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
 970     {
 971       if (bfd_pei_p (abfd))
 972         {
 973           ps = scnhdr_int->s_size;
 974           ss = 0;
 975         }
 976       else
 977        {
 978          ps = 0;
 979          ss = scnhdr_int->s_size;
 980        }
 981     }
 982   else
 983     {
 984       if (bfd_pei_p (abfd))
 985         ps = scnhdr_int->s_paddr;
 986       else
 987         ps = 0;
 988
 989       ss = scnhdr_int->s_size;
 990     }
 991
 992   PUT_SCNHDR_SIZE (abfd, ss,
 993                    scnhdr_ext->s_size);
 994
 995   /* s_paddr in PE is really the virtual size.  */
 996   PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
 997
 998   PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
 999                      scnhdr_ext->s_scnptr);
1000   PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
1001                      scnhdr_ext->s_relptr);
1002   PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
1003                       scnhdr_ext->s_lnnoptr);
1004
1005   {
1006     /* Extra flags must be set when dealing with PE.  All sections should also
1007        have the IMAGE_SCN_MEM_READ (0x40000000) flag set.  In addition, the
1008        .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
1009        sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
1010        (this is especially important when dealing with the .idata section since
1011        the addresses for routines from .dlls must be overwritten).  If .reloc
1012        section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
1013        (0x02000000).  Also, the resource data should also be read and
1014        writable.  */
1015
1016     /* FIXME: Alignment is also encoded in this field, at least on PPC and
1017        ARM-WINCE.  Although - how do we get the original alignment field
1018        back ?  */
1019
1020     typedef struct
1021     {
1022       char section_name[SCNNMLEN];
1023       unsigned long     must_have;
1024     }
1025     pe_required_section_flags;
1026
1027     pe_required_section_flags known_sections [] =
1028       {
1029         { ".arch",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
1030         { ".bss",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1031         { ".data",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1032         { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1033         { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1034         { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1035         { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1036         { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
1037         { ".rsrc",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1038         { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
1039         { ".tls",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1040         { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1041       };
1042
1043     pe_required_section_flags * p;
1044
1045     /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1046        we know exactly what this specific section wants so we remove it
1047        and then allow the must_have field to add it back in if necessary.
1048        However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1049        default WP_TEXT file flag has been cleared.  WP_TEXT may be cleared
1050        by ld --enable-auto-import (if auto-import is actually needed),
1051        by ld --omagic, or by obcopy --writable-text.  */
1052
1053     for (p = known_sections;
1054          p < known_sections + ARRAY_SIZE (known_sections);
1055          p++)
1056       if (memcmp (scnhdr_int->s_name, p->section_name, SCNNMLEN) == 0)
1057         {
1058           if (memcmp (scnhdr_int->s_name, ".text", sizeof ".text")
1059               || (bfd_get_file_flags (abfd) & WP_TEXT))
1060             scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
1061           scnhdr_int->s_flags |= p->must_have;
1062           break;
1063         }
1064
1065     H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1066   }
1067
1068   if (coff_data (abfd)->link_info
1069       && ! bfd_link_relocatable (coff_data (abfd)->link_info)
1070       && ! bfd_link_pic (coff_data (abfd)->link_info)
1071       && memcmp (scnhdr_int->s_name, ".text", sizeof ".text") == 0)
1072     {
1073       /* By inference from looking at MS output, the 32 bit field
1074          which is the combination of the number_of_relocs and
1075          number_of_linenos is used for the line number count in
1076          executables.  A 16-bit field won't do for cc1.  The MS
1077          document says that the number of relocs is zero for
1078          executables, but the 17-th bit has been observed to be there.
1079          Overflow is not an issue: a 4G-line program will overflow a
1080          bunch of other fields long before this!  */
1081       H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
1082       H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
1083     }
1084   else
1085     {
1086       if (scnhdr_int->s_nlnno <= 0xffff)
1087         H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
1088       else
1089         {
1090           /* xgettext:c-format */
1091           _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1092                               abfd, scnhdr_int->s_nlnno);
1093           bfd_set_error (bfd_error_file_truncated);
1094           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1095           ret = 0;
1096         }
1097
1098       /* Although we could encode 0xffff relocs here, we do not, to be
1099          consistent with other parts of bfd. Also it lets us warn, as
1100          we should never see 0xffff here w/o having the overflow flag
1101          set.  */
1102       if (scnhdr_int->s_nreloc < 0xffff)
1103         H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1104       else
1105         {
1106           /* PE can deal with large #s of relocs, but not here.  */
1107           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1108           scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1109           H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1110         }
1111     }
1112   return ret;
1113 }
1114
1115 void
1116 _bfd_XXi_swap_debugdir_in (bfd * abfd, void * ext1, void * in1)
1117 {
1118   struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) ext1;
1119   struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) in1;
1120
1121   in->Characteristics = H_GET_32(abfd, ext->Characteristics);
1122   in->TimeDateStamp = H_GET_32(abfd, ext->TimeDateStamp);
1123   in->MajorVersion = H_GET_16(abfd, ext->MajorVersion);
1124   in->MinorVersion = H_GET_16(abfd, ext->MinorVersion);
1125   in->Type = H_GET_32(abfd, ext->Type);
1126   in->SizeOfData = H_GET_32(abfd, ext->SizeOfData);
1127   in->AddressOfRawData = H_GET_32(abfd, ext->AddressOfRawData);
1128   in->PointerToRawData = H_GET_32(abfd, ext->PointerToRawData);
1129 }
1130
1131 unsigned int
1132 _bfd_XXi_swap_debugdir_out (bfd * abfd, void * inp, void * extp)
1133 {
1134   struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) extp;
1135   struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) inp;
1136
1137   H_PUT_32(abfd, in->Characteristics, ext->Characteristics);
1138   H_PUT_32(abfd, in->TimeDateStamp, ext->TimeDateStamp);
1139   H_PUT_16(abfd, in->MajorVersion, ext->MajorVersion);
1140   H_PUT_16(abfd, in->MinorVersion, ext->MinorVersion);
1141   H_PUT_32(abfd, in->Type, ext->Type);
1142   H_PUT_32(abfd, in->SizeOfData, ext->SizeOfData);
1143   H_PUT_32(abfd, in->AddressOfRawData, ext->AddressOfRawData);
1144   H_PUT_32(abfd, in->PointerToRawData, ext->PointerToRawData);
1145
1146   return sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
1147 }
1148
1149 CODEVIEW_INFO *
1150 _bfd_XXi_slurp_codeview_record (bfd * abfd, file_ptr where, unsigned long length, CODEVIEW_INFO *cvinfo)
1151 {
1152   char buffer[256+1];
1153
1154   if (bfd_seek (abfd, where, SEEK_SET) != 0)
1155     return NULL;
1156
1157   if (bfd_bread (buffer, 256, abfd) < 4)
1158     return NULL;
1159
1160   /* Ensure null termination of filename.  */
1161   buffer[256] = '\0';
1162
1163   cvinfo->CVSignature = H_GET_32 (abfd, buffer);
1164   cvinfo->Age = 0;
1165
1166   if ((cvinfo->CVSignature == CVINFO_PDB70_CVSIGNATURE)
1167       && (length > sizeof (CV_INFO_PDB70)))
1168     {
1169       CV_INFO_PDB70 *cvinfo70 = (CV_INFO_PDB70 *)(buffer);
1170
1171       cvinfo->Age = H_GET_32(abfd, cvinfo70->Age);
1172
1173       /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1174          by 8 single bytes.  Byte swap them so we can conveniently treat the GUID
1175          as 16 bytes in big-endian order.  */
1176       bfd_putb32 (bfd_getl32 (cvinfo70->Signature), cvinfo->Signature);
1177       bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[4])), &(cvinfo->Signature[4]));
1178       bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[6])), &(cvinfo->Signature[6]));
1179       memcpy (&(cvinfo->Signature[8]), &(cvinfo70->Signature[8]), 8);
1180
1181       cvinfo->SignatureLength = CV_INFO_SIGNATURE_LENGTH;
1182       // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1183
1184       return cvinfo;
1185     }
1186   else if ((cvinfo->CVSignature == CVINFO_PDB20_CVSIGNATURE)
1187            && (length > sizeof (CV_INFO_PDB20)))
1188     {
1189       CV_INFO_PDB20 *cvinfo20 = (CV_INFO_PDB20 *)(buffer);
1190       cvinfo->Age = H_GET_32(abfd, cvinfo20->Age);
1191       memcpy (cvinfo->Signature, cvinfo20->Signature, 4);
1192       cvinfo->SignatureLength = 4;
1193       // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1194
1195       return cvinfo;
1196     }
1197
1198   return NULL;
1199 }
1200
1201 unsigned int
1202 _bfd_XXi_write_codeview_record (bfd * abfd, file_ptr where, CODEVIEW_INFO *cvinfo)
1203 {
1204   const bfd_size_type size = sizeof (CV_INFO_PDB70) + 1;
1205   bfd_size_type written;
1206   CV_INFO_PDB70 *cvinfo70;
1207   char * buffer;
1208
1209   if (bfd_seek (abfd, where, SEEK_SET) != 0)
1210     return 0;
1211
1212   buffer = xmalloc (size);
1213   cvinfo70 = (CV_INFO_PDB70 *) buffer;
1214   H_PUT_32 (abfd, CVINFO_PDB70_CVSIGNATURE, cvinfo70->CvSignature);
1215
1216   /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1217      in little-endian order, followed by 8 single bytes.  */
1218   bfd_putl32 (bfd_getb32 (cvinfo->Signature), cvinfo70->Signature);
1219   bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[4])), &(cvinfo70->Signature[4]));
1220   bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[6])), &(cvinfo70->Signature[6]));
1221   memcpy (&(cvinfo70->Signature[8]), &(cvinfo->Signature[8]), 8);
1222
1223   H_PUT_32 (abfd, cvinfo->Age, cvinfo70->Age);
1224   cvinfo70->PdbFileName[0] = '\0';
1225
1226   written = bfd_bwrite (buffer, size, abfd);
1227
1228   free (buffer);
1229
1230   return written == size ? size : 0;
1231 }
1232
1233 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1234 {
1235   N_("Export Directory [.edata (or where ever we found it)]"),
1236   N_("Import Directory [parts of .idata]"),
1237   N_("Resource Directory [.rsrc]"),
1238   N_("Exception Directory [.pdata]"),
1239   N_("Security Directory"),
1240   N_("Base Relocation Directory [.reloc]"),
1241   N_("Debug Directory"),
1242   N_("Description Directory"),
1243   N_("Special Directory"),
1244   N_("Thread Storage Directory [.tls]"),
1245   N_("Load Configuration Directory"),
1246   N_("Bound Import Directory"),
1247   N_("Import Address Table Directory"),
1248   N_("Delay Import Directory"),
1249   N_("CLR Runtime Header"),
1250   N_("Reserved")
1251 };
1252
1253 #ifdef POWERPC_LE_PE
1254 /* The code for the PPC really falls in the "architecture dependent"
1255    category.  However, it's not clear that anyone will ever care, so
1256    we're ignoring the issue for now; if/when PPC matters, some of this
1257    may need to go into peicode.h, or arguments passed to enable the
1258    PPC- specific code.  */
1259 #endif
1260
1261 static bfd_boolean
1262 pe_print_idata (bfd * abfd, void * vfile)
1263 {
1264   FILE *file = (FILE *) vfile;
1265   bfd_byte *data;
1266   asection *section;
1267   bfd_signed_vma adj;
1268
1269 #ifdef POWERPC_LE_PE
1270   asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1271 #endif
1272
1273   bfd_size_type datasize = 0;
1274   bfd_size_type dataoff;
1275   bfd_size_type i;
1276   int onaline = 20;
1277
1278   pe_data_type *pe = pe_data (abfd);
1279   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1280
1281   bfd_vma addr;
1282
1283   addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1284
1285   if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1286     {
1287       /* Maybe the extra header isn't there.  Look for the section.  */
1288       section = bfd_get_section_by_name (abfd, ".idata");
1289       if (section == NULL)
1290         return TRUE;
1291
1292       addr = section->vma;
1293       datasize = section->size;
1294       if (datasize == 0)
1295         return TRUE;
1296     }
1297   else
1298     {
1299       addr += extra->ImageBase;
1300       for (section = abfd->sections; section != NULL; section = section->next)
1301         {
1302           datasize = section->size;
1303           if (addr >= section->vma && addr < section->vma + datasize)
1304             break;
1305         }
1306
1307       if (section == NULL)
1308         {
1309           fprintf (file,
1310                    _("\nThere is an import table, but the section containing it could not be found\n"));
1311           return TRUE;
1312         }
1313       else if (!(section->flags & SEC_HAS_CONTENTS))
1314         {
1315           fprintf (file,
1316                    _("\nThere is an import table in %s, but that section has no contents\n"),
1317                    section->name);
1318           return TRUE;
1319         }
1320     }
1321
1322   /* xgettext:c-format */
1323   fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1324            section->name, (unsigned long) addr);
1325
1326   dataoff = addr - section->vma;
1327
1328 #ifdef POWERPC_LE_PE
1329   if (rel_section != 0 && rel_section->size != 0)
1330     {
1331       /* The toc address can be found by taking the starting address,
1332          which on the PPC locates a function descriptor. The
1333          descriptor consists of the function code starting address
1334          followed by the address of the toc. The starting address we
1335          get from the bfd, and the descriptor is supposed to be in the
1336          .reldata section.  */
1337
1338       bfd_vma loadable_toc_address;
1339       bfd_vma toc_address;
1340       bfd_vma start_address;
1341       bfd_byte *data;
1342       bfd_vma offset;
1343
1344       if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1345         {
1346           if (data != NULL)
1347             free (data);
1348           return FALSE;
1349         }
1350
1351       offset = abfd->start_address - rel_section->vma;
1352
1353       if (offset >= rel_section->size || offset + 8 > rel_section->size)
1354         {
1355           if (data != NULL)
1356             free (data);
1357           return FALSE;
1358         }
1359
1360       start_address = bfd_get_32 (abfd, data + offset);
1361       loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1362       toc_address = loadable_toc_address - 32768;
1363
1364       fprintf (file,
1365                _("\nFunction descriptor located at the start address: %04lx\n"),
1366                (unsigned long int) (abfd->start_address));
1367       fprintf (file,
1368                /* xgettext:c-format */
1369                _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1370                start_address, loadable_toc_address, toc_address);
1371       if (data != NULL)
1372         free (data);
1373     }
1374   else
1375     {
1376       fprintf (file,
1377                _("\nNo reldata section! Function descriptor not decoded.\n"));
1378     }
1379 #endif
1380
1381   fprintf (file,
1382            _("\nThe Import Tables (interpreted %s section contents)\n"),
1383            section->name);
1384   fprintf (file,
1385            _("\
1386  vma:            Hint    Time      Forward  DLL       First\n\
1387                  Table   Stamp     Chain    Name      Thunk\n"));
1388
1389   /* Read the whole section.  Some of the fields might be before dataoff.  */
1390   if (!bfd_malloc_and_get_section (abfd, section, &data))
1391     {
1392       if (data != NULL)
1393         free (data);
1394       return FALSE;
1395     }
1396
1397   adj = section->vma - extra->ImageBase;
1398
1399   /* Print all image import descriptors.  */
1400   for (i = dataoff; i + onaline <= datasize; i += onaline)
1401     {
1402       bfd_vma hint_addr;
1403       bfd_vma time_stamp;
1404       bfd_vma forward_chain;
1405       bfd_vma dll_name;
1406       bfd_vma first_thunk;
1407       int idx = 0;
1408       bfd_size_type j;
1409       char *dll;
1410
1411       /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress).  */
1412       fprintf (file, " %08lx\t", (unsigned long) (i + adj));
1413       hint_addr = bfd_get_32 (abfd, data + i);
1414       time_stamp = bfd_get_32 (abfd, data + i + 4);
1415       forward_chain = bfd_get_32 (abfd, data + i + 8);
1416       dll_name = bfd_get_32 (abfd, data + i + 12);
1417       first_thunk = bfd_get_32 (abfd, data + i + 16);
1418
1419       fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1420                (unsigned long) hint_addr,
1421                (unsigned long) time_stamp,
1422                (unsigned long) forward_chain,
1423                (unsigned long) dll_name,
1424                (unsigned long) first_thunk);
1425
1426       if (hint_addr == 0 && first_thunk == 0)
1427         break;
1428
1429       if (dll_name - adj >= section->size)
1430         break;
1431
1432       dll = (char *) data + dll_name - adj;
1433       /* PR 17512 file: 078-12277-0.004.  */
1434       bfd_size_type maxlen = (char *)(data + datasize) - dll - 1;
1435       fprintf (file, _("\n\tDLL Name: %.*s\n"), (int) maxlen, dll);
1436
1437       /* PR 21546: When the Hint Address is zero,
1438          we try the First Thunk instead.  */
1439       if (hint_addr == 0)
1440         hint_addr = first_thunk;
1441
1442       if (hint_addr != 0 && hint_addr - adj < datasize)
1443         {
1444           bfd_byte *ft_data;
1445           asection *ft_section;
1446           bfd_vma ft_addr;
1447           bfd_size_type ft_datasize;
1448           int ft_idx;
1449           int ft_allocated;
1450
1451           fprintf (file, _("\tvma:  Hint/Ord Member-Name Bound-To\n"));
1452
1453           idx = hint_addr - adj;
1454
1455           ft_addr = first_thunk + extra->ImageBase;
1456           ft_idx = first_thunk - adj;
1457           ft_data = data + ft_idx;
1458           ft_datasize = datasize - ft_idx;
1459           ft_allocated = 0;
1460
1461           if (first_thunk != hint_addr)
1462             {
1463               /* Find the section which contains the first thunk.  */
1464               for (ft_section = abfd->sections;
1465                    ft_section != NULL;
1466                    ft_section = ft_section->next)
1467                 {
1468                   if (ft_addr >= ft_section->vma
1469                       && ft_addr < ft_section->vma + ft_section->size)
1470                     break;
1471                 }
1472
1473               if (ft_section == NULL)
1474                 {
1475                   fprintf (file,
1476                        _("\nThere is a first thunk, but the section containing it could not be found\n"));
1477                   continue;
1478                 }
1479
1480               /* Now check to see if this section is the same as our current
1481                  section.  If it is not then we will have to load its data in.  */
1482               if (ft_section != section)
1483                 {
1484                   ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1485                   ft_datasize = ft_section->size - ft_idx;
1486                   ft_data = (bfd_byte *) bfd_malloc (ft_datasize);
1487                   if (ft_data == NULL)
1488                     continue;
1489
1490                   /* Read ft_datasize bytes starting at offset ft_idx.  */
1491                   if (!bfd_get_section_contents (abfd, ft_section, ft_data,
1492                                                  (bfd_vma) ft_idx, ft_datasize))
1493                     {
1494                       free (ft_data);
1495                       continue;
1496                     }
1497                   ft_allocated = 1;
1498                 }
1499             }
1500
1501           /* Print HintName vector entries.  */
1502 #ifdef COFF_WITH_pex64
1503           for (j = 0; idx + j + 8 <= datasize; j += 8)
1504             {
1505               bfd_size_type amt;
1506               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1507               unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1508
1509               if (!member && !member_high)
1510                 break;
1511
1512               amt = member - adj;
1513
1514               if (HighBitSet (member_high))
1515                 fprintf (file, "\t%lx%08lx\t %4lx%08lx  <none>",
1516                          member_high, member,
1517                          WithoutHighBit (member_high), member);
1518               /* PR binutils/17512: Handle corrupt PE data.  */
1519               else if (amt >= datasize || amt + 2 >= datasize)
1520                 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
1521               else
1522                 {
1523                   int ordinal;
1524                   char *member_name;
1525
1526                   ordinal = bfd_get_16 (abfd, data + amt);
1527                   member_name = (char *) data + amt + 2;
1528                   fprintf (file, "\t%04lx\t %4d  %.*s",member, ordinal,
1529                            (int) (datasize - (amt + 2)), member_name);
1530                 }
1531
1532               /* If the time stamp is not zero, the import address
1533                  table holds actual addresses.  */
1534               if (time_stamp != 0
1535                   && first_thunk != 0
1536                   && first_thunk != hint_addr
1537                   && j + 4 <= ft_datasize)
1538                 fprintf (file, "\t%04lx",
1539                          (unsigned long) bfd_get_32 (abfd, ft_data + j));
1540               fprintf (file, "\n");
1541             }
1542 #else
1543           for (j = 0; idx + j + 4 <= datasize; j += 4)
1544             {
1545               bfd_size_type amt;
1546               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1547
1548               /* Print single IMAGE_IMPORT_BY_NAME vector.  */
1549               if (member == 0)
1550                 break;
1551
1552               amt = member - adj;
1553
1554               if (HighBitSet (member))
1555                 fprintf (file, "\t%04lx\t %4lu  <none>",
1556                          member, WithoutHighBit (member));
1557               /* PR binutils/17512: Handle corrupt PE data.  */
1558               else if (amt >= datasize || amt + 2 >= datasize)
1559                 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
1560               else
1561                 {
1562                   int ordinal;
1563                   char *member_name;
1564
1565                   ordinal = bfd_get_16 (abfd, data + amt);
1566                   member_name = (char *) data + amt + 2;
1567                   fprintf (file, "\t%04lx\t %4d  %.*s",
1568                            member, ordinal,
1569                            (int) (datasize - (amt + 2)), member_name);
1570                 }
1571
1572               /* If the time stamp is not zero, the import address
1573                  table holds actual addresses.  */
1574               if (time_stamp != 0
1575                   && first_thunk != 0
1576                   && first_thunk != hint_addr
1577                   && j + 4 <= ft_datasize)
1578                 fprintf (file, "\t%04lx",
1579                          (unsigned long) bfd_get_32 (abfd, ft_data + j));
1580
1581               fprintf (file, "\n");
1582             }
1583 #endif
1584           if (ft_allocated)
1585             free (ft_data);
1586         }
1587
1588       fprintf (file, "\n");
1589     }
1590
1591   free (data);
1592
1593   return TRUE;
1594 }
1595
1596 static bfd_boolean
1597 pe_print_edata (bfd * abfd, void * vfile)
1598 {
1599   FILE *file = (FILE *) vfile;
1600   bfd_byte *data;
1601   asection *section;
1602   bfd_size_type datasize = 0;
1603   bfd_size_type dataoff;
1604   bfd_size_type i;
1605   bfd_vma       adj;
1606   struct EDT_type
1607   {
1608     long export_flags;          /* Reserved - should be zero.  */
1609     long time_stamp;
1610     short major_ver;
1611     short minor_ver;
1612     bfd_vma name;               /* RVA - relative to image base.  */
1613     long base;                  /* Ordinal base.  */
1614     unsigned long num_functions;/* Number in the export address table.  */
1615     unsigned long num_names;    /* Number in the name pointer table.  */
1616     bfd_vma eat_addr;           /* RVA to the export address table.  */
1617     bfd_vma npt_addr;           /* RVA to the Export Name Pointer Table.  */
1618     bfd_vma ot_addr;            /* RVA to the Ordinal Table.  */
1619   } edt;
1620
1621   pe_data_type *pe = pe_data (abfd);
1622   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1623
1624   bfd_vma addr;
1625
1626   addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1627
1628   if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1629     {
1630       /* Maybe the extra header isn't there.  Look for the section.  */
1631       section = bfd_get_section_by_name (abfd, ".edata");
1632       if (section == NULL)
1633         return TRUE;
1634
1635       addr = section->vma;
1636       dataoff = 0;
1637       datasize = section->size;
1638       if (datasize == 0)
1639         return TRUE;
1640     }
1641   else
1642     {
1643       addr += extra->ImageBase;
1644
1645       for (section = abfd->sections; section != NULL; section = section->next)
1646         if (addr >= section->vma && addr < section->vma + section->size)
1647           break;
1648
1649       if (section == NULL)
1650         {
1651           fprintf (file,
1652                    _("\nThere is an export table, but the section containing it could not be found\n"));
1653           return TRUE;
1654         }
1655       else if (!(section->flags & SEC_HAS_CONTENTS))
1656         {
1657           fprintf (file,
1658                    _("\nThere is an export table in %s, but that section has no contents\n"),
1659                    section->name);
1660           return TRUE;
1661         }
1662
1663       dataoff = addr - section->vma;
1664       datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1665       if (dataoff > section->size
1666           || datasize > section->size - dataoff)
1667         {
1668           fprintf (file,
1669                    _("\nThere is an export table in %s, but it does not fit into that section\n"),
1670                    section->name);
1671           return TRUE;
1672         }
1673     }
1674
1675   /* PR 17512: Handle corrupt PE binaries.  */
1676   if (datasize < 40)
1677     {
1678       fprintf (file,
1679                /* xgettext:c-format */
1680                _("\nThere is an export table in %s, but it is too small (%d)\n"),
1681                section->name, (int) datasize);
1682       return TRUE;
1683     }
1684
1685   /* xgettext:c-format */
1686   fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1687            section->name, (unsigned long) addr);
1688
1689   data = (bfd_byte *) bfd_malloc (datasize);
1690   if (data == NULL)
1691     return FALSE;
1692
1693   if (! bfd_get_section_contents (abfd, section, data,
1694                                   (file_ptr) dataoff, datasize))
1695     return FALSE;
1696
1697   /* Go get Export Directory Table.  */
1698   edt.export_flags   = bfd_get_32 (abfd, data +  0);
1699   edt.time_stamp     = bfd_get_32 (abfd, data +  4);
1700   edt.major_ver      = bfd_get_16 (abfd, data +  8);
1701   edt.minor_ver      = bfd_get_16 (abfd, data + 10);
1702   edt.name           = bfd_get_32 (abfd, data + 12);
1703   edt.base           = bfd_get_32 (abfd, data + 16);
1704   edt.num_functions  = bfd_get_32 (abfd, data + 20);
1705   edt.num_names      = bfd_get_32 (abfd, data + 24);
1706   edt.eat_addr       = bfd_get_32 (abfd, data + 28);
1707   edt.npt_addr       = bfd_get_32 (abfd, data + 32);
1708   edt.ot_addr        = bfd_get_32 (abfd, data + 36);
1709
1710   adj = section->vma - extra->ImageBase + dataoff;
1711
1712   /* Dump the EDT first.  */
1713   fprintf (file,
1714            _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1715            section->name);
1716
1717   fprintf (file,
1718            _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1719
1720   fprintf (file,
1721            _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1722
1723   fprintf (file,
1724            /* xgettext:c-format */
1725            _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1726
1727   fprintf (file,
1728            _("Name \t\t\t\t"));
1729   bfd_fprintf_vma (abfd, file, edt.name);
1730
1731   if ((edt.name >= adj) && (edt.name < adj + datasize))
1732     fprintf (file, " %.*s\n",
1733              (int) (datasize - (edt.name - adj)),
1734              data + edt.name - adj);
1735   else
1736     fprintf (file, "(outside .edata section)\n");
1737
1738   fprintf (file,
1739            _("Ordinal Base \t\t\t%ld\n"), edt.base);
1740
1741   fprintf (file,
1742            _("Number in:\n"));
1743
1744   fprintf (file,
1745            _("\tExport Address Table \t\t%08lx\n"),
1746            edt.num_functions);
1747
1748   fprintf (file,
1749            _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1750
1751   fprintf (file,
1752            _("Table Addresses\n"));
1753
1754   fprintf (file,
1755            _("\tExport Address Table \t\t"));
1756   bfd_fprintf_vma (abfd, file, edt.eat_addr);
1757   fprintf (file, "\n");
1758
1759   fprintf (file,
1760            _("\tName Pointer Table \t\t"));
1761   bfd_fprintf_vma (abfd, file, edt.npt_addr);
1762   fprintf (file, "\n");
1763
1764   fprintf (file,
1765            _("\tOrdinal Table \t\t\t"));
1766   bfd_fprintf_vma (abfd, file, edt.ot_addr);
1767   fprintf (file, "\n");
1768
1769   /* The next table to find is the Export Address Table. It's basically
1770      a list of pointers that either locate a function in this dll, or
1771      forward the call to another dll. Something like:
1772       typedef union
1773       {
1774         long export_rva;
1775         long forwarder_rva;
1776       } export_address_table_entry;  */
1777
1778   fprintf (file,
1779           _("\nExport Address Table -- Ordinal Base %ld\n"),
1780           edt.base);
1781
1782   /* PR 17512: Handle corrupt PE binaries.  */
1783   /* PR 17512 file: 140-165018-0.004.  */
1784   if (edt.eat_addr - adj >= datasize
1785       /* PR 17512: file: 092b1829 */
1786       || (edt.num_functions + 1) * 4 < edt.num_functions
1787       || edt.eat_addr - adj + (edt.num_functions + 1) * 4 > datasize)
1788     fprintf (file, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1789              (long) edt.eat_addr,
1790              (long) edt.num_functions);
1791   else for (i = 0; i < edt.num_functions; ++i)
1792     {
1793       bfd_vma eat_member = bfd_get_32 (abfd,
1794                                        data + edt.eat_addr + (i * 4) - adj);
1795       if (eat_member == 0)
1796         continue;
1797
1798       if (eat_member - adj <= datasize)
1799         {
1800           /* This rva is to a name (forwarding function) in our section.  */
1801           /* Should locate a function descriptor.  */
1802           fprintf (file,
1803                    "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1804                    (long) i,
1805                    (long) (i + edt.base),
1806                    (unsigned long) eat_member,
1807                    _("Forwarder RVA"),
1808                    (int)(datasize - (eat_member - adj)),
1809                    data + eat_member - adj);
1810         }
1811       else
1812         {
1813           /* Should locate a function descriptor in the reldata section.  */
1814           fprintf (file,
1815                    "\t[%4ld] +base[%4ld] %04lx %s\n",
1816                    (long) i,
1817                    (long) (i + edt.base),
1818                    (unsigned long) eat_member,
1819                    _("Export RVA"));
1820         }
1821     }
1822
1823   /* The Export Name Pointer Table is paired with the Export Ordinal Table.  */
1824   /* Dump them in parallel for clarity.  */
1825   fprintf (file,
1826            _("\n[Ordinal/Name Pointer] Table\n"));
1827
1828   /* PR 17512: Handle corrupt PE binaries.  */
1829   if (edt.npt_addr + (edt.num_names * 4) - adj >= datasize
1830       /* PR 17512: file: bb68816e.  */
1831       || edt.num_names * 4 < edt.num_names
1832       || (data + edt.npt_addr - adj) < data)
1833     /* xgettext:c-format */
1834     fprintf (file, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1835              (long) edt.npt_addr,
1836              (long) edt.num_names);
1837   /* PR 17512: file: 140-147171-0.004.  */
1838   else if (edt.ot_addr + (edt.num_names * 2) - adj >= datasize
1839            || data + edt.ot_addr - adj < data)
1840     /* xgettext:c-format */
1841     fprintf (file, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1842              (long) edt.ot_addr,
1843              (long) edt.num_names);
1844   else for (i = 0; i < edt.num_names; ++i)
1845     {
1846       bfd_vma  name_ptr;
1847       bfd_vma  ord;
1848
1849       ord = bfd_get_16 (abfd, data + edt.ot_addr + (i * 2) - adj);
1850       name_ptr = bfd_get_32 (abfd, data + edt.npt_addr + (i * 4) - adj);
1851
1852       if ((name_ptr - adj) >= datasize)
1853         {
1854           /* xgettext:c-format */
1855           fprintf (file, _("\t[%4ld] <corrupt offset: %lx>\n"),
1856                    (long) ord, (long) name_ptr);
1857         }
1858       else
1859         {
1860           char * name = (char *) data + name_ptr - adj;
1861
1862           fprintf (file, "\t[%4ld] %.*s\n", (long) ord,
1863                    (int)((char *)(data + datasize) - name), name);
1864         }
1865     }
1866
1867   free (data);
1868
1869   return TRUE;
1870 }
1871
1872 /* This really is architecture dependent.  On IA-64, a .pdata entry
1873    consists of three dwords containing relative virtual addresses that
1874    specify the start and end address of the code range the entry
1875    covers and the address of the corresponding unwind info data.
1876
1877    On ARM and SH-4, a compressed PDATA structure is used :
1878    _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1879    _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1880    See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1881
1882    This is the version for uncompressed data.  */
1883
1884 static bfd_boolean
1885 pe_print_pdata (bfd * abfd, void * vfile)
1886 {
1887 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1888 # define PDATA_ROW_SIZE (3 * 8)
1889 #else
1890 # define PDATA_ROW_SIZE (5 * 4)
1891 #endif
1892   FILE *file = (FILE *) vfile;
1893   bfd_byte *data = 0;
1894   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1895   bfd_size_type datasize = 0;
1896   bfd_size_type i;
1897   bfd_size_type start, stop;
1898   int onaline = PDATA_ROW_SIZE;
1899
1900   if (section == NULL
1901       || coff_section_data (abfd, section) == NULL
1902       || pei_section_data (abfd, section) == NULL)
1903     return TRUE;
1904
1905   stop = pei_section_data (abfd, section)->virt_size;
1906   if ((stop % onaline) != 0)
1907     fprintf (file,
1908              /* xgettext:c-format */
1909              _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1910              (long) stop, onaline);
1911
1912   fprintf (file,
1913            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1914 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1915   fprintf (file,
1916            _(" vma:\t\t\tBegin Address    End Address      Unwind Info\n"));
1917 #else
1918   fprintf (file, _("\
1919  vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n\
1920      \t\tAddress  Address  Handler  Data     Address    Mask\n"));
1921 #endif
1922
1923   datasize = section->size;
1924   if (datasize == 0)
1925     return TRUE;
1926
1927   /* PR 17512: file: 002-193900-0.004.  */
1928   if (datasize < stop)
1929     {
1930       /* xgettext:c-format */
1931       fprintf (file, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1932                (long) stop, (long) datasize);
1933       return FALSE;
1934     }
1935
1936   if (! bfd_malloc_and_get_section (abfd, section, &data))
1937     {
1938       if (data != NULL)
1939         free (data);
1940       return FALSE;
1941     }
1942
1943   start = 0;
1944
1945   for (i = start; i < stop; i += onaline)
1946     {
1947       bfd_vma begin_addr;
1948       bfd_vma end_addr;
1949       bfd_vma eh_handler;
1950       bfd_vma eh_data;
1951       bfd_vma prolog_end_addr;
1952 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1953       int em_data;
1954 #endif
1955
1956       if (i + PDATA_ROW_SIZE > stop)
1957         break;
1958
1959       begin_addr      = GET_PDATA_ENTRY (abfd, data + i     );
1960       end_addr        = GET_PDATA_ENTRY (abfd, data + i +  4);
1961       eh_handler      = GET_PDATA_ENTRY (abfd, data + i +  8);
1962       eh_data         = GET_PDATA_ENTRY (abfd, data + i + 12);
1963       prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1964
1965       if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1966           && eh_data == 0 && prolog_end_addr == 0)
1967         /* We are probably into the padding of the section now.  */
1968         break;
1969
1970 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1971       em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1972 #endif
1973       eh_handler &= ~(bfd_vma) 0x3;
1974       prolog_end_addr &= ~(bfd_vma) 0x3;
1975
1976       fputc (' ', file);
1977       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1978       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1979       bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1980       bfd_fprintf_vma (abfd, file, eh_handler);
1981 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1982       fputc (' ', file);
1983       bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1984       bfd_fprintf_vma (abfd, file, prolog_end_addr);
1985       fprintf (file, "   %x", em_data);
1986 #endif
1987
1988 #ifdef POWERPC_LE_PE
1989       if (eh_handler == 0 && eh_data != 0)
1990         {
1991           /* Special bits here, although the meaning may be a little
1992              mysterious. The only one I know for sure is 0x03
1993              Code Significance
1994              0x00 None
1995              0x01 Register Save Millicode
1996              0x02 Register Restore Millicode
1997              0x03 Glue Code Sequence.  */
1998           switch (eh_data)
1999             {
2000             case 0x01:
2001               fprintf (file, _(" Register save millicode"));
2002               break;
2003             case 0x02:
2004               fprintf (file, _(" Register restore millicode"));
2005               break;
2006             case 0x03:
2007               fprintf (file, _(" Glue code sequence"));
2008               break;
2009             default:
2010               break;
2011             }
2012         }
2013 #endif
2014       fprintf (file, "\n");
2015     }
2016
2017   free (data);
2018
2019   return TRUE;
2020 #undef PDATA_ROW_SIZE
2021 }
2022
2023 typedef struct sym_cache
2024 {
2025   int        symcount;
2026   asymbol ** syms;
2027 } sym_cache;
2028
2029 static asymbol **
2030 slurp_symtab (bfd *abfd, sym_cache *psc)
2031 {
2032   asymbol ** sy = NULL;
2033   long storage;
2034
2035   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
2036     {
2037       psc->symcount = 0;
2038       return NULL;
2039     }
2040
2041   storage = bfd_get_symtab_upper_bound (abfd);
2042   if (storage < 0)
2043     return NULL;
2044   if (storage)
2045     {
2046       sy = (asymbol **) bfd_malloc (storage);
2047       if (sy == NULL)
2048         return NULL;
2049     }
2050
2051   psc->symcount = bfd_canonicalize_symtab (abfd, sy);
2052   if (psc->symcount < 0)
2053     return NULL;
2054   return sy;
2055 }
2056
2057 static const char *
2058 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
2059 {
2060   int i;
2061
2062   if (psc->syms == 0)
2063     psc->syms = slurp_symtab (abfd, psc);
2064
2065   for (i = 0; i < psc->symcount; i++)
2066     {
2067       if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
2068         return psc->syms[i]->name;
2069     }
2070
2071   return NULL;
2072 }
2073
2074 static void
2075 cleanup_syms (sym_cache *psc)
2076 {
2077   psc->symcount = 0;
2078   free (psc->syms);
2079   psc->syms = NULL;
2080 }
2081
2082 /* This is the version for "compressed" pdata.  */
2083
2084 bfd_boolean
2085 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
2086 {
2087 # define PDATA_ROW_SIZE (2 * 4)
2088   FILE *file = (FILE *) vfile;
2089   bfd_byte *data = NULL;
2090   asection *section = bfd_get_section_by_name (abfd, ".pdata");
2091   bfd_size_type datasize = 0;
2092   bfd_size_type i;
2093   bfd_size_type start, stop;
2094   int onaline = PDATA_ROW_SIZE;
2095   struct sym_cache cache = {0, 0} ;
2096
2097   if (section == NULL
2098       || coff_section_data (abfd, section) == NULL
2099       || pei_section_data (abfd, section) == NULL)
2100     return TRUE;
2101
2102   stop = pei_section_data (abfd, section)->virt_size;
2103   if ((stop % onaline) != 0)
2104     fprintf (file,
2105              /* xgettext:c-format */
2106              _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2107              (long) stop, onaline);
2108
2109   fprintf (file,
2110            _("\nThe Function Table (interpreted .pdata section contents)\n"));
2111
2112   fprintf (file, _("\
2113  vma:\t\tBegin    Prolog   Function Flags    Exception EH\n\
2114      \t\tAddress  Length   Length   32b exc  Handler   Data\n"));
2115
2116   datasize = section->size;
2117   if (datasize == 0)
2118     return TRUE;
2119
2120   if (! bfd_malloc_and_get_section (abfd, section, &data))
2121     {
2122       if (data != NULL)
2123         free (data);
2124       return FALSE;
2125     }
2126
2127   start = 0;
2128
2129   for (i = start; i < stop; i += onaline)
2130     {
2131       bfd_vma begin_addr;
2132       bfd_vma other_data;
2133       bfd_vma prolog_length, function_length;
2134       int flag32bit, exception_flag;
2135       asection *tsection;
2136
2137       if (i + PDATA_ROW_SIZE > stop)
2138         break;
2139
2140       begin_addr = GET_PDATA_ENTRY (abfd, data + i     );
2141       other_data = GET_PDATA_ENTRY (abfd, data + i +  4);
2142
2143       if (begin_addr == 0 && other_data == 0)
2144         /* We are probably into the padding of the section now.  */
2145         break;
2146
2147       prolog_length = (other_data & 0x000000FF);
2148       function_length = (other_data & 0x3FFFFF00) >> 8;
2149       flag32bit = (int)((other_data & 0x40000000) >> 30);
2150       exception_flag = (int)((other_data & 0x80000000) >> 31);
2151
2152       fputc (' ', file);
2153       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
2154       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
2155       bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
2156       bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
2157       fprintf (file, "%2d  %2d   ", flag32bit, exception_flag);
2158
2159       /* Get the exception handler's address and the data passed from the
2160          .text section. This is really the data that belongs with the .pdata
2161          but got "compressed" out for the ARM and SH4 architectures.  */
2162       tsection = bfd_get_section_by_name (abfd, ".text");
2163       if (tsection && coff_section_data (abfd, tsection)
2164           && pei_section_data (abfd, tsection))
2165         {
2166           bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
2167           bfd_byte *tdata;
2168
2169           tdata = (bfd_byte *) bfd_malloc (8);
2170           if (tdata)
2171             {
2172               if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
2173                 {
2174                   bfd_vma eh, eh_data;
2175
2176                   eh = bfd_get_32 (abfd, tdata);
2177                   eh_data = bfd_get_32 (abfd, tdata + 4);
2178                   fprintf (file, "%08x  ", (unsigned int) eh);
2179                   fprintf (file, "%08x", (unsigned int) eh_data);
2180                   if (eh != 0)
2181                     {
2182                       const char *s = my_symbol_for_address (abfd, eh, &cache);
2183
2184                       if (s)
2185                         fprintf (file, " (%s) ", s);
2186                     }
2187                 }
2188               free (tdata);
2189             }
2190         }
2191
2192       fprintf (file, "\n");
2193     }
2194
2195   free (data);
2196
2197   cleanup_syms (& cache);
2198
2199   return TRUE;
2200 #undef PDATA_ROW_SIZE
2201 }
2202
2203 \f
2204 #define IMAGE_REL_BASED_HIGHADJ 4
2205 static const char * const tbl[] =
2206 {
2207   "ABSOLUTE",
2208   "HIGH",
2209   "LOW",
2210   "HIGHLOW",
2211   "HIGHADJ",
2212   "MIPS_JMPADDR",
2213   "SECTION",
2214   "REL32",
2215   "RESERVED1",
2216   "MIPS_JMPADDR16",
2217   "DIR64",
2218   "HIGH3ADJ",
2219   "UNKNOWN",   /* MUST be last.  */
2220 };
2221
2222 static bfd_boolean
2223 pe_print_reloc (bfd * abfd, void * vfile)
2224 {
2225   FILE *file = (FILE *) vfile;
2226   bfd_byte *data = 0;
2227   asection *section = bfd_get_section_by_name (abfd, ".reloc");
2228   bfd_byte *p, *end;
2229
2230   if (section == NULL || section->size == 0 || !(section->flags & SEC_HAS_CONTENTS))
2231     return TRUE;
2232
2233   fprintf (file,
2234            _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2235
2236   if (! bfd_malloc_and_get_section (abfd, section, &data))
2237     {
2238       if (data != NULL)
2239         free (data);
2240       return FALSE;
2241     }
2242
2243   p = data;
2244   end = data + section->size;
2245   while (p + 8 <= end)
2246     {
2247       int j;
2248       bfd_vma virtual_address;
2249       unsigned long number, size;
2250       bfd_byte *chunk_end;
2251
2252       /* The .reloc section is a sequence of blocks, with a header consisting
2253          of two 32 bit quantities, followed by a number of 16 bit entries.  */
2254       virtual_address = bfd_get_32 (abfd, p);
2255       size = bfd_get_32 (abfd, p + 4);
2256       p += 8;
2257       number = (size - 8) / 2;
2258
2259       if (size == 0)
2260         break;
2261
2262       fprintf (file,
2263                /* xgettext:c-format */
2264                _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2265                (unsigned long) virtual_address, size, size, number);
2266
2267       chunk_end = p - 8 + size;
2268       if (chunk_end > end)
2269         chunk_end = end;
2270       j = 0;
2271       while (p + 2 <= chunk_end)
2272         {
2273           unsigned short e = bfd_get_16 (abfd, p);
2274           unsigned int t = (e & 0xF000) >> 12;
2275           int off = e & 0x0FFF;
2276
2277           if (t >= sizeof (tbl) / sizeof (tbl[0]))
2278             t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
2279
2280           fprintf (file,
2281                    /* xgettext:c-format */
2282                    _("\treloc %4d offset %4x [%4lx] %s"),
2283                    j, off, (unsigned long) (off + virtual_address), tbl[t]);
2284
2285           p += 2;
2286           j++;
2287
2288           /* HIGHADJ takes an argument, - the next record *is* the
2289              low 16 bits of addend.  */
2290           if (t == IMAGE_REL_BASED_HIGHADJ && p + 2 <= chunk_end)
2291             {
2292               fprintf (file, " (%4x)", (unsigned int) bfd_get_16 (abfd, p));
2293               p += 2;
2294               j++;
2295             }
2296
2297           fprintf (file, "\n");
2298         }
2299     }
2300
2301   free (data);
2302
2303   return TRUE;
2304 }
2305 \f
2306 /* A data structure describing the regions of a .rsrc section.
2307    Some fields are filled in as the section is parsed.  */
2308
2309 typedef struct rsrc_regions
2310 {
2311   bfd_byte * section_start;
2312   bfd_byte * section_end;
2313   bfd_byte * strings_start;
2314   bfd_byte * resource_start;
2315 } rsrc_regions;
2316
2317 static bfd_byte *
2318 rsrc_print_resource_directory (FILE * , bfd *, unsigned int, bfd_byte *,
2319                                rsrc_regions *, bfd_vma);
2320
2321 /* Print the resource entry at DATA, with the text indented by INDENT.
2322    Recusively calls rsrc_print_resource_directory to print the contents
2323    of directory entries.
2324    Returns the address of the end of the data associated with the entry
2325    or section_end + 1 upon failure.  */
2326
2327 static bfd_byte *
2328 rsrc_print_resource_entries (FILE *         file,
2329                              bfd *          abfd,
2330                              unsigned int   indent,
2331                              bfd_boolean    is_name,
2332                              bfd_byte *     data,
2333                              rsrc_regions * regions,
2334                              bfd_vma        rva_bias)
2335 {
2336   unsigned long entry, addr, size;
2337   bfd_byte * leaf;
2338
2339   if (data + 8 >= regions->section_end)
2340     return regions->section_end + 1;
2341
2342   /* xgettext:c-format */
2343   fprintf (file, _("%03x %*.s Entry: "), (int)(data - regions->section_start), indent, " ");
2344
2345   entry = (unsigned long) bfd_get_32 (abfd, data);
2346   if (is_name)
2347     {
2348       bfd_byte * name;
2349
2350       /* Note - the documentation says that this field is an RVA value
2351          but windres appears to produce a section relative offset with
2352          the top bit set.  Support both styles for now.  */
2353       if (HighBitSet (entry))
2354         name = regions->section_start + WithoutHighBit (entry);
2355       else
2356         name = regions->section_start + entry - rva_bias;
2357
2358       if (name + 2 < regions->section_end && name > regions->section_start)
2359         {
2360           unsigned int len;
2361
2362           if (regions->strings_start == NULL)
2363             regions->strings_start = name;
2364
2365           len = bfd_get_16 (abfd, name);
2366
2367           fprintf (file, _("name: [val: %08lx len %d]: "), entry, len);
2368
2369           if (name + 2 + len * 2 < regions->section_end)
2370             {
2371               /* This strange loop is to cope with multibyte characters.  */
2372               while (len --)
2373                 {
2374                   char c;
2375
2376                   name += 2;
2377                   c = * name;
2378                   /* Avoid printing control characters.  */
2379                   if (c > 0 && c < 32)
2380                     fprintf (file, "^%c", c + 64);
2381                   else
2382                     fprintf (file, "%.1s", name);
2383                 }
2384             }
2385           else
2386             {
2387               fprintf (file, _("<corrupt string length: %#x>\n"), len);
2388               /* PR binutils/17512: Do not try to continue decoding a
2389                  corrupted resource section.  It is likely to end up with
2390                  reams of extraneous output.  FIXME: We could probably
2391                  continue if we disable the printing of strings...  */
2392               return regions->section_end + 1;
2393             }
2394         }
2395       else
2396         {
2397           fprintf (file, _("<corrupt string offset: %#lx>\n"), entry);
2398           return regions->section_end + 1;
2399         }
2400     }
2401   else
2402     fprintf (file, _("ID: %#08lx"), entry);
2403
2404   entry = (long) bfd_get_32 (abfd, data + 4);
2405   fprintf (file, _(", Value: %#08lx\n"), entry);
2406
2407   if (HighBitSet  (entry))
2408     {
2409       data = regions->section_start + WithoutHighBit (entry);
2410       if (data <= regions->section_start || data > regions->section_end)
2411         return regions->section_end + 1;
2412
2413       /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2414          in the resource table.  We need some way to detect this.  */
2415       return rsrc_print_resource_directory (file, abfd, indent + 1, data,
2416                                             regions, rva_bias);
2417     }
2418
2419   leaf = regions->section_start + entry;
2420
2421   if (leaf + 16 >= regions->section_end
2422       /* PR 17512: file: 055dff7e.  */
2423       || leaf < regions->section_start)
2424     return regions->section_end + 1;
2425
2426   /* xgettext:c-format */
2427   fprintf (file, _("%03x %*.s  Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2428            (int) (entry), indent, " ",
2429            addr = (long) bfd_get_32 (abfd, leaf),
2430            size = (long) bfd_get_32 (abfd, leaf + 4),
2431            (int) bfd_get_32 (abfd, leaf + 8));
2432
2433   /* Check that the reserved entry is 0.  */
2434   if (bfd_get_32 (abfd, leaf + 12) != 0
2435       /* And that the data address/size is valid too.  */
2436       || (regions->section_start + (addr - rva_bias) + size > regions->section_end))
2437     return regions->section_end + 1;
2438
2439   if (regions->resource_start == NULL)
2440     regions->resource_start = regions->section_start + (addr - rva_bias);
2441
2442   return regions->section_start + (addr - rva_bias) + size;
2443 }
2444
2445 #define max(a,b) ((a) > (b) ? (a) : (b))
2446 #define min(a,b) ((a) < (b) ? (a) : (b))
2447
2448 static bfd_byte *
2449 rsrc_print_resource_directory (FILE *         file,
2450                                bfd *          abfd,
2451                                unsigned int   indent,
2452                                bfd_byte *     data,
2453                                rsrc_regions * regions,
2454                                bfd_vma        rva_bias)
2455 {
2456   unsigned int num_names, num_ids;
2457   bfd_byte * highest_data = data;
2458
2459   if (data + 16 >= regions->section_end)
2460     return regions->section_end + 1;
2461
2462   fprintf (file, "%03x %*.s ", (int)(data - regions->section_start), indent, " ");
2463   switch (indent)
2464     {
2465     case 0: fprintf (file, "Type"); break;
2466     case 2: fprintf (file, "Name"); break;
2467     case 4: fprintf (file, "Language"); break;
2468     default:
2469       fprintf (file, _("<unknown directory type: %d>\n"), indent);
2470       /* FIXME: For now we end the printing here.  If in the
2471          future more directory types are added to the RSRC spec
2472          then we will need to change this.  */
2473       return regions->section_end + 1;
2474     }
2475
2476   /* xgettext:c-format */
2477   fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2478            (int) bfd_get_32 (abfd, data),
2479            (long) bfd_get_32 (abfd, data + 4),
2480            (int)  bfd_get_16 (abfd, data + 8),
2481            (int)  bfd_get_16 (abfd, data + 10),
2482            num_names = (int) bfd_get_16 (abfd, data + 12),
2483            num_ids =   (int) bfd_get_16 (abfd, data + 14));
2484   data += 16;
2485
2486   while (num_names --)
2487     {
2488       bfd_byte * entry_end;
2489
2490       entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE,
2491                                                data, regions, rva_bias);
2492       data += 8;
2493       highest_data = max (highest_data, entry_end);
2494       if (entry_end >= regions->section_end)
2495         return entry_end;
2496     }
2497
2498   while (num_ids --)
2499     {
2500       bfd_byte * entry_end;
2501
2502       entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE,
2503                                                data, regions, rva_bias);
2504       data += 8;
2505       highest_data = max (highest_data, entry_end);
2506       if (entry_end >= regions->section_end)
2507         return entry_end;
2508     }
2509
2510   return max (highest_data, data);
2511 }
2512
2513 /* Display the contents of a .rsrc section.  We do not try to
2514    reproduce the resources, windres does that.  Instead we dump
2515    the tables in a human readable format.  */
2516
2517 static bfd_boolean
2518 rsrc_print_section (bfd * abfd, void * vfile)
2519 {
2520   bfd_vma rva_bias;
2521   pe_data_type * pe;
2522   FILE * file = (FILE *) vfile;
2523   bfd_size_type datasize;
2524   asection * section;
2525   bfd_byte * data;
2526   rsrc_regions regions;
2527
2528   pe = pe_data (abfd);
2529   if (pe == NULL)
2530     return TRUE;
2531
2532   section = bfd_get_section_by_name (abfd, ".rsrc");
2533   if (section == NULL)
2534     return TRUE;
2535   if (!(section->flags & SEC_HAS_CONTENTS))
2536     return TRUE;
2537
2538   datasize = section->size;
2539   if (datasize == 0)
2540     return TRUE;
2541
2542   rva_bias = section->vma - pe->pe_opthdr.ImageBase;
2543
2544   if (! bfd_malloc_and_get_section (abfd, section, & data))
2545     {
2546       if (data != NULL)
2547         free (data);
2548       return FALSE;
2549     }
2550
2551   regions.section_start = data;
2552   regions.section_end = data + datasize;
2553   regions.strings_start = NULL;
2554   regions.resource_start = NULL;
2555
2556   fflush (file);
2557   fprintf (file, "\nThe .rsrc Resource Directory section:\n");
2558
2559   while (data < regions.section_end)
2560     {
2561       bfd_byte * p = data;
2562
2563       data = rsrc_print_resource_directory (file, abfd, 0, data, & regions, rva_bias);
2564
2565       if (data == regions.section_end + 1)
2566         fprintf (file, _("Corrupt .rsrc section detected!\n"));
2567       else
2568         {
2569           /* Align data before continuing.  */
2570           int align = (1 << section->alignment_power) - 1;
2571
2572           data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align);
2573           rva_bias += data - p;
2574
2575           /* For reasons that are unclear .rsrc sections are sometimes created
2576              aligned to a 1^3 boundary even when their alignment is set at
2577              1^2.  Catch that case here before we issue a spurious warning
2578              message.  */
2579           if (data == (regions.section_end - 4))
2580             data = regions.section_end;
2581           else if (data < regions.section_end)
2582             {
2583               /* If the extra data is all zeros then do not complain.
2584                  This is just padding so that the section meets the
2585                  page size requirements.  */
2586               while (++ data < regions.section_end)
2587                 if (*data != 0)
2588                   break;
2589               if (data < regions.section_end)
2590                 fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2591             }
2592         }
2593     }
2594
2595   if (regions.strings_start != NULL)
2596     fprintf (file, _(" String table starts at offset: %#03x\n"),
2597              (int) (regions.strings_start - regions.section_start));
2598   if (regions.resource_start != NULL)
2599     fprintf (file, _(" Resources start at offset: %#03x\n"),
2600              (int) (regions.resource_start - regions.section_start));
2601
2602   free (regions.section_start);
2603   return TRUE;
2604 }
2605
2606 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2607
2608 static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] =
2609 {
2610   "Unknown",
2611   "COFF",
2612   "CodeView",
2613   "FPO",
2614   "Misc",
2615   "Exception",
2616   "Fixup",
2617   "OMAP-to-SRC",
2618   "OMAP-from-SRC",
2619   "Borland",
2620   "Reserved",
2621   "CLSID",
2622 };
2623
2624 static bfd_boolean
2625 pe_print_debugdata (bfd * abfd, void * vfile)
2626 {
2627   FILE *file = (FILE *) vfile;
2628   pe_data_type *pe = pe_data (abfd);
2629   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
2630   asection *section;
2631   bfd_byte *data = 0;
2632   bfd_size_type dataoff;
2633   unsigned int i;
2634
2635   bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
2636   bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
2637
2638   if (size == 0)
2639     return TRUE;
2640
2641   addr += extra->ImageBase;
2642   for (section = abfd->sections; section != NULL; section = section->next)
2643     {
2644       if ((addr >= section->vma) && (addr < (section->vma + section->size)))
2645         break;
2646     }
2647
2648   if (section == NULL)
2649     {
2650       fprintf (file,
2651                _("\nThere is a debug directory, but the section containing it could not be found\n"));
2652       return TRUE;
2653     }
2654   else if (!(section->flags & SEC_HAS_CONTENTS))
2655     {
2656       fprintf (file,
2657                _("\nThere is a debug directory in %s, but that section has no contents\n"),
2658                section->name);
2659       return TRUE;
2660     }
2661   else if (section->size < size)
2662     {
2663       fprintf (file,
2664                _("\nError: section %s contains the debug data starting address but it is too small\n"),
2665                section->name);
2666       return FALSE;
2667     }
2668
2669   fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2670            section->name, (unsigned long) addr);
2671
2672   dataoff = addr - section->vma;
2673
2674   if (size > (section->size - dataoff))
2675     {
2676       fprintf (file, _("The debug data size field in the data directory is too big for the section"));
2677       return FALSE;
2678     }
2679
2680   fprintf (file,
2681            _("Type                Size     Rva      Offset\n"));
2682
2683   /* Read the whole section.  */
2684   if (!bfd_malloc_and_get_section (abfd, section, &data))
2685     {
2686       if (data != NULL)
2687         free (data);
2688       return FALSE;
2689     }
2690
2691   for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2692     {
2693       const char *type_name;
2694       struct external_IMAGE_DEBUG_DIRECTORY *ext
2695         = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
2696       struct internal_IMAGE_DEBUG_DIRECTORY idd;
2697
2698       _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
2699
2700       if ((idd.Type) >= IMAGE_NUMBEROF_DEBUG_TYPES)
2701         type_name = debug_type_names[0];
2702       else
2703         type_name = debug_type_names[idd.Type];
2704
2705       fprintf (file, " %2ld  %14s %08lx %08lx %08lx\n",
2706                idd.Type, type_name, idd.SizeOfData,
2707                idd.AddressOfRawData, idd.PointerToRawData);
2708
2709       if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
2710         {
2711           char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1];
2712           /* PR 17512: file: 065-29434-0.001:0.1
2713              We need to use a 32-bit aligned buffer
2714              to safely read in a codeview record.  */
2715           char buffer[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO);
2716
2717           CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
2718
2719           /* The debug entry doesn't have to have to be in a section,
2720              in which case AddressOfRawData is 0, so always use PointerToRawData.  */
2721           if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData,
2722                                                idd.SizeOfData, cvinfo))
2723             continue;
2724
2725           for (i = 0; i < cvinfo->SignatureLength; i++)
2726             sprintf (&signature[i*2], "%02x", cvinfo->Signature[i] & 0xff);
2727
2728           /* xgettext:c-format */
2729           fprintf (file, _("(format %c%c%c%c signature %s age %ld)\n"),
2730                    buffer[0], buffer[1], buffer[2], buffer[3],
2731                    signature, cvinfo->Age);
2732         }
2733     }
2734
2735   if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0)
2736     fprintf (file,
2737             _("The debug directory size is not a multiple of the debug directory entry size\n"));
2738
2739   return TRUE;
2740 }
2741
2742 /* Print out the program headers.  */
2743
2744 bfd_boolean
2745 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2746 {
2747   FILE *file = (FILE *) vfile;
2748   int j;
2749   pe_data_type *pe = pe_data (abfd);
2750   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2751   const char *subsystem_name = NULL;
2752   const char *name;
2753
2754   /* The MS dumpbin program reportedly ands with 0xff0f before
2755      printing the characteristics field.  Not sure why.  No reason to
2756      emulate it here.  */
2757   fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2758 #undef PF
2759 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2760   PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2761   PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2762   PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2763   PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2764   PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2765   PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2766   PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2767   PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2768   PF (IMAGE_FILE_SYSTEM, "system file");
2769   PF (IMAGE_FILE_DLL, "DLL");
2770   PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2771 #undef PF
2772
2773   /* ctime implies '\n'.  */
2774   {
2775     time_t t = pe->coff.timestamp;
2776     fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2777   }
2778
2779 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2780 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2781 #endif
2782 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2783 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2784 #endif
2785 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2786 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2787 #endif
2788
2789   switch (i->Magic)
2790     {
2791     case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2792       name = "PE32";
2793       break;
2794     case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2795       name = "PE32+";
2796       break;
2797     case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2798       name = "ROM";
2799       break;
2800     default:
2801       name = NULL;
2802       break;
2803     }
2804   fprintf (file, "Magic\t\t\t%04x", i->Magic);
2805   if (name)
2806     fprintf (file, "\t(%s)",name);
2807   fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2808   fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2809   fprintf (file, "SizeOfCode\t\t");
2810   bfd_fprintf_vma (abfd, file, i->SizeOfCode);
2811   fprintf (file, "\nSizeOfInitializedData\t");
2812   bfd_fprintf_vma (abfd, file, i->SizeOfInitializedData);
2813   fprintf (file, "\nSizeOfUninitializedData\t");
2814   bfd_fprintf_vma (abfd, file, i->SizeOfUninitializedData);
2815   fprintf (file, "\nAddressOfEntryPoint\t");
2816   bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2817   fprintf (file, "\nBaseOfCode\t\t");
2818   bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2819 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2820   /* PE32+ does not have BaseOfData member!  */
2821   fprintf (file, "\nBaseOfData\t\t");
2822   bfd_fprintf_vma (abfd, file, i->BaseOfData);
2823 #endif
2824
2825   fprintf (file, "\nImageBase\t\t");
2826   bfd_fprintf_vma (abfd, file, i->ImageBase);
2827   fprintf (file, "\nSectionAlignment\t%08x\n", i->SectionAlignment);
2828   fprintf (file, "FileAlignment\t\t%08x\n", i->FileAlignment);
2829   fprintf (file, "MajorOSystemVersion\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%08x\n", i->Reserved1);
2836   fprintf (file, "SizeOfImage\t\t%08x\n", i->SizeOfImage);
2837   fprintf (file, "SizeOfHeaders\t\t%08x\n", i->SizeOfHeaders);
2838   fprintf (file, "CheckSum\t\t%08x\n", 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 }