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)
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 (datasize > section->size - dataoff)
1665         {
1666           fprintf (file,
1667                    _("\nThere is an export table in %s, but it does not fit into that section\n"),
1668                    section->name);
1669           return TRUE;
1670         }
1671     }
1672
1673   /* PR 17512: Handle corrupt PE binaries.  */
1674   if (datasize < 36)
1675     {
1676       fprintf (file,
1677                /* xgettext:c-format */
1678                _("\nThere is an export table in %s, but it is too small (%d)\n"),
1679                section->name, (int) datasize);
1680       return TRUE;
1681     }
1682
1683   /* xgettext:c-format */
1684   fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1685            section->name, (unsigned long) addr);
1686
1687   data = (bfd_byte *) bfd_malloc (datasize);
1688   if (data == NULL)
1689     return FALSE;
1690
1691   if (! bfd_get_section_contents (abfd, section, data,
1692                                   (file_ptr) dataoff, datasize))
1693     return FALSE;
1694
1695   /* Go get Export Directory Table.  */
1696   edt.export_flags   = bfd_get_32 (abfd, data +  0);
1697   edt.time_stamp     = bfd_get_32 (abfd, data +  4);
1698   edt.major_ver      = bfd_get_16 (abfd, data +  8);
1699   edt.minor_ver      = bfd_get_16 (abfd, data + 10);
1700   edt.name           = bfd_get_32 (abfd, data + 12);
1701   edt.base           = bfd_get_32 (abfd, data + 16);
1702   edt.num_functions  = bfd_get_32 (abfd, data + 20);
1703   edt.num_names      = bfd_get_32 (abfd, data + 24);
1704   edt.eat_addr       = bfd_get_32 (abfd, data + 28);
1705   edt.npt_addr       = bfd_get_32 (abfd, data + 32);
1706   edt.ot_addr        = bfd_get_32 (abfd, data + 36);
1707
1708   adj = section->vma - extra->ImageBase + dataoff;
1709
1710   /* Dump the EDT first.  */
1711   fprintf (file,
1712            _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1713            section->name);
1714
1715   fprintf (file,
1716            _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1717
1718   fprintf (file,
1719            _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1720
1721   fprintf (file,
1722            /* xgettext:c-format */
1723            _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1724
1725   fprintf (file,
1726            _("Name \t\t\t\t"));
1727   bfd_fprintf_vma (abfd, file, edt.name);
1728
1729   if ((edt.name >= adj) && (edt.name < adj + datasize))
1730     fprintf (file, " %.*s\n",
1731              (int) (datasize - (edt.name - adj)),
1732              data + edt.name - adj);
1733   else
1734     fprintf (file, "(outside .edata section)\n");
1735
1736   fprintf (file,
1737            _("Ordinal Base \t\t\t%ld\n"), edt.base);
1738
1739   fprintf (file,
1740            _("Number in:\n"));
1741
1742   fprintf (file,
1743            _("\tExport Address Table \t\t%08lx\n"),
1744            edt.num_functions);
1745
1746   fprintf (file,
1747            _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1748
1749   fprintf (file,
1750            _("Table Addresses\n"));
1751
1752   fprintf (file,
1753            _("\tExport Address Table \t\t"));
1754   bfd_fprintf_vma (abfd, file, edt.eat_addr);
1755   fprintf (file, "\n");
1756
1757   fprintf (file,
1758            _("\tName Pointer Table \t\t"));
1759   bfd_fprintf_vma (abfd, file, edt.npt_addr);
1760   fprintf (file, "\n");
1761
1762   fprintf (file,
1763            _("\tOrdinal Table \t\t\t"));
1764   bfd_fprintf_vma (abfd, file, edt.ot_addr);
1765   fprintf (file, "\n");
1766
1767   /* The next table to find is the Export Address Table. It's basically
1768      a list of pointers that either locate a function in this dll, or
1769      forward the call to another dll. Something like:
1770       typedef union
1771       {
1772         long export_rva;
1773         long forwarder_rva;
1774       } export_address_table_entry;  */
1775
1776   fprintf (file,
1777           _("\nExport Address Table -- Ordinal Base %ld\n"),
1778           edt.base);
1779
1780   /* PR 17512: Handle corrupt PE binaries.  */
1781   if (edt.eat_addr + (edt.num_functions * 4) - adj >= datasize
1782       /* PR 17512: file: 092b1829 */
1783       || (edt.num_functions * 4) < edt.num_functions
1784       /* PR 17512 file: 140-165018-0.004.  */
1785       || data + edt.eat_addr - adj < data)
1786     fprintf (file, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1787              (long) edt.eat_addr,
1788              (long) edt.num_functions);
1789   else for (i = 0; i < edt.num_functions; ++i)
1790     {
1791       bfd_vma eat_member = bfd_get_32 (abfd,
1792                                        data + edt.eat_addr + (i * 4) - adj);
1793       if (eat_member == 0)
1794         continue;
1795
1796       if (eat_member - adj <= datasize)
1797         {
1798           /* This rva is to a name (forwarding function) in our section.  */
1799           /* Should locate a function descriptor.  */
1800           fprintf (file,
1801                    "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1802                    (long) i,
1803                    (long) (i + edt.base),
1804                    (unsigned long) eat_member,
1805                    _("Forwarder RVA"),
1806                    (int)(datasize - (eat_member - adj)),
1807                    data + eat_member - adj);
1808         }
1809       else
1810         {
1811           /* Should locate a function descriptor in the reldata section.  */
1812           fprintf (file,
1813                    "\t[%4ld] +base[%4ld] %04lx %s\n",
1814                    (long) i,
1815                    (long) (i + edt.base),
1816                    (unsigned long) eat_member,
1817                    _("Export RVA"));
1818         }
1819     }
1820
1821   /* The Export Name Pointer Table is paired with the Export Ordinal Table.  */
1822   /* Dump them in parallel for clarity.  */
1823   fprintf (file,
1824            _("\n[Ordinal/Name Pointer] Table\n"));
1825
1826   /* PR 17512: Handle corrupt PE binaries.  */
1827   if (edt.npt_addr + (edt.num_names * 4) - adj >= datasize
1828       /* PR 17512: file: bb68816e.  */
1829       || edt.num_names * 4 < edt.num_names
1830       || (data + edt.npt_addr - adj) < data)
1831     /* xgettext:c-format */
1832     fprintf (file, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1833              (long) edt.npt_addr,
1834              (long) edt.num_names);
1835   /* PR 17512: file: 140-147171-0.004.  */
1836   else if (edt.ot_addr + (edt.num_names * 2) - adj >= datasize
1837            || data + edt.ot_addr - adj < data)
1838     /* xgettext:c-format */
1839     fprintf (file, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1840              (long) edt.ot_addr,
1841              (long) edt.num_names);
1842   else for (i = 0; i < edt.num_names; ++i)
1843     {
1844       bfd_vma  name_ptr;
1845       bfd_vma  ord;
1846
1847       ord = bfd_get_16 (abfd, data + edt.ot_addr + (i * 2) - adj);
1848       name_ptr = bfd_get_32 (abfd, data + edt.npt_addr + (i * 4) - adj);
1849
1850       if ((name_ptr - adj) >= datasize)
1851         {
1852           /* xgettext:c-format */
1853           fprintf (file, _("\t[%4ld] <corrupt offset: %lx>\n"),
1854                    (long) ord, (long) name_ptr);
1855         }
1856       else
1857         {
1858           char * name = (char *) data + name_ptr - adj;
1859
1860           fprintf (file, "\t[%4ld] %.*s\n", (long) ord,
1861                    (int)((char *)(data + datasize) - name), name);
1862         }
1863     }
1864
1865   free (data);
1866
1867   return TRUE;
1868 }
1869
1870 /* This really is architecture dependent.  On IA-64, a .pdata entry
1871    consists of three dwords containing relative virtual addresses that
1872    specify the start and end address of the code range the entry
1873    covers and the address of the corresponding unwind info data.
1874
1875    On ARM and SH-4, a compressed PDATA structure is used :
1876    _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1877    _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1878    See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1879
1880    This is the version for uncompressed data.  */
1881
1882 static bfd_boolean
1883 pe_print_pdata (bfd * abfd, void * vfile)
1884 {
1885 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1886 # define PDATA_ROW_SIZE (3 * 8)
1887 #else
1888 # define PDATA_ROW_SIZE (5 * 4)
1889 #endif
1890   FILE *file = (FILE *) vfile;
1891   bfd_byte *data = 0;
1892   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1893   bfd_size_type datasize = 0;
1894   bfd_size_type i;
1895   bfd_size_type start, stop;
1896   int onaline = PDATA_ROW_SIZE;
1897
1898   if (section == NULL
1899       || coff_section_data (abfd, section) == NULL
1900       || pei_section_data (abfd, section) == NULL)
1901     return TRUE;
1902
1903   stop = pei_section_data (abfd, section)->virt_size;
1904   if ((stop % onaline) != 0)
1905     fprintf (file,
1906              /* xgettext:c-format */
1907              _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1908              (long) stop, onaline);
1909
1910   fprintf (file,
1911            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1912 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1913   fprintf (file,
1914            _(" vma:\t\t\tBegin Address    End Address      Unwind Info\n"));
1915 #else
1916   fprintf (file, _("\
1917  vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n\
1918      \t\tAddress  Address  Handler  Data     Address    Mask\n"));
1919 #endif
1920
1921   datasize = section->size;
1922   if (datasize == 0)
1923     return TRUE;
1924
1925   /* PR 17512: file: 002-193900-0.004.  */
1926   if (datasize < stop)
1927     {
1928       /* xgettext:c-format */
1929       fprintf (file, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1930                (long) stop, (long) datasize);
1931       return FALSE;
1932     }
1933
1934   if (! bfd_malloc_and_get_section (abfd, section, &data))
1935     {
1936       if (data != NULL)
1937         free (data);
1938       return FALSE;
1939     }
1940
1941   start = 0;
1942
1943   for (i = start; i < stop; i += onaline)
1944     {
1945       bfd_vma begin_addr;
1946       bfd_vma end_addr;
1947       bfd_vma eh_handler;
1948       bfd_vma eh_data;
1949       bfd_vma prolog_end_addr;
1950 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1951       int em_data;
1952 #endif
1953
1954       if (i + PDATA_ROW_SIZE > stop)
1955         break;
1956
1957       begin_addr      = GET_PDATA_ENTRY (abfd, data + i     );
1958       end_addr        = GET_PDATA_ENTRY (abfd, data + i +  4);
1959       eh_handler      = GET_PDATA_ENTRY (abfd, data + i +  8);
1960       eh_data         = GET_PDATA_ENTRY (abfd, data + i + 12);
1961       prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1962
1963       if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1964           && eh_data == 0 && prolog_end_addr == 0)
1965         /* We are probably into the padding of the section now.  */
1966         break;
1967
1968 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1969       em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1970 #endif
1971       eh_handler &= ~(bfd_vma) 0x3;
1972       prolog_end_addr &= ~(bfd_vma) 0x3;
1973
1974       fputc (' ', file);
1975       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1976       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1977       bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1978       bfd_fprintf_vma (abfd, file, eh_handler);
1979 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1980       fputc (' ', file);
1981       bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1982       bfd_fprintf_vma (abfd, file, prolog_end_addr);
1983       fprintf (file, "   %x", em_data);
1984 #endif
1985
1986 #ifdef POWERPC_LE_PE
1987       if (eh_handler == 0 && eh_data != 0)
1988         {
1989           /* Special bits here, although the meaning may be a little
1990              mysterious. The only one I know for sure is 0x03
1991              Code Significance
1992              0x00 None
1993              0x01 Register Save Millicode
1994              0x02 Register Restore Millicode
1995              0x03 Glue Code Sequence.  */
1996           switch (eh_data)
1997             {
1998             case 0x01:
1999               fprintf (file, _(" Register save millicode"));
2000               break;
2001             case 0x02:
2002               fprintf (file, _(" Register restore millicode"));
2003               break;
2004             case 0x03:
2005               fprintf (file, _(" Glue code sequence"));
2006               break;
2007             default:
2008               break;
2009             }
2010         }
2011 #endif
2012       fprintf (file, "\n");
2013     }
2014
2015   free (data);
2016
2017   return TRUE;
2018 #undef PDATA_ROW_SIZE
2019 }
2020
2021 typedef struct sym_cache
2022 {
2023   int        symcount;
2024   asymbol ** syms;
2025 } sym_cache;
2026
2027 static asymbol **
2028 slurp_symtab (bfd *abfd, sym_cache *psc)
2029 {
2030   asymbol ** sy = NULL;
2031   long storage;
2032
2033   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
2034     {
2035       psc->symcount = 0;
2036       return NULL;
2037     }
2038
2039   storage = bfd_get_symtab_upper_bound (abfd);
2040   if (storage < 0)
2041     return NULL;
2042   if (storage)
2043     {
2044       sy = (asymbol **) bfd_malloc (storage);
2045       if (sy == NULL)
2046         return NULL;
2047     }
2048
2049   psc->symcount = bfd_canonicalize_symtab (abfd, sy);
2050   if (psc->symcount < 0)
2051     return NULL;
2052   return sy;
2053 }
2054
2055 static const char *
2056 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
2057 {
2058   int i;
2059
2060   if (psc->syms == 0)
2061     psc->syms = slurp_symtab (abfd, psc);
2062
2063   for (i = 0; i < psc->symcount; i++)
2064     {
2065       if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
2066         return psc->syms[i]->name;
2067     }
2068
2069   return NULL;
2070 }
2071
2072 static void
2073 cleanup_syms (sym_cache *psc)
2074 {
2075   psc->symcount = 0;
2076   free (psc->syms);
2077   psc->syms = NULL;
2078 }
2079
2080 /* This is the version for "compressed" pdata.  */
2081
2082 bfd_boolean
2083 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
2084 {
2085 # define PDATA_ROW_SIZE (2 * 4)
2086   FILE *file = (FILE *) vfile;
2087   bfd_byte *data = NULL;
2088   asection *section = bfd_get_section_by_name (abfd, ".pdata");
2089   bfd_size_type datasize = 0;
2090   bfd_size_type i;
2091   bfd_size_type start, stop;
2092   int onaline = PDATA_ROW_SIZE;
2093   struct sym_cache cache = {0, 0} ;
2094
2095   if (section == NULL
2096       || coff_section_data (abfd, section) == NULL
2097       || pei_section_data (abfd, section) == NULL)
2098     return TRUE;
2099
2100   stop = pei_section_data (abfd, section)->virt_size;
2101   if ((stop % onaline) != 0)
2102     fprintf (file,
2103              /* xgettext:c-format */
2104              _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2105              (long) stop, onaline);
2106
2107   fprintf (file,
2108            _("\nThe Function Table (interpreted .pdata section contents)\n"));
2109
2110   fprintf (file, _("\
2111  vma:\t\tBegin    Prolog   Function Flags    Exception EH\n\
2112      \t\tAddress  Length   Length   32b exc  Handler   Data\n"));
2113
2114   datasize = section->size;
2115   if (datasize == 0)
2116     return TRUE;
2117
2118   if (! bfd_malloc_and_get_section (abfd, section, &data))
2119     {
2120       if (data != NULL)
2121         free (data);
2122       return FALSE;
2123     }
2124
2125   start = 0;
2126
2127   for (i = start; i < stop; i += onaline)
2128     {
2129       bfd_vma begin_addr;
2130       bfd_vma other_data;
2131       bfd_vma prolog_length, function_length;
2132       int flag32bit, exception_flag;
2133       asection *tsection;
2134
2135       if (i + PDATA_ROW_SIZE > stop)
2136         break;
2137
2138       begin_addr = GET_PDATA_ENTRY (abfd, data + i     );
2139       other_data = GET_PDATA_ENTRY (abfd, data + i +  4);
2140
2141       if (begin_addr == 0 && other_data == 0)
2142         /* We are probably into the padding of the section now.  */
2143         break;
2144
2145       prolog_length = (other_data & 0x000000FF);
2146       function_length = (other_data & 0x3FFFFF00) >> 8;
2147       flag32bit = (int)((other_data & 0x40000000) >> 30);
2148       exception_flag = (int)((other_data & 0x80000000) >> 31);
2149
2150       fputc (' ', file);
2151       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
2152       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
2153       bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
2154       bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
2155       fprintf (file, "%2d  %2d   ", flag32bit, exception_flag);
2156
2157       /* Get the exception handler's address and the data passed from the
2158          .text section. This is really the data that belongs with the .pdata
2159          but got "compressed" out for the ARM and SH4 architectures.  */
2160       tsection = bfd_get_section_by_name (abfd, ".text");
2161       if (tsection && coff_section_data (abfd, tsection)
2162           && pei_section_data (abfd, tsection))
2163         {
2164           bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
2165           bfd_byte *tdata;
2166
2167           tdata = (bfd_byte *) bfd_malloc (8);
2168           if (tdata)
2169             {
2170               if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
2171                 {
2172                   bfd_vma eh, eh_data;
2173
2174                   eh = bfd_get_32 (abfd, tdata);
2175                   eh_data = bfd_get_32 (abfd, tdata + 4);
2176                   fprintf (file, "%08x  ", (unsigned int) eh);
2177                   fprintf (file, "%08x", (unsigned int) eh_data);
2178                   if (eh != 0)
2179                     {
2180                       const char *s = my_symbol_for_address (abfd, eh, &cache);
2181
2182                       if (s)
2183                         fprintf (file, " (%s) ", s);
2184                     }
2185                 }
2186               free (tdata);
2187             }
2188         }
2189
2190       fprintf (file, "\n");
2191     }
2192
2193   free (data);
2194
2195   cleanup_syms (& cache);
2196
2197   return TRUE;
2198 #undef PDATA_ROW_SIZE
2199 }
2200
2201 \f
2202 #define IMAGE_REL_BASED_HIGHADJ 4
2203 static const char * const tbl[] =
2204 {
2205   "ABSOLUTE",
2206   "HIGH",
2207   "LOW",
2208   "HIGHLOW",
2209   "HIGHADJ",
2210   "MIPS_JMPADDR",
2211   "SECTION",
2212   "REL32",
2213   "RESERVED1",
2214   "MIPS_JMPADDR16",
2215   "DIR64",
2216   "HIGH3ADJ",
2217   "UNKNOWN",   /* MUST be last.  */
2218 };
2219
2220 static bfd_boolean
2221 pe_print_reloc (bfd * abfd, void * vfile)
2222 {
2223   FILE *file = (FILE *) vfile;
2224   bfd_byte *data = 0;
2225   asection *section = bfd_get_section_by_name (abfd, ".reloc");
2226   bfd_byte *p, *end;
2227
2228   if (section == NULL || section->size == 0 || !(section->flags & SEC_HAS_CONTENTS))
2229     return TRUE;
2230
2231   fprintf (file,
2232            _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2233
2234   if (! bfd_malloc_and_get_section (abfd, section, &data))
2235     {
2236       if (data != NULL)
2237         free (data);
2238       return FALSE;
2239     }
2240
2241   p = data;
2242   end = data + section->size;
2243   while (p + 8 <= end)
2244     {
2245       int j;
2246       bfd_vma virtual_address;
2247       unsigned long number, size;
2248       bfd_byte *chunk_end;
2249
2250       /* The .reloc section is a sequence of blocks, with a header consisting
2251          of two 32 bit quantities, followed by a number of 16 bit entries.  */
2252       virtual_address = bfd_get_32 (abfd, p);
2253       size = bfd_get_32 (abfd, p + 4);
2254       p += 8;
2255       number = (size - 8) / 2;
2256
2257       if (size == 0)
2258         break;
2259
2260       fprintf (file,
2261                /* xgettext:c-format */
2262                _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2263                (unsigned long) virtual_address, size, size, number);
2264
2265       chunk_end = p - 8 + size;
2266       if (chunk_end > end)
2267         chunk_end = end;
2268       j = 0;
2269       while (p + 2 <= chunk_end)
2270         {
2271           unsigned short e = bfd_get_16 (abfd, p);
2272           unsigned int t = (e & 0xF000) >> 12;
2273           int off = e & 0x0FFF;
2274
2275           if (t >= sizeof (tbl) / sizeof (tbl[0]))
2276             t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
2277
2278           fprintf (file,
2279                    /* xgettext:c-format */
2280                    _("\treloc %4d offset %4x [%4lx] %s"),
2281                    j, off, (unsigned long) (off + virtual_address), tbl[t]);
2282
2283           p += 2;
2284           j++;
2285
2286           /* HIGHADJ takes an argument, - the next record *is* the
2287              low 16 bits of addend.  */
2288           if (t == IMAGE_REL_BASED_HIGHADJ && p + 2 <= chunk_end)
2289             {
2290               fprintf (file, " (%4x)", (unsigned int) bfd_get_16 (abfd, p));
2291               p += 2;
2292               j++;
2293             }
2294
2295           fprintf (file, "\n");
2296         }
2297     }
2298
2299   free (data);
2300
2301   return TRUE;
2302 }
2303 \f
2304 /* A data structure describing the regions of a .rsrc section.
2305    Some fields are filled in as the section is parsed.  */
2306
2307 typedef struct rsrc_regions
2308 {
2309   bfd_byte * section_start;
2310   bfd_byte * section_end;
2311   bfd_byte * strings_start;
2312   bfd_byte * resource_start;
2313 } rsrc_regions;
2314
2315 static bfd_byte *
2316 rsrc_print_resource_directory (FILE * , bfd *, unsigned int, bfd_byte *,
2317                                rsrc_regions *, bfd_vma);
2318
2319 /* Print the resource entry at DATA, with the text indented by INDENT.
2320    Recusively calls rsrc_print_resource_directory to print the contents
2321    of directory entries.
2322    Returns the address of the end of the data associated with the entry
2323    or section_end + 1 upon failure.  */
2324
2325 static bfd_byte *
2326 rsrc_print_resource_entries (FILE *         file,
2327                              bfd *          abfd,
2328                              unsigned int   indent,
2329                              bfd_boolean    is_name,
2330                              bfd_byte *     data,
2331                              rsrc_regions * regions,
2332                              bfd_vma        rva_bias)
2333 {
2334   unsigned long entry, addr, size;
2335   bfd_byte * leaf;
2336
2337   if (data + 8 >= regions->section_end)
2338     return regions->section_end + 1;
2339
2340   /* xgettext:c-format */
2341   fprintf (file, _("%03x %*.s Entry: "), (int)(data - regions->section_start), indent, " ");
2342
2343   entry = (unsigned long) bfd_get_32 (abfd, data);
2344   if (is_name)
2345     {
2346       bfd_byte * name;
2347
2348       /* Note - the documentation says that this field is an RVA value
2349          but windres appears to produce a section relative offset with
2350          the top bit set.  Support both styles for now.  */
2351       if (HighBitSet (entry))
2352         name = regions->section_start + WithoutHighBit (entry);
2353       else
2354         name = regions->section_start + entry - rva_bias;
2355
2356       if (name + 2 < regions->section_end && name > regions->section_start)
2357         {
2358           unsigned int len;
2359
2360           if (regions->strings_start == NULL)
2361             regions->strings_start = name;
2362
2363           len = bfd_get_16 (abfd, name);
2364
2365           fprintf (file, _("name: [val: %08lx len %d]: "), entry, len);
2366
2367           if (name + 2 + len * 2 < regions->section_end)
2368             {
2369               /* This strange loop is to cope with multibyte characters.  */
2370               while (len --)
2371                 {
2372                   char c;
2373
2374                   name += 2;
2375                   c = * name;
2376                   /* Avoid printing control characters.  */
2377                   if (c > 0 && c < 32)
2378                     fprintf (file, "^%c", c + 64);
2379                   else
2380                     fprintf (file, "%.1s", name);
2381                 }
2382             }
2383           else
2384             {
2385               fprintf (file, _("<corrupt string length: %#x>\n"), len);
2386               /* PR binutils/17512: Do not try to continue decoding a
2387                  corrupted resource section.  It is likely to end up with
2388                  reams of extraneous output.  FIXME: We could probably
2389                  continue if we disable the printing of strings...  */
2390               return regions->section_end + 1;
2391             }
2392         }
2393       else
2394         {
2395           fprintf (file, _("<corrupt string offset: %#lx>\n"), entry);
2396           return regions->section_end + 1;
2397         }
2398     }
2399   else
2400     fprintf (file, _("ID: %#08lx"), entry);
2401
2402   entry = (long) bfd_get_32 (abfd, data + 4);
2403   fprintf (file, _(", Value: %#08lx\n"), entry);
2404
2405   if (HighBitSet  (entry))
2406     {
2407       data = regions->section_start + WithoutHighBit (entry);
2408       if (data <= regions->section_start || data > regions->section_end)
2409         return regions->section_end + 1;
2410
2411       /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2412          in the resource table.  We need some way to detect this.  */
2413       return rsrc_print_resource_directory (file, abfd, indent + 1, data,
2414                                             regions, rva_bias);
2415     }
2416
2417   leaf = regions->section_start + entry;
2418
2419   if (leaf + 16 >= regions->section_end
2420       /* PR 17512: file: 055dff7e.  */
2421       || leaf < regions->section_start)
2422     return regions->section_end + 1;
2423
2424   /* xgettext:c-format */
2425   fprintf (file, _("%03x %*.s  Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2426            (int) (entry), indent, " ",
2427            addr = (long) bfd_get_32 (abfd, leaf),
2428            size = (long) bfd_get_32 (abfd, leaf + 4),
2429            (int) bfd_get_32 (abfd, leaf + 8));
2430
2431   /* Check that the reserved entry is 0.  */
2432   if (bfd_get_32 (abfd, leaf + 12) != 0
2433       /* And that the data address/size is valid too.  */
2434       || (regions->section_start + (addr - rva_bias) + size > regions->section_end))
2435     return regions->section_end + 1;
2436
2437   if (regions->resource_start == NULL)
2438     regions->resource_start = regions->section_start + (addr - rva_bias);
2439
2440   return regions->section_start + (addr - rva_bias) + size;
2441 }
2442
2443 #define max(a,b) ((a) > (b) ? (a) : (b))
2444 #define min(a,b) ((a) < (b) ? (a) : (b))
2445
2446 static bfd_byte *
2447 rsrc_print_resource_directory (FILE *         file,
2448                                bfd *          abfd,
2449                                unsigned int   indent,
2450                                bfd_byte *     data,
2451                                rsrc_regions * regions,
2452                                bfd_vma        rva_bias)
2453 {
2454   unsigned int num_names, num_ids;
2455   bfd_byte * highest_data = data;
2456
2457   if (data + 16 >= regions->section_end)
2458     return regions->section_end + 1;
2459
2460   fprintf (file, "%03x %*.s ", (int)(data - regions->section_start), indent, " ");
2461   switch (indent)
2462     {
2463     case 0: fprintf (file, "Type"); break;
2464     case 2: fprintf (file, "Name"); break;
2465     case 4: fprintf (file, "Language"); break;
2466     default:
2467       fprintf (file, _("<unknown directory type: %d>\n"), indent);
2468       /* FIXME: For now we end the printing here.  If in the
2469          future more directory types are added to the RSRC spec
2470          then we will need to change this.  */
2471       return regions->section_end + 1;
2472     }
2473
2474   /* xgettext:c-format */
2475   fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2476            (int) bfd_get_32 (abfd, data),
2477            (long) bfd_get_32 (abfd, data + 4),
2478            (int)  bfd_get_16 (abfd, data + 8),
2479            (int)  bfd_get_16 (abfd, data + 10),
2480            num_names = (int) bfd_get_16 (abfd, data + 12),
2481            num_ids =   (int) bfd_get_16 (abfd, data + 14));
2482   data += 16;
2483
2484   while (num_names --)
2485     {
2486       bfd_byte * entry_end;
2487
2488       entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE,
2489                                                data, regions, rva_bias);
2490       data += 8;
2491       highest_data = max (highest_data, entry_end);
2492       if (entry_end >= regions->section_end)
2493         return entry_end;
2494     }
2495
2496   while (num_ids --)
2497     {
2498       bfd_byte * entry_end;
2499
2500       entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE,
2501                                                data, regions, rva_bias);
2502       data += 8;
2503       highest_data = max (highest_data, entry_end);
2504       if (entry_end >= regions->section_end)
2505         return entry_end;
2506     }
2507
2508   return max (highest_data, data);
2509 }
2510
2511 /* Display the contents of a .rsrc section.  We do not try to
2512    reproduce the resources, windres does that.  Instead we dump
2513    the tables in a human readable format.  */
2514
2515 static bfd_boolean
2516 rsrc_print_section (bfd * abfd, void * vfile)
2517 {
2518   bfd_vma rva_bias;
2519   pe_data_type * pe;
2520   FILE * file = (FILE *) vfile;
2521   bfd_size_type datasize;
2522   asection * section;
2523   bfd_byte * data;
2524   rsrc_regions regions;
2525
2526   pe = pe_data (abfd);
2527   if (pe == NULL)
2528     return TRUE;
2529
2530   section = bfd_get_section_by_name (abfd, ".rsrc");
2531   if (section == NULL)
2532     return TRUE;
2533   if (!(section->flags & SEC_HAS_CONTENTS))
2534     return TRUE;
2535
2536   datasize = section->size;
2537   if (datasize == 0)
2538     return TRUE;
2539
2540   rva_bias = section->vma - pe->pe_opthdr.ImageBase;
2541
2542   if (! bfd_malloc_and_get_section (abfd, section, & data))
2543     {
2544       if (data != NULL)
2545         free (data);
2546       return FALSE;
2547     }
2548
2549   regions.section_start = data;
2550   regions.section_end = data + datasize;
2551   regions.strings_start = NULL;
2552   regions.resource_start = NULL;
2553
2554   fflush (file);
2555   fprintf (file, "\nThe .rsrc Resource Directory section:\n");
2556
2557   while (data < regions.section_end)
2558     {
2559       bfd_byte * p = data;
2560
2561       data = rsrc_print_resource_directory (file, abfd, 0, data, & regions, rva_bias);
2562
2563       if (data == regions.section_end + 1)
2564         fprintf (file, _("Corrupt .rsrc section detected!\n"));
2565       else
2566         {
2567           /* Align data before continuing.  */
2568           int align = (1 << section->alignment_power) - 1;
2569
2570           data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align);
2571           rva_bias += data - p;
2572
2573           /* For reasons that are unclear .rsrc sections are sometimes created
2574              aligned to a 1^3 boundary even when their alignment is set at
2575              1^2.  Catch that case here before we issue a spurious warning
2576              message.  */
2577           if (data == (regions.section_end - 4))
2578             data = regions.section_end;
2579           else if (data < regions.section_end)
2580             {
2581               /* If the extra data is all zeros then do not complain.
2582                  This is just padding so that the section meets the
2583                  page size requirements.  */
2584               while (++ data < regions.section_end)
2585                 if (*data != 0)
2586                   break;
2587               if (data < regions.section_end)
2588                 fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2589             }
2590         }
2591     }
2592
2593   if (regions.strings_start != NULL)
2594     fprintf (file, _(" String table starts at offset: %#03x\n"),
2595              (int) (regions.strings_start - regions.section_start));
2596   if (regions.resource_start != NULL)
2597     fprintf (file, _(" Resources start at offset: %#03x\n"),
2598              (int) (regions.resource_start - regions.section_start));
2599
2600   free (regions.section_start);
2601   return TRUE;
2602 }
2603
2604 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2605
2606 static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] =
2607 {
2608   "Unknown",
2609   "COFF",
2610   "CodeView",
2611   "FPO",
2612   "Misc",
2613   "Exception",
2614   "Fixup",
2615   "OMAP-to-SRC",
2616   "OMAP-from-SRC",
2617   "Borland",
2618   "Reserved",
2619   "CLSID",
2620 };
2621
2622 static bfd_boolean
2623 pe_print_debugdata (bfd * abfd, void * vfile)
2624 {
2625   FILE *file = (FILE *) vfile;
2626   pe_data_type *pe = pe_data (abfd);
2627   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
2628   asection *section;
2629   bfd_byte *data = 0;
2630   bfd_size_type dataoff;
2631   unsigned int i;
2632
2633   bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
2634   bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
2635
2636   if (size == 0)
2637     return TRUE;
2638
2639   addr += extra->ImageBase;
2640   for (section = abfd->sections; section != NULL; section = section->next)
2641     {
2642       if ((addr >= section->vma) && (addr < (section->vma + section->size)))
2643         break;
2644     }
2645
2646   if (section == NULL)
2647     {
2648       fprintf (file,
2649                _("\nThere is a debug directory, but the section containing it could not be found\n"));
2650       return TRUE;
2651     }
2652   else if (!(section->flags & SEC_HAS_CONTENTS))
2653     {
2654       fprintf (file,
2655                _("\nThere is a debug directory in %s, but that section has no contents\n"),
2656                section->name);
2657       return TRUE;
2658     }
2659   else if (section->size < size)
2660     {
2661       fprintf (file,
2662                _("\nError: section %s contains the debug data starting address but it is too small\n"),
2663                section->name);
2664       return FALSE;
2665     }
2666
2667   fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2668            section->name, (unsigned long) addr);
2669
2670   dataoff = addr - section->vma;
2671
2672   if (size > (section->size - dataoff))
2673     {
2674       fprintf (file, _("The debug data size field in the data directory is too big for the section"));
2675       return FALSE;
2676     }
2677
2678   fprintf (file,
2679            _("Type                Size     Rva      Offset\n"));
2680
2681   /* Read the whole section.  */
2682   if (!bfd_malloc_and_get_section (abfd, section, &data))
2683     {
2684       if (data != NULL)
2685         free (data);
2686       return FALSE;
2687     }
2688
2689   for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2690     {
2691       const char *type_name;
2692       struct external_IMAGE_DEBUG_DIRECTORY *ext
2693         = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
2694       struct internal_IMAGE_DEBUG_DIRECTORY idd;
2695
2696       _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
2697
2698       if ((idd.Type) >= IMAGE_NUMBEROF_DEBUG_TYPES)
2699         type_name = debug_type_names[0];
2700       else
2701         type_name = debug_type_names[idd.Type];
2702
2703       fprintf (file, " %2ld  %14s %08lx %08lx %08lx\n",
2704                idd.Type, type_name, idd.SizeOfData,
2705                idd.AddressOfRawData, idd.PointerToRawData);
2706
2707       if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
2708         {
2709           char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1];
2710           /* PR 17512: file: 065-29434-0.001:0.1
2711              We need to use a 32-bit aligned buffer
2712              to safely read in a codeview record.  */
2713           char buffer[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO);
2714
2715           CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
2716
2717           /* The debug entry doesn't have to have to be in a section,
2718              in which case AddressOfRawData is 0, so always use PointerToRawData.  */
2719           if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData,
2720                                                idd.SizeOfData, cvinfo))
2721             continue;
2722
2723           for (i = 0; i < cvinfo->SignatureLength; i++)
2724             sprintf (&signature[i*2], "%02x", cvinfo->Signature[i] & 0xff);
2725
2726           /* xgettext:c-format */
2727           fprintf (file, _("(format %c%c%c%c signature %s age %ld)\n"),
2728                    buffer[0], buffer[1], buffer[2], buffer[3],
2729                    signature, cvinfo->Age);
2730         }
2731     }
2732
2733   if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0)
2734     fprintf (file,
2735             _("The debug directory size is not a multiple of the debug directory entry size\n"));
2736
2737   return TRUE;
2738 }
2739
2740 /* Print out the program headers.  */
2741
2742 bfd_boolean
2743 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2744 {
2745   FILE *file = (FILE *) vfile;
2746   int j;
2747   pe_data_type *pe = pe_data (abfd);
2748   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2749   const char *subsystem_name = NULL;
2750   const char *name;
2751
2752   /* The MS dumpbin program reportedly ands with 0xff0f before
2753      printing the characteristics field.  Not sure why.  No reason to
2754      emulate it here.  */
2755   fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2756 #undef PF
2757 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2758   PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2759   PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2760   PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2761   PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2762   PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2763   PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2764   PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2765   PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2766   PF (IMAGE_FILE_SYSTEM, "system file");
2767   PF (IMAGE_FILE_DLL, "DLL");
2768   PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2769 #undef PF
2770
2771   /* ctime implies '\n'.  */
2772   {
2773     time_t t = pe->coff.timestamp;
2774     fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2775   }
2776
2777 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2778 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2779 #endif
2780 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2781 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2782 #endif
2783 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2784 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2785 #endif
2786
2787   switch (i->Magic)
2788     {
2789     case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2790       name = "PE32";
2791       break;
2792     case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2793       name = "PE32+";
2794       break;
2795     case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2796       name = "ROM";
2797       break;
2798     default:
2799       name = NULL;
2800       break;
2801     }
2802   fprintf (file, "Magic\t\t\t%04x", i->Magic);
2803   if (name)
2804     fprintf (file, "\t(%s)",name);
2805   fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2806   fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2807   fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2808   fprintf (file, "SizeOfInitializedData\t%08lx\n",
2809            (unsigned long) i->SizeOfInitializedData);
2810   fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2811            (unsigned long) i->SizeOfUninitializedData);
2812   fprintf (file, "AddressOfEntryPoint\t");
2813   bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2814   fprintf (file, "\nBaseOfCode\t\t");
2815   bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2816 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2817   /* PE32+ does not have BaseOfData member!  */
2818   fprintf (file, "\nBaseOfData\t\t");
2819   bfd_fprintf_vma (abfd, file, i->BaseOfData);
2820 #endif
2821
2822   fprintf (file, "\nImageBase\t\t");
2823   bfd_fprintf_vma (abfd, file, i->ImageBase);
2824   fprintf (file, "\nSectionAlignment\t");
2825   bfd_fprintf_vma (abfd, file, i->SectionAlignment);
2826   fprintf (file, "\nFileAlignment\t\t");
2827   bfd_fprintf_vma (abfd, file, i->FileAlignment);
2828   fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2829   fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2830   fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2831   fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2832   fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2833   fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2834   fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2835   fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2836   fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2837   fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2838
2839   switch (i->Subsystem)
2840     {
2841     case IMAGE_SUBSYSTEM_UNKNOWN:
2842       subsystem_name = "unspecified";
2843       break;
2844     case IMAGE_SUBSYSTEM_NATIVE:
2845       subsystem_name = "NT native";
2846       break;
2847     case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2848       subsystem_name = "Windows GUI";
2849       break;
2850     case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2851       subsystem_name = "Windows CUI";
2852       break;
2853     case IMAGE_SUBSYSTEM_POSIX_CUI:
2854       subsystem_name = "POSIX CUI";
2855       break;
2856     case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2857       subsystem_name = "Wince CUI";
2858       break;
2859     // These are from UEFI Platform Initialization Specification 1.1.
2860     case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2861       subsystem_name = "EFI application";
2862       break;
2863     case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2864       subsystem_name = "EFI boot service driver";
2865       break;
2866     case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2867       subsystem_name = "EFI runtime driver";
2868       break;
2869     case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2870       subsystem_name = "SAL runtime driver";
2871       break;
2872     // This is from revision 8.0 of the MS PE/COFF spec
2873     case IMAGE_SUBSYSTEM_XBOX:
2874       subsystem_name = "XBOX";
2875       break;
2876     // Added default case for clarity - subsystem_name is NULL anyway.
2877     default:
2878       subsystem_name = NULL;
2879     }
2880
2881   fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2882   if (subsystem_name)
2883     fprintf (file, "\t(%s)", subsystem_name);
2884   fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2885   fprintf (file, "SizeOfStackReserve\t");
2886   bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
2887   fprintf (file, "\nSizeOfStackCommit\t");
2888   bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
2889   fprintf (file, "\nSizeOfHeapReserve\t");
2890   bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
2891   fprintf (file, "\nSizeOfHeapCommit\t");
2892   bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
2893   fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2894   fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2895            (unsigned long) i->NumberOfRvaAndSizes);
2896
2897   fprintf (file, "\nThe Data Directory\n");
2898   for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2899     {
2900       fprintf (file, "Entry %1x ", j);
2901       bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
2902       fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2903       fprintf (file, "%s\n", dir_names[j]);
2904     }
2905
2906   pe_print_idata (abfd, vfile);
2907   pe_print_edata (abfd, vfile);
2908   if (bfd_coff_have_print_pdata (abfd))
2909     bfd_coff_print_pdata (abfd, vfile);
2910   else
2911     pe_print_pdata (abfd, vfile);
2912   pe_print_reloc (abfd, vfile);
2913   pe_print_debugdata (abfd, file);
2914
2915   rsrc_print_section (abfd, vfile);
2916
2917   return TRUE;
2918 }
2919
2920 static bfd_boolean
2921 is_vma_in_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
2922 {
2923   bfd_vma addr = * (bfd_vma *) obj;
2924   return (addr >= sect->vma) && (addr < (sect->vma + sect->size));
2925 }
2926
2927 static asection *
2928 find_section_by_vma (bfd *abfd, bfd_vma addr)
2929 {
2930   return bfd_sections_find_if (abfd, is_vma_in_section, (void *) & addr);
2931 }
2932
2933 /* Copy any private info we understand from the input bfd
2934    to the output bfd.  */
2935
2936 bfd_boolean
2937 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2938 {
2939   pe_data_type *ipe, *ope;
2940
2941   /* One day we may try to grok other private data.  */
2942   if (ibfd->xvec->flavour != bfd_target_coff_flavour
2943       || obfd->xvec->flavour != bfd_target_coff_flavour)
2944     return TRUE;
2945
2946   ipe = pe_data (ibfd);
2947   ope = pe_data (obfd);
2948
2949   /* pe_opthdr is copied in copy_object.  */
2950   ope->dll = ipe->dll;
2951
2952   /* Don't copy input subsystem if output is different from input.  */
2953   if (obfd->xvec != ibfd->xvec)
2954     ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2955
2956   /* For strip: if we removed .reloc, we'll make a real mess of things
2957      if we don't remove this entry as well.  */
2958   if (! pe_data (obfd)->has_reloc_section)
2959     {
2960       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2961       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2962     }
2963
2964   /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2965      But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2966      won't be added.  */
2967   if (! pe_data (ibfd)->has_reloc_section
2968       && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
2969     pe_data (obfd)->dont_strip_reloc = 1;
2970
2971   /* The file offsets contained in the debug directory need rewriting.  */
2972   if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size != 0)
2973     {
2974       bfd_vma addr = ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].VirtualAddress
2975         + ope->pe_opthdr.ImageBase;
2976       asection *section = find_section_by_vma (obfd, addr);
2977       bfd_byte *data;
2978
2979       if (section && bfd_malloc_and_get_section (obfd, section, &data))
2980         {
2981           unsigned int i;
2982           struct external_IMAGE_DEBUG_DIRECTORY *dd =
2983             (struct external_IMAGE_DEBUG_DIRECTORY *)(data + (addr - section->vma));
2984
2985           /* PR 17512: file: 0f15796a.  */
2986           if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size + (addr - section->vma)
2987               > bfd_get_section_size (section))
2988             {
2989               /* xgettext:c-format */
2990               _bfd_error_handler
2991                 (_("%pB: Data Directory size (%lx) "
2992                    "exceeds space left in section (%" PRIx64 ")"),
2993                  obfd, ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size,
2994                  (uint64_t) (section->size - (addr - section->vma)));
2995               return FALSE;
2996             }
2997           /* PR 23110.  */
2998           else if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size < 0)
2999             {
3000               /* xgettext:c-format */
3001               _bfd_error_handler
3002                 (_("%pB: Data Directory size (%#lx) is negative"),
3003                  obfd, ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size);
3004               return FALSE;
3005             }
3006
3007           for (i = 0; i < ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
3008                  / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
3009             {
3010               asection *ddsection;
3011               struct external_IMAGE_DEBUG_DIRECTORY *edd = &(dd[i]);
3012               struct internal_IMAGE_DEBUG_DIRECTORY idd;
3013
3014               _bfd_XXi_swap_debugdir_in (obfd, edd, &idd);
3015
3016               if (idd.AddressOfRawData == 0)
3017                 continue; /* RVA 0 means only offset is valid, not handled yet.  */
3018
3019               ddsection = find_section_by_vma (obfd, idd.AddressOfRawData + ope->pe_opthdr.ImageBase);
3020               if (!ddsection)
3021                 continue; /* Not in a section! */
3022
3023               idd.PointerToRawData = ddsection->filepos + (idd.AddressOfRawData
3024                                                            + ope->pe_opthdr.ImageBase) - ddsection->vma;
3025
3026               _bfd_XXi_swap_debugdir_out (obfd, &idd, edd);
3027             }
3028
3029           if (!bfd_set_section_contents (obfd, section, data, 0, section->size))
3030             {
3031               _bfd_error_handler (_("failed to update file offsets in debug directory"));
3032               return FALSE;
3033             }
3034         }
3035       else if (section)
3036         {
3037           _bfd_error_handler (_("%pB: failed to read debug data section"), obfd);
3038           return FALSE;
3039         }
3040     }
3041
3042   return TRUE;
3043 }
3044
3045 /* Copy private section data.  */
3046
3047 bfd_boolean
3048 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
3049                                        asection *isec,
3050                                        bfd *obfd,
3051                                        asection *osec)
3052 {
3053   if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
3054       || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
3055     return TRUE;
3056
3057   if (coff_section_data (ibfd, isec) != NULL
3058       && pei_section_data (ibfd, isec) != NULL)
3059     {
3060       if (coff_section_data (obfd, osec) == NULL)
3061         {
3062           bfd_size_type amt = sizeof (struct coff_section_tdata);
3063           osec->used_by_bfd = bfd_zalloc (obfd, amt);
3064           if (osec->used_by_bfd == NULL)
3065             return FALSE;
3066         }
3067
3068       if (pei_section_data (obfd, osec) == NULL)
3069         {
3070           bfd_size_type amt = sizeof (struct pei_section_tdata);
3071           coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
3072           if (coff_section_data (obfd, osec)->tdata == NULL)
3073             return FALSE;
3074         }
3075
3076       pei_section_data (obfd, osec)->virt_size =
3077         pei_section_data (ibfd, isec)->virt_size;
3078       pei_section_data (obfd, osec)->pe_flags =
3079         pei_section_data (ibfd, isec)->pe_flags;
3080     }
3081
3082   return TRUE;
3083 }
3084
3085 void
3086 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
3087 {
3088   coff_get_symbol_info (abfd, symbol, ret);
3089 }
3090
3091 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3092 static int
3093 sort_x64_pdata (const void *l, const void *r)
3094 {
3095   const char *lp = (const char *) l;
3096   const char *rp = (const char *) r;
3097   bfd_vma vl, vr;
3098   vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
3099   if (vl != vr)
3100     return (vl < vr ? -1 : 1);
3101   /* We compare just begin address.  */
3102   return 0;
3103 }
3104 #endif
3105 \f
3106 /* Functions to process a .rsrc section.  */
3107
3108 static unsigned int sizeof_leaves;
3109 static unsigned int sizeof_strings;
3110 static unsigned int sizeof_tables_and_entries;
3111
3112 static bfd_byte *
3113 rsrc_count_directory (bfd *, bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma);
3114
3115 static bfd_byte *
3116 rsrc_count_entries (bfd *          abfd,
3117                     bfd_boolean    is_name,
3118                     bfd_byte *     datastart,
3119                     bfd_byte *     data,
3120                     bfd_byte *     dataend,
3121                     bfd_vma        rva_bias)
3122 {
3123   unsigned long entry, addr, size;
3124
3125   if (data + 8 >= dataend)
3126     return dataend + 1;
3127
3128   if (is_name)
3129     {
3130       bfd_byte * name;
3131
3132       entry = (long) bfd_get_32 (abfd, data);
3133
3134       if (HighBitSet (entry))
3135         name = datastart + WithoutHighBit (entry);
3136       else
3137         name = datastart + entry - rva_bias;
3138
3139       if (name + 2 >= dataend || name < datastart)
3140         return dataend + 1;
3141
3142       unsigned int len = bfd_get_16 (abfd, name);
3143       if (len == 0 || len > 256)
3144         return dataend + 1;
3145     }
3146
3147   entry = (long) bfd_get_32 (abfd, data + 4);
3148
3149   if (HighBitSet (entry))
3150     {
3151       data = datastart + WithoutHighBit (entry);
3152
3153       if (data <= datastart || data >= dataend)
3154         return dataend + 1;
3155
3156       return rsrc_count_directory (abfd, datastart, data, dataend, rva_bias);
3157     }
3158
3159   if (datastart + entry + 16 >= dataend)
3160     return dataend + 1;
3161
3162   addr = (long) bfd_get_32 (abfd, datastart + entry);
3163   size = (long) bfd_get_32 (abfd, datastart + entry + 4);
3164
3165   return datastart + addr - rva_bias + size;
3166 }
3167
3168 static bfd_byte *
3169 rsrc_count_directory (bfd *          abfd,
3170                       bfd_byte *     datastart,
3171                       bfd_byte *     data,
3172                       bfd_byte *     dataend,
3173                       bfd_vma        rva_bias)
3174 {
3175   unsigned int  num_entries, num_ids;
3176   bfd_byte *    highest_data = data;
3177
3178   if (data + 16 >= dataend)
3179     return dataend + 1;
3180
3181   num_entries  = (int) bfd_get_16 (abfd, data + 12);
3182   num_ids      = (int) bfd_get_16 (abfd, data + 14);
3183
3184   num_entries += num_ids;
3185
3186   data += 16;
3187
3188   while (num_entries --)
3189     {
3190       bfd_byte * entry_end;
3191
3192       entry_end = rsrc_count_entries (abfd, num_entries >= num_ids,
3193                                       datastart, data, dataend, rva_bias);
3194       data += 8;
3195       highest_data = max (highest_data, entry_end);
3196       if (entry_end >= dataend)
3197         break;
3198     }
3199
3200   return max (highest_data, data);
3201 }
3202
3203 typedef struct rsrc_dir_chain
3204 {
3205   unsigned int         num_entries;
3206   struct rsrc_entry *  first_entry;
3207   struct rsrc_entry *  last_entry;
3208 } rsrc_dir_chain;
3209
3210 typedef struct rsrc_directory
3211 {
3212   unsigned int characteristics;
3213   unsigned int time;
3214   unsigned int major;
3215   unsigned int minor;
3216
3217   rsrc_dir_chain names;
3218   rsrc_dir_chain ids;
3219
3220   struct rsrc_entry * entry;
3221 } rsrc_directory;
3222
3223 typedef struct rsrc_string
3224 {
3225   unsigned int  len;
3226   bfd_byte *    string;
3227 } rsrc_string;
3228
3229 typedef struct rsrc_leaf
3230 {
3231   unsigned int  size;
3232   unsigned int  codepage;
3233   bfd_byte *    data;
3234 } rsrc_leaf;
3235
3236 typedef struct rsrc_entry
3237 {
3238   bfd_boolean is_name;
3239   union
3240   {
3241     unsigned int          id;
3242     struct rsrc_string    name;
3243   } name_id;
3244
3245   bfd_boolean is_dir;
3246   union
3247   {
3248     struct rsrc_directory * directory;
3249     struct rsrc_leaf *      leaf;
3250   } value;
3251
3252   struct rsrc_entry *     next_entry;
3253   struct rsrc_directory * parent;
3254 } rsrc_entry;
3255
3256 static bfd_byte *
3257 rsrc_parse_directory (bfd *, rsrc_directory *, bfd_byte *,
3258                       bfd_byte *, bfd_byte *, bfd_vma, rsrc_entry *);
3259
3260 static bfd_byte *
3261 rsrc_parse_entry (bfd *            abfd,
3262                   bfd_boolean      is_name,
3263                   rsrc_entry *     entry,
3264                   bfd_byte *       datastart,
3265                   bfd_byte *       data,
3266                   bfd_byte *       dataend,
3267                   bfd_vma          rva_bias,
3268                   rsrc_directory * parent)
3269 {
3270   unsigned long val, addr, size;
3271
3272   val = bfd_get_32 (abfd, data);
3273
3274   entry->parent = parent;
3275   entry->is_name = is_name;
3276
3277   if (is_name)
3278     {
3279       bfd_byte * address;
3280
3281       if (HighBitSet (val))
3282         {
3283           val = WithoutHighBit (val);
3284
3285           address = datastart + val;
3286         }
3287       else
3288         {
3289           address = datastart + val - rva_bias;
3290         }
3291
3292       if (address + 3 > dataend)
3293         return dataend;
3294
3295       entry->name_id.name.len    = bfd_get_16 (abfd, address);
3296       entry->name_id.name.string = address + 2;
3297     }
3298   else
3299     entry->name_id.id = val;
3300
3301   val = bfd_get_32 (abfd, data + 4);
3302
3303   if (HighBitSet (val))
3304     {
3305       entry->is_dir = TRUE;
3306       entry->value.directory = bfd_malloc (sizeof * entry->value.directory);
3307       if (entry->value.directory == NULL)
3308         return dataend;
3309
3310       return rsrc_parse_directory (abfd, entry->value.directory,
3311                                    datastart,
3312                                    datastart + WithoutHighBit (val),
3313                                    dataend, rva_bias, entry);
3314     }
3315
3316   entry->is_dir = FALSE;
3317   entry->value.leaf = bfd_malloc (sizeof * entry->value.leaf);
3318   if (entry->value.leaf == NULL)
3319     return dataend;
3320
3321   data = datastart + val;
3322   if (data < datastart || data >= dataend)
3323     return dataend;
3324
3325   addr = bfd_get_32 (abfd, data);
3326   size = entry->value.leaf->size = bfd_get_32 (abfd, data + 4);
3327   entry->value.leaf->codepage = bfd_get_32 (abfd, data + 8);
3328   /* FIXME: We assume that the reserved field (data + 12) is OK.  */
3329
3330   entry->value.leaf->data = bfd_malloc (size);
3331   if (entry->value.leaf->data == NULL)
3332     return dataend;
3333
3334   memcpy (entry->value.leaf->data, datastart + addr - rva_bias, size);
3335   return datastart + (addr - rva_bias) + size;
3336 }
3337
3338 static bfd_byte *
3339 rsrc_parse_entries (bfd *            abfd,
3340                     rsrc_dir_chain * chain,
3341                     bfd_boolean      is_name,
3342                     bfd_byte *       highest_data,
3343                     bfd_byte *       datastart,
3344                     bfd_byte *       data,
3345                     bfd_byte *       dataend,
3346                     bfd_vma          rva_bias,
3347                     rsrc_directory * parent)
3348 {
3349   unsigned int i;
3350   rsrc_entry * entry;
3351
3352   if (chain->num_entries == 0)
3353     {
3354       chain->first_entry = chain->last_entry = NULL;
3355       return highest_data;
3356     }
3357
3358   entry = bfd_malloc (sizeof * entry);
3359   if (entry == NULL)
3360     return dataend;
3361
3362   chain->first_entry = entry;
3363
3364   for (i = chain->num_entries; i--;)
3365     {
3366       bfd_byte * entry_end;
3367
3368       entry_end = rsrc_parse_entry (abfd, is_name, entry, datastart,
3369                                     data, dataend, rva_bias, parent);
3370       data += 8;
3371       highest_data = max (entry_end, highest_data);
3372       if (entry_end > dataend)
3373         return dataend;
3374
3375       if (i)
3376         {
3377           entry->next_entry = bfd_malloc (sizeof * entry);
3378           entry = entry->next_entry;
3379           if (entry == NULL)
3380             return dataend;
3381         }
3382       else
3383         entry->next_entry = NULL;
3384     }
3385
3386   chain->last_entry = entry;
3387
3388   return highest_data;
3389 }
3390
3391 static bfd_byte *
3392 rsrc_parse_directory (bfd *            abfd,
3393                       rsrc_directory * table,
3394                       bfd_byte *       datastart,
3395                       bfd_byte *       data,
3396                       bfd_byte *       dataend,
3397                       bfd_vma          rva_bias,
3398                       rsrc_entry *     entry)
3399 {
3400   bfd_byte * highest_data = data;
3401
3402   if (table == NULL)
3403     return dataend;
3404
3405   table->characteristics = bfd_get_32 (abfd, data);
3406   table->time = bfd_get_32 (abfd, data + 4);
3407   table->major = bfd_get_16 (abfd, data + 8);
3408   table->minor = bfd_get_16 (abfd, data + 10);
3409   table->names.num_entries = bfd_get_16 (abfd, data + 12);
3410   table->ids.num_entries = bfd_get_16 (abfd, data + 14);
3411   table->entry = entry;
3412
3413   data += 16;
3414
3415   highest_data = rsrc_parse_entries (abfd, & table->names, TRUE, data,
3416                                      datastart, data, dataend, rva_bias, table);
3417   data += table->names.num_entries * 8;
3418
3419   highest_data = rsrc_parse_entries (abfd, & table->ids, FALSE, highest_data,
3420                                      datastart, data, dataend, rva_bias, table);
3421   data += table->ids.num_entries * 8;
3422
3423   return max (highest_data, data);
3424 }
3425
3426 typedef struct rsrc_write_data
3427 {
3428   bfd *      abfd;
3429   bfd_byte * datastart;
3430   bfd_byte * next_table;
3431   bfd_byte * next_leaf;
3432   bfd_byte * next_string;
3433   bfd_byte * next_data;
3434   bfd_vma    rva_bias;
3435 } rsrc_write_data;
3436
3437 static void
3438 rsrc_write_string (rsrc_write_data * data,
3439                    rsrc_string *     string)
3440 {
3441   bfd_put_16 (data->abfd, string->len, data->next_string);
3442   memcpy (data->next_string + 2, string->string, string->len * 2);
3443   data->next_string += (string->len + 1) * 2;
3444 }
3445
3446 static inline unsigned int
3447 rsrc_compute_rva (rsrc_write_data * data,
3448                   bfd_byte *        addr)
3449 {
3450   return (addr - data->datastart) + data->rva_bias;
3451 }
3452
3453 static void
3454 rsrc_write_leaf (rsrc_write_data * data,
3455                  rsrc_leaf *       leaf)
3456 {
3457   bfd_put_32 (data->abfd, rsrc_compute_rva (data, data->next_data),
3458               data->next_leaf);
3459   bfd_put_32 (data->abfd, leaf->size,     data->next_leaf + 4);
3460   bfd_put_32 (data->abfd, leaf->codepage, data->next_leaf + 8);
3461   bfd_put_32 (data->abfd, 0 /*reserved*/, data->next_leaf + 12);
3462   data->next_leaf += 16;
3463
3464   memcpy (data->next_data, leaf->data, leaf->size);
3465   /* An undocumented feature of Windows resources is that each unit
3466      of raw data is 8-byte aligned...  */
3467   data->next_data += ((leaf->size + 7) & ~7);
3468 }
3469
3470 static void rsrc_write_directory (rsrc_write_data *, rsrc_directory *);
3471
3472 static void
3473 rsrc_write_entry (rsrc_write_data *  data,
3474                   bfd_byte *         where,
3475                   rsrc_entry *       entry)
3476 {
3477   if (entry->is_name)
3478     {
3479       bfd_put_32 (data->abfd,
3480                   SetHighBit (data->next_string - data->datastart),
3481                   where);
3482       rsrc_write_string (data, & entry->name_id.name);
3483     }
3484   else
3485     bfd_put_32 (data->abfd, entry->name_id.id, where);
3486
3487   if (entry->is_dir)
3488     {
3489       bfd_put_32 (data->abfd,
3490                   SetHighBit (data->next_table - data->datastart),
3491                   where + 4);
3492       rsrc_write_directory (data, entry->value.directory);
3493     }
3494   else
3495     {
3496       bfd_put_32 (data->abfd, data->next_leaf - data->datastart, where + 4);
3497       rsrc_write_leaf (data, entry->value.leaf);
3498     }
3499 }
3500
3501 static void
3502 rsrc_compute_region_sizes (rsrc_directory * dir)
3503 {
3504   struct rsrc_entry * entry;
3505
3506   if (dir == NULL)
3507     return;
3508
3509   sizeof_tables_and_entries += 16;
3510
3511   for (entry = dir->names.first_entry; entry != NULL; entry = entry->next_entry)
3512     {
3513       sizeof_tables_and_entries += 8;
3514
3515       sizeof_strings += (entry->name_id.name.len + 1) * 2;
3516
3517       if (entry->is_dir)
3518         rsrc_compute_region_sizes (entry->value.directory);
3519       else
3520         sizeof_leaves += 16;
3521     }
3522
3523   for (entry = dir->ids.first_entry; entry != NULL; entry = entry->next_entry)
3524     {
3525       sizeof_tables_and_entries += 8;
3526
3527       if (entry->is_dir)
3528         rsrc_compute_region_sizes (entry->value.directory);
3529       else
3530         sizeof_leaves += 16;
3531     }
3532 }
3533
3534 static void
3535 rsrc_write_directory (rsrc_write_data * data,
3536                       rsrc_directory *  dir)
3537 {
3538   rsrc_entry * entry;
3539   unsigned int i;
3540   bfd_byte * next_entry;
3541   bfd_byte * nt;
3542
3543   bfd_put_32 (data->abfd, dir->characteristics, data->next_table);
3544   bfd_put_32 (data->abfd, 0 /*dir->time*/, data->next_table + 4);
3545   bfd_put_16 (data->abfd, dir->major, data->next_table + 8);
3546   bfd_put_16 (data->abfd, dir->minor, data->next_table + 10);
3547   bfd_put_16 (data->abfd, dir->names.num_entries, data->next_table + 12);
3548   bfd_put_16 (data->abfd, dir->ids.num_entries, data->next_table + 14);
3549
3550   /* Compute where the entries and the next table will be placed.  */
3551   next_entry = data->next_table + 16;
3552   data->next_table = next_entry + (dir->names.num_entries * 8)
3553     + (dir->ids.num_entries * 8);
3554   nt = data->next_table;
3555
3556   /* Write the entries.  */
3557   for (i = dir->names.num_entries, entry = dir->names.first_entry;
3558        i > 0 && entry != NULL;
3559        i--, entry = entry->next_entry)
3560     {
3561       BFD_ASSERT (entry->is_name);
3562       rsrc_write_entry (data, next_entry, entry);
3563       next_entry += 8;
3564     }
3565   BFD_ASSERT (i == 0);
3566   BFD_ASSERT (entry == NULL);
3567
3568   for (i = dir->ids.num_entries, entry = dir->ids.first_entry;
3569        i > 0 && entry != NULL;
3570        i--, entry = entry->next_entry)
3571     {
3572       BFD_ASSERT (! entry->is_name);
3573       rsrc_write_entry (data, next_entry, entry);
3574       next_entry += 8;
3575     }
3576   BFD_ASSERT (i == 0);
3577   BFD_ASSERT (entry == NULL);
3578   BFD_ASSERT (nt == next_entry);
3579 }
3580
3581 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3582 /* Return the length (number of units) of the first character in S,
3583    putting its 'ucs4_t' representation in *PUC.  */
3584
3585 static unsigned int
3586 #if defined HAVE_WCTYPE_H
3587 u16_mbtouc (wint_t * puc, const unsigned short * s, unsigned int n)
3588 #else
3589 u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n)
3590 #endif
3591 {
3592   unsigned short c = * s;
3593
3594   if (c < 0xd800 || c >= 0xe000)
3595     {
3596       *puc = c;
3597       return 1;
3598     }
3599
3600   if (c < 0xdc00)
3601     {
3602       if (n >= 2)
3603         {
3604           if (s[1] >= 0xdc00 && s[1] < 0xe000)
3605             {
3606               *puc = 0x10000 + ((c - 0xd800) << 10) + (s[1] - 0xdc00);
3607               return 2;
3608             }
3609         }
3610       else
3611         {
3612           /* Incomplete multibyte character.  */
3613           *puc = 0xfffd;
3614           return n;
3615         }
3616     }
3617
3618   /* Invalid multibyte character.  */
3619   *puc = 0xfffd;
3620   return 1;
3621 }
3622 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3623
3624 /* Perform a comparison of two entries.  */
3625 static signed int
3626 rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b)
3627 {
3628   signed int    res;
3629   bfd_byte *    astring;
3630   unsigned int  alen;
3631   bfd_byte *    bstring;
3632   unsigned int  blen;
3633
3634   if (! is_name)
3635     return a->name_id.id - b->name_id.id;
3636
3637   /* We have to perform a case insenstive, unicode string comparison...  */
3638   astring = a->name_id.name.string;
3639   alen    = a->name_id.name.len;
3640   bstring = b->name_id.name.string;
3641   blen    = b->name_id.name.len;
3642
3643 #if defined  __CYGWIN__ || defined __MINGW32__
3644   /* Under Windows hosts (both Cygwin and Mingw types),
3645      unicode == UTF-16 == wchar_t.  The case insensitive string comparison
3646      function however goes by different names in the two environments...  */
3647
3648 #undef rscpcmp
3649 #ifdef __CYGWIN__
3650 #define rscpcmp wcsncasecmp
3651 #endif
3652 #ifdef __MINGW32__
3653 #define rscpcmp wcsnicmp
3654 #endif
3655
3656   res = rscpcmp ((const wchar_t *) astring, (const wchar_t *) bstring,
3657                  min (alen, blen));
3658
3659 #elif defined HAVE_WCHAR_H
3660   {
3661     unsigned int  i;
3662
3663     res = 0;
3664     for (i = min (alen, blen); i--; astring += 2, bstring += 2)
3665       {
3666 #if defined HAVE_WCTYPE_H
3667         wint_t awc;
3668         wint_t bwc;
3669 #else
3670         wchar_t awc;
3671         wchar_t bwc;
3672 #endif
3673
3674         /* Convert UTF-16 unicode characters into wchar_t characters
3675            so that we can then perform a case insensitive comparison.  */
3676         unsigned int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2);
3677         unsigned int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2);
3678
3679         if (Alen != Blen)
3680           return Alen - Blen;
3681
3682 #ifdef HAVE_WCTYPE_H
3683         awc = towlower (awc);
3684         bwc = towlower (bwc);
3685
3686         res = awc - bwc;
3687 #else
3688         res = wcsncasecmp (& awc, & bwc, 1);
3689 #endif
3690         if (res)
3691           break;
3692       }
3693   }
3694 #else
3695   /* Do the best we can - a case sensitive, untranslated comparison.  */
3696   res = memcmp (astring, bstring, min (alen, blen) * 2);
3697 #endif
3698
3699   if (res == 0)
3700     res = alen - blen;
3701
3702   return res;
3703 }
3704
3705 static void
3706 rsrc_print_name (char * buffer, rsrc_string string)
3707 {
3708   unsigned int  i;
3709   bfd_byte *    name = string.string;
3710
3711   for (i = string.len; i--; name += 2)
3712     sprintf (buffer + strlen (buffer), "%.1s", name);
3713 }
3714
3715 static const char *
3716 rsrc_resource_name (rsrc_entry * entry, rsrc_directory * dir)
3717 {
3718   static char buffer [256];
3719   bfd_boolean is_string = FALSE;
3720
3721   buffer[0] = 0;
3722
3723   if (dir != NULL && dir->entry != NULL && dir->entry->parent != NULL
3724       && dir->entry->parent->entry != NULL)
3725     {
3726       strcpy (buffer, "type: ");
3727       if (dir->entry->parent->entry->is_name)
3728         rsrc_print_name (buffer + strlen (buffer),
3729                          dir->entry->parent->entry->name_id.name);
3730       else
3731         {
3732           unsigned int id = dir->entry->parent->entry->name_id.id;
3733
3734           sprintf (buffer + strlen (buffer), "%x", id);
3735           switch (id)
3736             {
3737             case 1: strcat (buffer, " (CURSOR)"); break;
3738             case 2: strcat (buffer, " (BITMAP)"); break;
3739             case 3: strcat (buffer, " (ICON)"); break;
3740             case 4: strcat (buffer, " (MENU)"); break;
3741             case 5: strcat (buffer, " (DIALOG)"); break;
3742             case 6: strcat (buffer, " (STRING)"); is_string = TRUE; break;
3743             case 7: strcat (buffer, " (FONTDIR)"); break;
3744             case 8: strcat (buffer, " (FONT)"); break;
3745             case 9: strcat (buffer, " (ACCELERATOR)"); break;
3746             case 10: strcat (buffer, " (RCDATA)"); break;
3747             case 11: strcat (buffer, " (MESSAGETABLE)"); break;
3748             case 12: strcat (buffer, " (GROUP_CURSOR)"); break;
3749             case 14: strcat (buffer, " (GROUP_ICON)"); break;
3750             case 16: strcat (buffer, " (VERSION)"); break;
3751             case 17: strcat (buffer, " (DLGINCLUDE)"); break;
3752             case 19: strcat (buffer, " (PLUGPLAY)"); break;
3753             case 20: strcat (buffer, " (VXD)"); break;
3754             case 21: strcat (buffer, " (ANICURSOR)"); break;
3755             case 22: strcat (buffer, " (ANIICON)"); break;
3756             case 23: strcat (buffer, " (HTML)"); break;
3757             case 24: strcat (buffer, " (MANIFEST)"); break;
3758             case 240: strcat (buffer, " (DLGINIT)"); break;
3759             case 241: strcat (buffer, " (TOOLBAR)"); break;
3760             }
3761         }
3762     }
3763
3764   if (dir != NULL && dir->entry != NULL)
3765     {
3766       strcat (buffer, " name: ");
3767       if (dir->entry->is_name)
3768         rsrc_print_name (buffer + strlen (buffer), dir->entry->name_id.name);
3769       else
3770         {
3771           unsigned int id = dir->entry->name_id.id;
3772
3773           sprintf (buffer + strlen (buffer), "%x", id);
3774
3775           if (is_string)
3776             sprintf (buffer + strlen (buffer), " (resource id range: %d - %d)",
3777                      (id - 1) << 4, (id << 4) - 1);
3778         }
3779     }
3780
3781   if (entry != NULL)
3782     {
3783       strcat (buffer, " lang: ");
3784
3785       if (entry->is_name)
3786         rsrc_print_name (buffer + strlen (buffer), entry->name_id.name);
3787       else
3788         sprintf (buffer + strlen (buffer), "%x", entry->name_id.id);
3789     }
3790
3791   return buffer;
3792 }
3793
3794 /* *sigh* Windows resource strings are special.  Only the top 28-bits of
3795    their ID is stored in the NAME entry.  The bottom four bits are used as
3796    an index into unicode string table that makes up the data of the leaf.
3797    So identical type-name-lang string resources may not actually be
3798    identical at all.
3799
3800    This function is called when we have detected two string resources with
3801    match top-28-bit IDs.  We have to scan the string tables inside the leaves
3802    and discover if there are any real collisions.  If there are then we report
3803    them and return FALSE.  Otherwise we copy any strings from B into A and
3804    then return TRUE.  */
3805
3806 static bfd_boolean
3807 rsrc_merge_string_entries (rsrc_entry * a ATTRIBUTE_UNUSED,
3808                            rsrc_entry * b ATTRIBUTE_UNUSED)
3809 {
3810   unsigned int copy_needed = 0;
3811   unsigned int i;
3812   bfd_byte * astring;
3813   bfd_byte * bstring;
3814   bfd_byte * new_data;
3815   bfd_byte * nstring;
3816
3817   /* Step one: Find out what we have to do.  */
3818   BFD_ASSERT (! a->is_dir);
3819   astring = a->value.leaf->data;
3820
3821   BFD_ASSERT (! b->is_dir);
3822   bstring = b->value.leaf->data;
3823
3824   for (i = 0; i < 16; i++)
3825     {
3826       unsigned int alen = astring[0] + (astring[1] << 8);
3827       unsigned int blen = bstring[0] + (bstring[1] << 8);
3828
3829       if (alen == 0)
3830         {
3831           copy_needed += blen * 2;
3832         }
3833       else if (blen == 0)
3834         ;
3835       else if (alen != blen)
3836         /* FIXME: Should we continue the loop in order to report other duplicates ?  */
3837         break;
3838       /* alen == blen != 0.  We might have two identical strings.  If so we
3839          can ignore the second one.  There is no need for wchar_t vs UTF-16
3840          theatrics here - we are only interested in (case sensitive) equality.  */
3841       else if (memcmp (astring + 2, bstring + 2, alen * 2) != 0)
3842         break;
3843
3844       astring += (alen + 1) * 2;
3845       bstring += (blen + 1) * 2;
3846     }
3847
3848   if (i != 16)
3849     {
3850       if (a->parent != NULL
3851           && a->parent->entry != NULL
3852           && !a->parent->entry->is_name)
3853         _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3854                             ((a->parent->entry->name_id.id - 1) << 4) + i);
3855       return FALSE;
3856     }
3857
3858   if (copy_needed == 0)
3859     return TRUE;
3860
3861   /* If we reach here then A and B must both have non-colliding strings.
3862      (We never get string resources with fully empty string tables).
3863      We need to allocate an extra COPY_NEEDED bytes in A and then bring
3864      in B's strings.  */
3865   new_data = bfd_malloc (a->value.leaf->size + copy_needed);
3866   if (new_data == NULL)
3867     return FALSE;
3868
3869   nstring = new_data;
3870   astring = a->value.leaf->data;
3871   bstring = b->value.leaf->data;
3872
3873   for (i = 0; i < 16; i++)
3874     {
3875       unsigned int alen = astring[0] + (astring[1] << 8);
3876       unsigned int blen = bstring[0] + (bstring[1] << 8);
3877
3878       if (alen != 0)
3879         {
3880           memcpy (nstring, astring, (alen + 1) * 2);
3881           nstring += (alen + 1) * 2;
3882         }
3883       else if (blen != 0)
3884         {
3885           memcpy (nstring, bstring, (blen + 1) * 2);
3886           nstring += (blen + 1) * 2;
3887         }
3888       else
3889         {
3890           * nstring++ = 0;
3891           * nstring++ = 0;
3892         }
3893
3894       astring += (alen + 1) * 2;
3895       bstring += (blen + 1) * 2;
3896     }
3897
3898   BFD_ASSERT (nstring - new_data == (signed) (a->value.leaf->size + copy_needed));
3899
3900   free (a->value.leaf->data);
3901   a->value.leaf->data = new_data;
3902   a->value.leaf->size += copy_needed;
3903
3904   return TRUE;
3905 }
3906
3907 static void rsrc_merge (rsrc_entry *, rsrc_entry *);
3908
3909 /* Sort the entries in given part of the directory.
3910    We use an old fashioned bubble sort because we are dealing
3911    with lists and we want to handle matches specially.  */
3912
3913 static void
3914 rsrc_sort_entries (rsrc_dir_chain *  chain,
3915                    bfd_boolean       is_name,
3916                    rsrc_directory *  dir)
3917 {
3918   rsrc_entry * entry;
3919   rsrc_entry * next;
3920   rsrc_entry ** points_to_entry;
3921   bfd_boolean swapped;
3922
3923   if (chain->num_entries < 2)
3924     return;
3925
3926   do
3927     {
3928       swapped = FALSE;
3929       points_to_entry = & chain->first_entry;
3930       entry = * points_to_entry;
3931       next  = entry->next_entry;
3932
3933       do
3934         {
3935           signed int cmp = rsrc_cmp (is_name, entry, next);
3936
3937           if (cmp > 0)
3938             {
3939               entry->next_entry = next->next_entry;
3940               next->next_entry = entry;
3941               * points_to_entry = next;
3942               points_to_entry = & next->next_entry;
3943               next = entry->next_entry;
3944               swapped = TRUE;
3945             }
3946           else if (cmp == 0)
3947             {
3948               if (entry->is_dir && next->is_dir)
3949                 {
3950                   /* When we encounter identical directory entries we have to
3951                      merge them together.  The exception to this rule is for
3952                      resource manifests - there can only be one of these,
3953                      even if they differ in language.  Zero-language manifests
3954                      are assumed to be default manifests (provided by the
3955                      Cygwin/MinGW build system) and these can be silently dropped,
3956                      unless that would reduce the number of manifests to zero.
3957                      There should only ever be one non-zero lang manifest -
3958                      if there are more it is an error.  A non-zero lang
3959                      manifest takes precedence over a default manifest.  */
3960                   if (!entry->is_name
3961                       && entry->name_id.id == 1
3962                       && dir != NULL
3963                       && dir->entry != NULL
3964                       && !dir->entry->is_name
3965                       && dir->entry->name_id.id == 0x18)
3966                     {
3967                       if (next->value.directory->names.num_entries == 0
3968                           && next->value.directory->ids.num_entries == 1
3969                           && !next->value.directory->ids.first_entry->is_name
3970                           && next->value.directory->ids.first_entry->name_id.id == 0)
3971                         /* Fall through so that NEXT is dropped.  */
3972                         ;
3973                       else if (entry->value.directory->names.num_entries == 0
3974                                && entry->value.directory->ids.num_entries == 1
3975                                && !entry->value.directory->ids.first_entry->is_name
3976                                && entry->value.directory->ids.first_entry->name_id.id == 0)
3977                         {
3978                           /* Swap ENTRY and NEXT.  Then fall through so that the old ENTRY is dropped.  */
3979                           entry->next_entry = next->next_entry;
3980                           next->next_entry = entry;
3981                           * points_to_entry = next;
3982                           points_to_entry = & next->next_entry;
3983                           next = entry->next_entry;
3984                           swapped = TRUE;
3985                         }
3986                       else
3987                         {
3988                           _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3989                           bfd_set_error (bfd_error_file_truncated);
3990                           return;
3991                         }
3992
3993                       /* Unhook NEXT from the chain.  */
3994                       /* FIXME: memory loss here.  */
3995                       entry->next_entry = next->next_entry;
3996                       chain->num_entries --;
3997                       if (chain->num_entries < 2)
3998                         return;
3999                       next = next->next_entry;
4000                     }
4001                   else
4002                     rsrc_merge (entry, next);
4003                 }
4004               else if (entry->is_dir != next->is_dir)
4005                 {
4006                   _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4007                   bfd_set_error (bfd_error_file_truncated);
4008                   return;
4009                 }
4010               else
4011                 {
4012                   /* Otherwise with identical leaves we issue an error
4013                      message - because there should never be duplicates.
4014                      The exception is Type 18/Name 1/Lang 0 which is the
4015                      defaul manifest - this can just be dropped.  */
4016                   if (!entry->is_name
4017                       && entry->name_id.id == 0
4018                       && dir != NULL
4019                       && dir->entry != NULL
4020                       && !dir->entry->is_name
4021                       && dir->entry->name_id.id == 1
4022                       && dir->entry->parent != NULL
4023                       && dir->entry->parent->entry != NULL
4024                       && !dir->entry->parent->entry->is_name
4025                       && dir->entry->parent->entry->name_id.id == 0x18 /* RT_MANIFEST */)
4026                     ;
4027                   else if (dir != NULL
4028                            && dir->entry != NULL
4029                            && dir->entry->parent != NULL
4030                            && dir->entry->parent->entry != NULL
4031                            && !dir->entry->parent->entry->is_name
4032                            && dir->entry->parent->entry->name_id.id == 0x6 /* RT_STRING */)
4033                     {
4034                       /* Strings need special handling.  */
4035                       if (! rsrc_merge_string_entries (entry, next))
4036                         {
4037                           /* _bfd_error_handler should have been called inside merge_strings.  */
4038                           bfd_set_error (bfd_error_file_truncated);
4039                           return;
4040                         }
4041                     }
4042                   else
4043                     {
4044                       if (dir == NULL
4045                           || dir->entry == NULL
4046                           || dir->entry->parent == NULL
4047                           || dir->entry->parent->entry == NULL)
4048                         _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4049                       else
4050                         _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4051                                             rsrc_resource_name (entry, dir));
4052                       bfd_set_error (bfd_error_file_truncated);
4053                       return;
4054                     }
4055                 }
4056
4057               /* Unhook NEXT from the chain.  */
4058               entry->next_entry = next->next_entry;
4059               chain->num_entries --;
4060               if (chain->num_entries < 2)
4061                 return;
4062               next = next->next_entry;
4063             }
4064           else
4065             {
4066               points_to_entry = & entry->next_entry;
4067               entry = next;
4068               next = next->next_entry;
4069             }
4070         }
4071       while (next);
4072
4073       chain->last_entry = entry;
4074     }
4075   while (swapped);
4076 }
4077
4078 /* Attach B's chain onto A.  */
4079 static void
4080 rsrc_attach_chain (rsrc_dir_chain * achain, rsrc_dir_chain * bchain)
4081 {
4082   if (bchain->num_entries == 0)
4083     return;
4084
4085   achain->num_entries += bchain->num_entries;
4086
4087   if (achain->first_entry == NULL)
4088     {
4089       achain->first_entry = bchain->first_entry;
4090       achain->last_entry  = bchain->last_entry;
4091     }
4092   else
4093     {
4094       achain->last_entry->next_entry = bchain->first_entry;
4095       achain->last_entry = bchain->last_entry;
4096     }
4097
4098   bchain->num_entries = 0;
4099   bchain->first_entry = bchain->last_entry = NULL;
4100 }
4101
4102 static void
4103 rsrc_merge (struct rsrc_entry * a, struct rsrc_entry * b)
4104 {
4105   rsrc_directory * adir;
4106   rsrc_directory * bdir;
4107
4108   BFD_ASSERT (a->is_dir);
4109   BFD_ASSERT (b->is_dir);
4110
4111   adir = a->value.directory;
4112   bdir = b->value.directory;
4113
4114   if (adir->characteristics != bdir->characteristics)
4115     {
4116       _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4117       bfd_set_error (bfd_error_file_truncated);
4118       return;
4119     }
4120
4121   if (adir->major != bdir->major || adir->minor != bdir->minor)
4122     {
4123       _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4124       bfd_set_error (bfd_error_file_truncated);
4125       return;
4126     }
4127
4128   /* Attach B's name chain to A.  */
4129   rsrc_attach_chain (& adir->names, & bdir->names);
4130
4131   /* Attach B's ID chain to A.  */
4132   rsrc_attach_chain (& adir->ids, & bdir->ids);
4133
4134   /* Now sort A's entries.  */
4135   rsrc_sort_entries (& adir->names, TRUE, adir);
4136   rsrc_sort_entries (& adir->ids, FALSE, adir);
4137 }
4138
4139 /* Check the .rsrc section.  If it contains multiple concatenated
4140    resources then we must merge them properly.  Otherwise Windows
4141    will ignore all but the first set.  */
4142
4143 static void
4144 rsrc_process_section (bfd * abfd,
4145                       struct coff_final_link_info * pfinfo)
4146 {
4147   rsrc_directory    new_table;
4148   bfd_size_type     size;
4149   asection *        sec;
4150   pe_data_type *    pe;
4151   bfd_vma           rva_bias;
4152   bfd_byte *        data;
4153   bfd_byte *        datastart;
4154   bfd_byte *        dataend;
4155   bfd_byte *        new_data;
4156   unsigned int      num_resource_sets;
4157   rsrc_directory *  type_tables;
4158   rsrc_write_data   write_data;
4159   unsigned int      indx;
4160   bfd *             input;
4161   unsigned int      num_input_rsrc = 0;
4162   unsigned int      max_num_input_rsrc = 4;
4163   ptrdiff_t *       rsrc_sizes = NULL;
4164
4165   new_table.names.num_entries = 0;
4166   new_table.ids.num_entries = 0;
4167
4168   sec = bfd_get_section_by_name (abfd, ".rsrc");
4169   if (sec == NULL || (size = sec->rawsize) == 0)
4170     return;
4171
4172   pe = pe_data (abfd);
4173   if (pe == NULL)
4174     return;
4175
4176   rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4177
4178   data = bfd_malloc (size);
4179   if (data == NULL)
4180     return;
4181
4182   datastart = data;
4183
4184   if (! bfd_get_section_contents (abfd, sec, data, 0, size))
4185     goto end;
4186
4187   /* Step zero: Scan the input bfds looking for .rsrc sections and record
4188      their lengths.  Note - we rely upon the fact that the linker script
4189      does *not* sort the input .rsrc sections, so that the order in the
4190      linkinfo list matches the order in the output .rsrc section.
4191
4192      We need to know the lengths because each input .rsrc section has padding
4193      at the end of a variable amount.  (It does not appear to be based upon
4194      the section alignment or the file alignment).  We need to skip any
4195      padding bytes when parsing the input .rsrc sections.  */
4196   rsrc_sizes = bfd_malloc (max_num_input_rsrc * sizeof * rsrc_sizes);
4197   if (rsrc_sizes == NULL)
4198     goto end;
4199
4200   for (input = pfinfo->info->input_bfds;
4201        input != NULL;
4202        input = input->link.next)
4203     {
4204       asection * rsrc_sec = bfd_get_section_by_name (input, ".rsrc");
4205
4206       /* PR 18372 - skip discarded .rsrc sections.  */
4207       if (rsrc_sec != NULL && !discarded_section (rsrc_sec))
4208         {
4209           if (num_input_rsrc == max_num_input_rsrc)
4210             {
4211               max_num_input_rsrc += 10;
4212               rsrc_sizes = bfd_realloc (rsrc_sizes, max_num_input_rsrc
4213                                         * sizeof * rsrc_sizes);
4214               if (rsrc_sizes == NULL)
4215                 goto end;
4216             }
4217
4218           BFD_ASSERT (rsrc_sec->size > 0);
4219           rsrc_sizes [num_input_rsrc ++] = rsrc_sec->size;
4220         }
4221     }
4222
4223   if (num_input_rsrc < 2)
4224     goto end;
4225
4226   /* Step one: Walk the section, computing the size of the tables,
4227      leaves and data and decide if we need to do anything.  */
4228   dataend = data + size;
4229   num_resource_sets = 0;
4230
4231   while (data < dataend)
4232     {
4233       bfd_byte * p = data;
4234
4235       data = rsrc_count_directory (abfd, data, data, dataend, rva_bias);
4236
4237       if (data > dataend)
4238         {
4239           /* Corrupted .rsrc section - cannot merge.  */
4240           _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4241                               abfd);
4242           bfd_set_error (bfd_error_file_truncated);
4243           goto end;
4244         }
4245
4246       if ((data - p) > rsrc_sizes [num_resource_sets])
4247         {
4248           _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4249                               abfd);
4250           bfd_set_error (bfd_error_file_truncated);
4251           goto end;
4252         }
4253       /* FIXME: Should we add a check for "data - p" being much smaller
4254          than rsrc_sizes[num_resource_sets] ?  */
4255
4256       data = p + rsrc_sizes[num_resource_sets];
4257       rva_bias += data - p;
4258       ++ num_resource_sets;
4259     }
4260   BFD_ASSERT (num_resource_sets == num_input_rsrc);
4261
4262   /* Step two: Walk the data again, building trees of the resources.  */
4263   data = datastart;
4264   rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4265
4266   type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables);
4267   if (type_tables == NULL)
4268     goto end;
4269
4270   indx = 0;
4271   while (data < dataend)
4272     {
4273       bfd_byte * p = data;
4274
4275       (void) rsrc_parse_directory (abfd, type_tables + indx, data, data,
4276                                    dataend, rva_bias, NULL);
4277       data = p + rsrc_sizes[indx];
4278       rva_bias += data - p;
4279       ++ indx;
4280     }
4281   BFD_ASSERT (indx == num_resource_sets);
4282
4283   /* Step three: Merge the top level tables (there can be only one).
4284
4285      We must ensure that the merged entries are in ascending order.
4286
4287      We also thread the top level table entries from the old tree onto
4288      the new table, so that they can be pulled off later.  */
4289
4290   /* FIXME: Should we verify that all type tables are the same ?  */
4291   new_table.characteristics = type_tables[0].characteristics;
4292   new_table.time            = type_tables[0].time;
4293   new_table.major           = type_tables[0].major;
4294   new_table.minor           = type_tables[0].minor;
4295
4296   /* Chain the NAME entries onto the table.  */
4297   new_table.names.first_entry = NULL;
4298   new_table.names.last_entry = NULL;
4299
4300   for (indx = 0; indx < num_resource_sets; indx++)
4301     rsrc_attach_chain (& new_table.names, & type_tables[indx].names);
4302
4303   rsrc_sort_entries (& new_table.names, TRUE, & new_table);
4304
4305   /* Chain the ID entries onto the table.  */
4306   new_table.ids.first_entry = NULL;
4307   new_table.ids.last_entry = NULL;
4308
4309   for (indx = 0; indx < num_resource_sets; indx++)
4310     rsrc_attach_chain (& new_table.ids, & type_tables[indx].ids);
4311
4312   rsrc_sort_entries (& new_table.ids, FALSE, & new_table);
4313
4314   /* Step four: Create new contents for the .rsrc section.  */
4315   /* Step four point one: Compute the size of each region of the .rsrc section.
4316      We do this now, rather than earlier, as the merging above may have dropped
4317      some entries.  */
4318   sizeof_leaves = sizeof_strings = sizeof_tables_and_entries = 0;
4319   rsrc_compute_region_sizes (& new_table);
4320   /* We increment sizeof_strings to make sure that resource data
4321      starts on an 8-byte boundary.  FIXME: Is this correct ?  */
4322   sizeof_strings = (sizeof_strings + 7) & ~ 7;
4323
4324   new_data = bfd_zalloc (abfd, size);
4325   if (new_data == NULL)
4326     goto end;
4327
4328   write_data.abfd        = abfd;
4329   write_data.datastart   = new_data;
4330   write_data.next_table  = new_data;
4331   write_data.next_leaf   = new_data + sizeof_tables_and_entries;
4332   write_data.next_string = write_data.next_leaf + sizeof_leaves;
4333   write_data.next_data   = write_data.next_string + sizeof_strings;
4334   write_data.rva_bias    = sec->vma - pe->pe_opthdr.ImageBase;
4335
4336   rsrc_write_directory (& write_data, & new_table);
4337
4338   /* Step five: Replace the old contents with the new.
4339      We don't recompute the size as it's too late here to shrink section.
4340      See PR ld/20193 for more details.  */
4341   bfd_set_section_contents (pfinfo->output_bfd, sec, new_data, 0, size);
4342   sec->size = sec->rawsize = size;
4343
4344  end:
4345   /* Step six: Free all the memory that we have used.  */
4346   /* FIXME: Free the resource tree, if we have one.  */
4347   free (datastart);
4348   free (rsrc_sizes);
4349 }
4350
4351 /* Handle the .idata section and other things that need symbol table
4352    access.  */
4353
4354 bfd_boolean
4355 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
4356 {
4357   struct coff_link_hash_entry *h1;
4358   struct bfd_link_info *info = pfinfo->info;
4359   bfd_boolean result = TRUE;
4360
4361   /* There are a few fields that need to be filled in now while we
4362      have symbol table access.
4363
4364      The .idata subsections aren't directly available as sections, but
4365      they are in the symbol table, so get them from there.  */
4366
4367   /* The import directory.  This is the address of .idata$2, with size
4368      of .idata$2 + .idata$3.  */
4369   h1 = coff_link_hash_lookup (coff_hash_table (info),
4370                               ".idata$2", FALSE, FALSE, TRUE);
4371   if (h1 != NULL)
4372     {
4373       /* PR ld/2729: We cannot rely upon all the output sections having been
4374          created properly, so check before referencing them.  Issue a warning
4375          message for any sections tht could not be found.  */
4376       if ((h1->root.type == bfd_link_hash_defined
4377            || h1->root.type == bfd_link_hash_defweak)
4378           && h1->root.u.def.section != NULL
4379           && h1->root.u.def.section->output_section != NULL)
4380         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
4381           (h1->root.u.def.value
4382            + h1->root.u.def.section->output_section->vma
4383            + h1->root.u.def.section->output_offset);
4384       else
4385         {
4386           _bfd_error_handler
4387             (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4388              abfd);
4389           result = FALSE;
4390         }
4391
4392       h1 = coff_link_hash_lookup (coff_hash_table (info),
4393                                   ".idata$4", FALSE, FALSE, TRUE);
4394       if (h1 != NULL
4395           && (h1->root.type == bfd_link_hash_defined
4396            || h1->root.type == bfd_link_hash_defweak)
4397           && h1->root.u.def.section != NULL
4398           && h1->root.u.def.section->output_section != NULL)
4399         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
4400           ((h1->root.u.def.value
4401             + h1->root.u.def.section->output_section->vma
4402             + h1->root.u.def.section->output_offset)
4403            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
4404       else
4405         {
4406           _bfd_error_handler
4407             (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4408              abfd);
4409           result = FALSE;
4410         }
4411
4412       /* The import address table.  This is the size/address of
4413          .idata$5.  */
4414       h1 = coff_link_hash_lookup (coff_hash_table (info),
4415                                   ".idata$5", FALSE, FALSE, TRUE);
4416       if (h1 != NULL
4417           && (h1->root.type == bfd_link_hash_defined
4418            || h1->root.type == bfd_link_hash_defweak)
4419           && h1->root.u.def.section != NULL
4420           && h1->root.u.def.section->output_section != NULL)
4421         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4422           (h1->root.u.def.value
4423            + h1->root.u.def.section->output_section->vma
4424            + h1->root.u.def.section->output_offset);
4425       else
4426         {
4427           _bfd_error_handler
4428             (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4429              abfd);
4430           result = FALSE;
4431         }
4432
4433       h1 = coff_link_hash_lookup (coff_hash_table (info),
4434                                   ".idata$6", FALSE, FALSE, TRUE);
4435       if (h1 != NULL
4436           && (h1->root.type == bfd_link_hash_defined
4437            || h1->root.type == bfd_link_hash_defweak)
4438           && h1->root.u.def.section != NULL
4439           && h1->root.u.def.section->output_section != NULL)
4440         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4441           ((h1->root.u.def.value
4442             + h1->root.u.def.section->output_section->vma
4443             + h1->root.u.def.section->output_offset)
4444            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
4445       else
4446         {
4447           _bfd_error_handler
4448             (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4449              abfd);
4450           result = FALSE;
4451         }
4452     }
4453   else
4454     {
4455       h1 = coff_link_hash_lookup (coff_hash_table (info),
4456                                   "__IAT_start__", FALSE, FALSE, TRUE);
4457       if (h1 != NULL
4458           && (h1->root.type == bfd_link_hash_defined
4459            || h1->root.type == bfd_link_hash_defweak)
4460           && h1->root.u.def.section != NULL
4461           && h1->root.u.def.section->output_section != NULL)
4462         {
4463           bfd_vma iat_va;
4464
4465           iat_va =
4466             (h1->root.u.def.value
4467              + h1->root.u.def.section->output_section->vma
4468              + h1->root.u.def.section->output_offset);
4469
4470           h1 = coff_link_hash_lookup (coff_hash_table (info),
4471                                       "__IAT_end__", FALSE, FALSE, TRUE);
4472           if (h1 != NULL
4473               && (h1->root.type == bfd_link_hash_defined
4474                || h1->root.type == bfd_link_hash_defweak)
4475               && h1->root.u.def.section != NULL
4476               && h1->root.u.def.section->output_section != NULL)
4477             {
4478               pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4479                 ((h1->root.u.def.value
4480                   + h1->root.u.def.section->output_section->vma
4481                   + h1->root.u.def.section->output_offset)
4482                  - iat_va);
4483               if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
4484                 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4485                   iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
4486             }
4487           else
4488             {
4489               _bfd_error_handler
4490                 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4491                    " because .idata$6 is missing"), abfd);
4492               result = FALSE;
4493             }
4494         }
4495     }
4496
4497   h1 = coff_link_hash_lookup (coff_hash_table (info),
4498                               (bfd_get_symbol_leading_char (abfd) != 0
4499                                ? "__tls_used" : "_tls_used"),
4500                               FALSE, FALSE, TRUE);
4501   if (h1 != NULL)
4502     {
4503       if ((h1->root.type == bfd_link_hash_defined
4504            || h1->root.type == bfd_link_hash_defweak)
4505           && h1->root.u.def.section != NULL
4506           && h1->root.u.def.section->output_section != NULL)
4507         pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
4508           (h1->root.u.def.value
4509            + h1->root.u.def.section->output_section->vma
4510            + h1->root.u.def.section->output_offset
4511            - pe_data (abfd)->pe_opthdr.ImageBase);
4512       else
4513         {
4514           _bfd_error_handler
4515             (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4516              abfd);
4517           result = FALSE;
4518         }
4519      /* According to PECOFF sepcifications by Microsoft version 8.2
4520         the TLS data directory consists of 4 pointers, followed
4521         by two 4-byte integer. This implies that the total size
4522         is different for 32-bit and 64-bit executables.  */
4523 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4524       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
4525 #else
4526       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
4527 #endif
4528     }
4529
4530 /* If there is a .pdata section and we have linked pdata finally, we
4531      need to sort the entries ascending.  */
4532 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4533   {
4534     asection *sec = bfd_get_section_by_name (abfd, ".pdata");
4535
4536     if (sec)
4537       {
4538         bfd_size_type x = sec->rawsize;
4539         bfd_byte *tmp_data = NULL;
4540
4541         if (x)
4542           tmp_data = bfd_malloc (x);
4543
4544         if (tmp_data != NULL)
4545           {
4546             if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
4547               {
4548                 qsort (tmp_data,
4549                        (size_t) (x / 12),
4550                        12, sort_x64_pdata);
4551                 bfd_set_section_contents (pfinfo->output_bfd, sec,
4552                                           tmp_data, 0, x);
4553               }
4554             free (tmp_data);
4555           }
4556         else
4557           result = FALSE;
4558       }
4559   }
4560 #endif
4561
4562   rsrc_process_section (abfd, pfinfo);
4563
4564   /* If we couldn't find idata$2, we either have an excessively
4565      trivial program or are in DEEP trouble; we have to assume trivial
4566      program....  */
4567   return result;
4568 }