bfd/peXXigen.c

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