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