bfd/peXXigen.c

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