bfd/peXXigen.c

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