bfd/peXXigen.c

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