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