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