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 + (1LL << 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 > ((1L << 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
2149 static bfd_byte *
2150 rsrc_print_resource_directory (FILE * , bfd *, unsigned int,
2151                                bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma);
2152
2153 static bfd_byte *
2154 rsrc_print_resource_entries (FILE *        file,
2155                              bfd *         abfd,
2156                              unsigned int  indent,
2157                              bfd_boolean   is_name,
2158                              bfd_byte *    datastart,
2159                              bfd_byte *    data,
2160                              bfd_byte *    dataend,
2161                              bfd_vma       rva_bias)
2162 {
2163   unsigned long entry, addr, size;
2164
2165   if (data + 8 >= dataend)
2166     return dataend + 1;
2167
2168   fprintf (file, _("%*.s Entry: "), indent, " ");
2169
2170   entry = (long) bfd_get_32 (abfd, data);
2171   if (is_name)
2172     {
2173       bfd_byte * name;
2174
2175       /* Note - the documenation says that this field is an RVA value
2176          but windres appears to produce a section relative offset with
2177          the top bit set.  Support both styles for now.  */
2178       if (HighBitSet (entry))
2179         name = datastart + WithoutHighBit (entry);
2180       else
2181         name = datastart + entry - rva_bias;
2182
2183       if (name + 2 < dataend)
2184         {
2185           unsigned int len;
2186           len = bfd_get_16 (abfd, name);
2187
2188           fprintf (file, _("name: [val: %08lx len %d]: "), entry, len);
2189           if (name + 2 + len * 2 < dataend)
2190             {
2191               /* This strange loop is to cope with multibyte characters.  */
2192               while (len --)
2193                 {
2194                   name += 2;
2195                   fprintf (file, "%.1s", name);
2196                 }
2197             }
2198           else
2199             fprintf (file, _("<corrupt string length: %#x>"), len);
2200         }
2201       else
2202         fprintf (file, _("<corrupt string offset: %#lx>"), entry);
2203     }
2204   else
2205     fprintf (file, _("ID: %#08lx"), entry);
2206
2207   entry = (long) bfd_get_32 (abfd, data + 4);
2208   fprintf (file, _(", Value: %#08lx\n"), entry);
2209
2210   if (HighBitSet  (entry))
2211     return rsrc_print_resource_directory (file, abfd, indent + 1,
2212                                           datastart,
2213                                           datastart + WithoutHighBit (entry),
2214                                           dataend, rva_bias);
2215
2216   if (datastart + entry + 16 >= dataend)
2217     return dataend + 1;
2218
2219   fprintf (file, _("%*.s  Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2220            indent, " ",
2221            addr = (long) bfd_get_32 (abfd, datastart + entry),
2222            size = (long) bfd_get_32 (abfd, datastart + entry + 4),
2223            (int) bfd_get_32 (abfd, datastart + entry + 8));
2224
2225   /* Check that the reserved entry is 0.  */
2226   if (bfd_get_32 (abfd, datastart + entry + 12) != 0
2227       /* And that the data address/size is valid too.  */
2228       || (datastart + (addr - rva_bias) + size > dataend))
2229     return dataend + 1;
2230
2231   return datastart + (addr - rva_bias) + size;
2232 }
2233
2234 #define max(a,b) ((a) > (b) ? (a) : (b))
2235 #define min(a,b) ((a) < (b) ? (a) : (b))
2236
2237 static bfd_byte *
2238 rsrc_print_resource_directory (FILE *        file,
2239                                bfd *         abfd,
2240                                unsigned int  indent,
2241                                bfd_byte *    datastart,
2242                                bfd_byte *    data,
2243                                bfd_byte *    dataend,
2244                                bfd_vma       rva_bias)
2245 {
2246   unsigned int num_names, num_ids;
2247   bfd_byte * highest_data = data;
2248
2249   if (data + 16 >= dataend)
2250     return dataend + 1;
2251
2252   fprintf (file, "%*.s ", indent, " ");
2253   switch (indent)
2254     {
2255     case 0: fprintf (file, "Type"); break;
2256     case 2: fprintf (file, "Name"); break;
2257     case 4: fprintf (file, "Language"); break;
2258     default: fprintf (file, "<unknown>"); break;
2259     }
2260
2261   fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2262            (int) bfd_get_32 (abfd, data),
2263            (long) bfd_get_32 (abfd, data + 4),
2264            (int)  bfd_get_16 (abfd, data + 8),
2265            (int)  bfd_get_16 (abfd, data + 10),
2266            num_names = (int) bfd_get_16 (abfd, data + 12),
2267            num_ids =   (int) bfd_get_16 (abfd, data + 14));
2268   data += 16;
2269
2270   while (num_names --)
2271     {
2272       bfd_byte * entry_end;
2273
2274       entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE,
2275                                                datastart, data, dataend, rva_bias);
2276       data += 8;
2277       highest_data = max (highest_data, entry_end);
2278       if (entry_end >= dataend)
2279         return entry_end;
2280     }
2281
2282   while (num_ids --)
2283     {
2284       bfd_byte * entry_end;
2285
2286       entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE,
2287                                                datastart, data, dataend,
2288                                                rva_bias);
2289       data += 8;
2290       highest_data = max (highest_data, entry_end);
2291       if (entry_end >= dataend)
2292         return entry_end;
2293     }
2294
2295   return max (highest_data, data);
2296 }
2297
2298 /* Display the contents of a .rsrc section.  We do not try to
2299    reproduce the resources, windres does that.  Instead we dump
2300    the tables in a human readable format.  */
2301
2302 static bfd_boolean
2303 rsrc_print_section (bfd * abfd, void * vfile)
2304 {
2305   bfd_vma rva_bias;
2306   pe_data_type * pe;
2307   FILE * file = (FILE *) vfile;
2308   bfd_size_type datasize;
2309   asection * section;
2310   bfd_byte * data;
2311   bfd_byte * dataend;
2312   bfd_byte * datastart;
2313
2314   pe = pe_data (abfd);
2315   if (pe == NULL)
2316     return TRUE;
2317
2318   section = bfd_get_section_by_name (abfd, ".rsrc");
2319   if (section == NULL)
2320     return TRUE;
2321   if (!(section->flags & SEC_HAS_CONTENTS))
2322     return TRUE;
2323
2324   datasize = section->size;
2325   if (datasize == 0)
2326     return TRUE;
2327
2328   rva_bias = section->vma - pe->pe_opthdr.ImageBase;
2329
2330   if (! bfd_malloc_and_get_section (abfd, section, & data))
2331     {
2332       if (data != NULL)
2333         free (data);
2334       return FALSE;
2335     }
2336   datastart = data;
2337   dataend = data + datasize;
2338
2339   fflush (file);
2340   fprintf (file, "\nThe .rsrc Resource Directory section:\n");
2341
2342   while (data < dataend)
2343     {
2344       bfd_byte * p = data;
2345
2346       data = rsrc_print_resource_directory (file, abfd, 0, data, data,
2347                                             dataend, rva_bias);
2348
2349       if (data == dataend + 1)
2350         fprintf (file, _("Corrupt .rsrc section detected!\n"));
2351       else
2352         {
2353           /* Align data before continuing.  */
2354           int align = (1 << section->alignment_power) - 1;
2355
2356           data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align);
2357           rva_bias += data - p;
2358
2359           /* For reasons that are unclear .rsrc sections are sometimes created
2360              aligned to a 1^3 boundary even when their alignment is set at
2361              1^2.  Catch that case here before we issue a spurious warning
2362              message.  */
2363           if (data == (dataend - 4))
2364             data = dataend;
2365           else if (data < dataend)
2366             fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2367         }
2368     }
2369
2370   free (datastart);
2371   return TRUE;
2372 }
2373
2374 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2375
2376 static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] =
2377 {
2378   "Unknown",
2379   "COFF",
2380   "CodeView",
2381   "FPO",
2382   "Misc",
2383   "Exception",
2384   "Fixup",
2385   "OMAP-to-SRC",
2386   "OMAP-from-SRC",
2387   "Borland",
2388   "Reserved",
2389   "CLSID",
2390 };
2391
2392 static bfd_boolean
2393 pe_print_debugdata (bfd * abfd, void * vfile)
2394 {
2395   FILE *file = (FILE *) vfile;
2396   pe_data_type *pe = pe_data (abfd);
2397   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
2398   asection *section;
2399   bfd_byte *data = 0;
2400   bfd_size_type dataoff;
2401   unsigned int i;
2402
2403   bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
2404   bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
2405
2406   if (size == 0)
2407     return TRUE;
2408
2409   addr += extra->ImageBase;
2410   for (section = abfd->sections; section != NULL; section = section->next)
2411     {
2412       if ((addr >= section->vma) && (addr < (section->vma + section->size)))
2413         break;
2414     }
2415
2416   if (section == NULL)
2417     {
2418       fprintf (file,
2419                _("\nThere is a debug directory, but the section containing it could not be found\n"));
2420       return TRUE;
2421     }
2422
2423   fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2424            section->name, (unsigned long) addr);
2425
2426   dataoff = addr - section->vma;
2427
2428   fprintf (file,
2429            _("Type                Size     Rva      Offset\n"));
2430
2431   /* Read the whole section. */
2432   if (!bfd_malloc_and_get_section (abfd, section, &data))
2433     {
2434       if (data != NULL)
2435         free (data);
2436       return FALSE;
2437     }
2438
2439   for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2440     {
2441       const char *type_name;
2442       struct external_IMAGE_DEBUG_DIRECTORY *ext
2443         = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
2444       struct internal_IMAGE_DEBUG_DIRECTORY idd;
2445
2446       _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
2447
2448       if ((idd.Type) > IMAGE_NUMBEROF_DEBUG_TYPES)
2449         type_name = debug_type_names[0];
2450       else
2451         type_name = debug_type_names[idd.Type];
2452
2453       fprintf (file, " %2ld  %14s %08lx %08lx %08lx\n",
2454                idd.Type, type_name, idd.SizeOfData,
2455                idd.AddressOfRawData, idd.PointerToRawData);
2456
2457       if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
2458         {
2459           char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1];
2460           char buffer[256 + 1];
2461           CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
2462
2463           /* The debug entry doesn't have to have to be in a section,
2464              in which case AddressOfRawData is 0, so always use PointerToRawData.  */
2465           if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData,
2466                                                idd.SizeOfData, cvinfo))
2467             continue;
2468
2469           for (i = 0; i < cvinfo->SignatureLength; i++)
2470             sprintf (&signature[i*2], "%02x", cvinfo->Signature[i] & 0xff);
2471
2472           fprintf (file, "(format %c%c%c%c signature %s age %ld)\n",
2473                    buffer[0], buffer[1], buffer[2], buffer[3],
2474                    signature, cvinfo->Age);
2475         }
2476     }
2477
2478   if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0)
2479     fprintf (file,
2480             _("The debug directory size is not a multiple of the debug directory entry size\n"));
2481
2482   return TRUE;
2483 }
2484
2485 /* Print out the program headers.  */
2486
2487 bfd_boolean
2488 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2489 {
2490   FILE *file = (FILE *) vfile;
2491   int j;
2492   pe_data_type *pe = pe_data (abfd);
2493   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2494   const char *subsystem_name = NULL;
2495   const char *name;
2496
2497   /* The MS dumpbin program reportedly ands with 0xff0f before
2498      printing the characteristics field.  Not sure why.  No reason to
2499      emulate it here.  */
2500   fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2501 #undef PF
2502 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2503   PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2504   PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2505   PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2506   PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2507   PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2508   PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2509   PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2510   PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2511   PF (IMAGE_FILE_SYSTEM, "system file");
2512   PF (IMAGE_FILE_DLL, "DLL");
2513   PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2514 #undef PF
2515
2516   /* ctime implies '\n'.  */
2517   {
2518     time_t t = pe->coff.timestamp;
2519     fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2520   }
2521
2522 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2523 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2524 #endif
2525 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2526 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2527 #endif
2528 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2529 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2530 #endif
2531
2532   switch (i->Magic)
2533     {
2534     case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2535       name = "PE32";
2536       break;
2537     case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2538       name = "PE32+";
2539       break;
2540     case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2541       name = "ROM";
2542       break;
2543     default:
2544       name = NULL;
2545       break;
2546     }
2547   fprintf (file, "Magic\t\t\t%04x", i->Magic);
2548   if (name)
2549     fprintf (file, "\t(%s)",name);
2550   fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2551   fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2552   fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2553   fprintf (file, "SizeOfInitializedData\t%08lx\n",
2554            (unsigned long) i->SizeOfInitializedData);
2555   fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2556            (unsigned long) i->SizeOfUninitializedData);
2557   fprintf (file, "AddressOfEntryPoint\t");
2558   bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2559   fprintf (file, "\nBaseOfCode\t\t");
2560   bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2561 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2562   /* PE32+ does not have BaseOfData member!  */
2563   fprintf (file, "\nBaseOfData\t\t");
2564   bfd_fprintf_vma (abfd, file, i->BaseOfData);
2565 #endif
2566
2567   fprintf (file, "\nImageBase\t\t");
2568   bfd_fprintf_vma (abfd, file, i->ImageBase);
2569   fprintf (file, "\nSectionAlignment\t");
2570   bfd_fprintf_vma (abfd, file, i->SectionAlignment);
2571   fprintf (file, "\nFileAlignment\t\t");
2572   bfd_fprintf_vma (abfd, file, i->FileAlignment);
2573   fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2574   fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2575   fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2576   fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2577   fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2578   fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2579   fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2580   fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2581   fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2582   fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2583
2584   switch (i->Subsystem)
2585     {
2586     case IMAGE_SUBSYSTEM_UNKNOWN:
2587       subsystem_name = "unspecified";
2588       break;
2589     case IMAGE_SUBSYSTEM_NATIVE:
2590       subsystem_name = "NT native";
2591       break;
2592     case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2593       subsystem_name = "Windows GUI";
2594       break;
2595     case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2596       subsystem_name = "Windows CUI";
2597       break;
2598     case IMAGE_SUBSYSTEM_POSIX_CUI:
2599       subsystem_name = "POSIX CUI";
2600       break;
2601     case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2602       subsystem_name = "Wince CUI";
2603       break;
2604     // These are from UEFI Platform Initialization Specification 1.1.
2605     case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2606       subsystem_name = "EFI application";
2607       break;
2608     case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2609       subsystem_name = "EFI boot service driver";
2610       break;
2611     case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2612       subsystem_name = "EFI runtime driver";
2613       break;
2614     case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2615       subsystem_name = "SAL runtime driver";
2616       break;
2617     // This is from revision 8.0 of the MS PE/COFF spec
2618     case IMAGE_SUBSYSTEM_XBOX:
2619       subsystem_name = "XBOX";
2620       break;
2621     // Added default case for clarity - subsystem_name is NULL anyway.
2622     default:
2623       subsystem_name = NULL;
2624     }
2625
2626   fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2627   if (subsystem_name)
2628     fprintf (file, "\t(%s)", subsystem_name);
2629   fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2630   fprintf (file, "SizeOfStackReserve\t");
2631   bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
2632   fprintf (file, "\nSizeOfStackCommit\t");
2633   bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
2634   fprintf (file, "\nSizeOfHeapReserve\t");
2635   bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
2636   fprintf (file, "\nSizeOfHeapCommit\t");
2637   bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
2638   fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2639   fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2640            (unsigned long) i->NumberOfRvaAndSizes);
2641
2642   fprintf (file, "\nThe Data Directory\n");
2643   for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2644     {
2645       fprintf (file, "Entry %1x ", j);
2646       bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
2647       fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2648       fprintf (file, "%s\n", dir_names[j]);
2649     }
2650
2651   pe_print_idata (abfd, vfile);
2652   pe_print_edata (abfd, vfile);
2653   if (bfd_coff_have_print_pdata (abfd))
2654     bfd_coff_print_pdata (abfd, vfile);
2655   else
2656     pe_print_pdata (abfd, vfile);
2657   pe_print_reloc (abfd, vfile);
2658   pe_print_debugdata (abfd, file);
2659
2660   rsrc_print_section (abfd, vfile);
2661
2662   return TRUE;
2663 }
2664
2665 /* Copy any private info we understand from the input bfd
2666    to the output bfd.  */
2667
2668 bfd_boolean
2669 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2670 {
2671   pe_data_type *ipe, *ope;
2672
2673   /* One day we may try to grok other private data.  */
2674   if (ibfd->xvec->flavour != bfd_target_coff_flavour
2675       || obfd->xvec->flavour != bfd_target_coff_flavour)
2676     return TRUE;
2677
2678   ipe = pe_data (ibfd);
2679   ope = pe_data (obfd);
2680
2681   /* pe_opthdr is copied in copy_object.  */
2682   ope->dll = ipe->dll;
2683
2684   /* Don't copy input subsystem if output is different from input.  */
2685   if (obfd->xvec != ibfd->xvec)
2686     ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2687
2688   /* For strip: if we removed .reloc, we'll make a real mess of things
2689      if we don't remove this entry as well.  */
2690   if (! pe_data (obfd)->has_reloc_section)
2691     {
2692       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2693       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2694     }
2695
2696   /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2697      But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2698      won't be added.  */
2699   if (! pe_data (ibfd)->has_reloc_section
2700       && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
2701     pe_data (obfd)->dont_strip_reloc = 1;
2702
2703   return TRUE;
2704 }
2705
2706 /* Copy private section data.  */
2707
2708 bfd_boolean
2709 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2710                                        asection *isec,
2711                                        bfd *obfd,
2712                                        asection *osec)
2713 {
2714   if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2715       || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
2716     return TRUE;
2717
2718   if (coff_section_data (ibfd, isec) != NULL
2719       && pei_section_data (ibfd, isec) != NULL)
2720     {
2721       if (coff_section_data (obfd, osec) == NULL)
2722         {
2723           bfd_size_type amt = sizeof (struct coff_section_tdata);
2724           osec->used_by_bfd = bfd_zalloc (obfd, amt);
2725           if (osec->used_by_bfd == NULL)
2726             return FALSE;
2727         }
2728
2729       if (pei_section_data (obfd, osec) == NULL)
2730         {
2731           bfd_size_type amt = sizeof (struct pei_section_tdata);
2732           coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
2733           if (coff_section_data (obfd, osec)->tdata == NULL)
2734             return FALSE;
2735         }
2736
2737       pei_section_data (obfd, osec)->virt_size =
2738         pei_section_data (ibfd, isec)->virt_size;
2739       pei_section_data (obfd, osec)->pe_flags =
2740         pei_section_data (ibfd, isec)->pe_flags;
2741     }
2742
2743   return TRUE;
2744 }
2745
2746 void
2747 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
2748 {
2749   coff_get_symbol_info (abfd, symbol, ret);
2750 }
2751
2752 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
2753 static int
2754 sort_x64_pdata (const void *l, const void *r)
2755 {
2756   const char *lp = (const char *) l;
2757   const char *rp = (const char *) r;
2758   bfd_vma vl, vr;
2759   vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
2760   if (vl != vr)
2761     return (vl < vr ? -1 : 1);
2762   /* We compare just begin address.  */
2763   return 0;
2764 }
2765 #endif
2766 \f
2767 /* Functions to process a .rsrc section.  */
2768
2769 static unsigned int sizeof_leaves;
2770 static unsigned int sizeof_strings;
2771 static unsigned int sizeof_tables_and_entries;
2772
2773 static bfd_byte *
2774 rsrc_count_directory (bfd *, bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma);
2775
2776 static bfd_byte *
2777 rsrc_count_entries (bfd *          abfd,
2778                     bfd_boolean    is_name,
2779                     bfd_byte *     datastart,
2780                     bfd_byte *     data,
2781                     bfd_byte *     dataend,
2782                     bfd_vma        rva_bias)
2783 {
2784   unsigned long entry, addr, size;
2785
2786   if (data + 8 >= dataend)
2787     return dataend + 1;
2788
2789   if (is_name)
2790     {
2791       bfd_byte * name;
2792
2793       entry = (long) bfd_get_32 (abfd, data);
2794
2795       if (HighBitSet (entry))
2796         name = datastart + WithoutHighBit (entry);
2797       else
2798         name = datastart + entry - rva_bias;
2799
2800       if (name + 2 >= dataend)
2801         return dataend + 1;
2802
2803       unsigned int len = bfd_get_16 (abfd, name);
2804       if (len == 0 || len > 256)
2805         return dataend + 1;
2806
2807       sizeof_strings += (len + 1) * 2;
2808     }
2809
2810   entry = (long) bfd_get_32 (abfd, data + 4);
2811
2812   if (HighBitSet (entry))
2813     return rsrc_count_directory (abfd,
2814                                  datastart,
2815                                  datastart + WithoutHighBit (entry),
2816                                  dataend, rva_bias);
2817
2818   if (datastart + entry + 16 >= dataend)
2819     return dataend + 1;
2820
2821   addr = (long) bfd_get_32 (abfd, datastart + entry);
2822   size = (long) bfd_get_32 (abfd, datastart + entry + 4);
2823
2824   sizeof_leaves += 16;
2825
2826   return datastart + addr - rva_bias + size;
2827 }
2828
2829 static bfd_byte *
2830 rsrc_count_directory (bfd *          abfd,
2831                       bfd_byte *     datastart,
2832                       bfd_byte *     data,
2833                       bfd_byte *     dataend,
2834                       bfd_vma        rva_bias)
2835 {
2836   unsigned int  num_entries, num_ids;
2837   bfd_byte *    highest_data = data;
2838
2839   if (data + 16 >= dataend)
2840     return dataend + 1;
2841
2842   num_entries  = (int) bfd_get_16 (abfd, data + 12);
2843   num_ids      = (int) bfd_get_16 (abfd, data + 14);
2844
2845   num_entries += num_ids;
2846
2847   data += 16;
2848   sizeof_tables_and_entries += 16;
2849
2850   while (num_entries --)
2851     {
2852       bfd_byte * entry_end;
2853
2854       entry_end = rsrc_count_entries (abfd, num_entries >= num_ids,
2855                                       datastart, data, dataend, rva_bias);
2856       data += 8;
2857       sizeof_tables_and_entries += 8;
2858       highest_data = max (highest_data, entry_end);
2859       if (entry_end >= dataend)
2860         break;
2861     }
2862
2863   return max (highest_data, data);
2864 }
2865
2866 typedef struct rsrc_dir_chain
2867 {
2868   unsigned int         num_entries;
2869   struct rsrc_entry *  first_entry;
2870   struct rsrc_entry *  last_entry;
2871 } rsrc_dir_chain;
2872
2873 typedef struct rsrc_directory
2874 {
2875   unsigned int characteristics;
2876   unsigned int time;
2877   unsigned int major;
2878   unsigned int minor;
2879
2880   rsrc_dir_chain names;
2881   rsrc_dir_chain ids;
2882
2883   struct rsrc_entry * entry;
2884 } rsrc_directory;
2885
2886 typedef struct rsrc_string
2887 {
2888   unsigned int  len;
2889   bfd_byte *    string;
2890 } rsrc_string;
2891
2892 typedef struct rsrc_leaf
2893 {
2894   unsigned int  size;
2895   unsigned int  codepage;
2896   bfd_byte *    data;
2897 } rsrc_leaf;
2898
2899 typedef struct rsrc_entry
2900 {
2901   bfd_boolean is_name;
2902   union
2903   {
2904     unsigned int          id;
2905     struct rsrc_string    name;
2906   } name_id;
2907
2908   bfd_boolean is_dir;
2909   union
2910   {
2911     struct rsrc_directory * directory;
2912     struct rsrc_leaf *      leaf;
2913   } value;
2914
2915   struct rsrc_entry *     next_entry;
2916   struct rsrc_directory * parent;
2917 } rsrc_entry;
2918
2919 static bfd_byte *
2920 rsrc_parse_directory (bfd *, rsrc_directory *, bfd_byte *,
2921                       bfd_byte *, bfd_byte *, bfd_vma, rsrc_entry *);
2922
2923 static bfd_byte *
2924 rsrc_parse_entry (bfd *            abfd,
2925                   bfd_boolean      is_name,
2926                   rsrc_entry *     entry,
2927                   bfd_byte *       datastart,
2928                   bfd_byte *       data,
2929                   bfd_byte *       dataend,
2930                   bfd_vma          rva_bias,
2931                   rsrc_directory * parent)
2932 {
2933   unsigned long val, addr, size;
2934
2935   val = bfd_get_32 (abfd, data);
2936
2937   entry->parent = parent;
2938   entry->is_name = is_name;
2939
2940   if (is_name)
2941     {
2942       /* FIXME: Add range checking ?  */
2943       if (HighBitSet (val))
2944         {
2945           val = WithoutHighBit (val);
2946
2947           entry->name_id.name.len    = bfd_get_16 (abfd, datastart + val);
2948           entry->name_id.name.string = datastart + val + 2;
2949         }
2950       else
2951         {
2952           entry->name_id.name.len    = bfd_get_16 (abfd, datastart + val
2953                                                    - rva_bias);
2954           entry->name_id.name.string = datastart + val - rva_bias + 2;
2955         }
2956     }
2957   else
2958     entry->name_id.id = val;
2959
2960   val = bfd_get_32 (abfd, data + 4);
2961
2962   if (HighBitSet (val))
2963     {
2964       entry->is_dir = TRUE;
2965       entry->value.directory = bfd_malloc (sizeof * entry->value.directory);
2966       if (entry->value.directory == NULL)
2967         return dataend;
2968
2969       return rsrc_parse_directory (abfd, entry->value.directory,
2970                                    datastart,
2971                                    datastart + WithoutHighBit (val),
2972                                    dataend, rva_bias, entry);
2973     }
2974
2975   entry->is_dir = FALSE;
2976   entry->value.leaf = bfd_malloc (sizeof * entry->value.leaf);
2977   if (entry->value.leaf == NULL)
2978     return dataend;
2979
2980   addr = bfd_get_32 (abfd, datastart + val);
2981   size = entry->value.leaf->size = bfd_get_32 (abfd, datastart + val + 4);
2982   entry->value.leaf->codepage = bfd_get_32 (abfd, datastart + val + 8);
2983
2984   entry->value.leaf->data = bfd_malloc (size);
2985   if (entry->value.leaf->data == NULL)
2986     return dataend;
2987
2988   memcpy (entry->value.leaf->data, datastart + addr - rva_bias, size);
2989   return datastart + (addr - rva_bias) + size;
2990 }
2991
2992 static bfd_byte *
2993 rsrc_parse_entries (bfd *            abfd,
2994                     rsrc_dir_chain * chain,
2995                     bfd_boolean      is_name,
2996                     bfd_byte *       highest_data,
2997                     bfd_byte *       datastart,
2998                     bfd_byte *       data,
2999                     bfd_byte *       dataend,
3000                     bfd_vma          rva_bias,
3001                     rsrc_directory * parent)
3002 {
3003   unsigned int i;
3004   rsrc_entry * entry;
3005
3006   if (chain->num_entries == 0)
3007     {
3008       chain->first_entry = chain->last_entry = NULL;
3009       return highest_data;
3010     }
3011
3012   entry = bfd_malloc (sizeof * entry);
3013   if (entry == NULL)
3014     return dataend;
3015
3016   chain->first_entry = entry;
3017
3018   for (i = chain->num_entries; i--;)
3019     {
3020       bfd_byte * entry_end;
3021
3022       entry_end = rsrc_parse_entry (abfd, is_name, entry, datastart,
3023                                     data, dataend, rva_bias, parent);
3024       data += 8;
3025       highest_data = max (entry_end, highest_data);
3026       if (entry_end > dataend)
3027         return dataend;
3028
3029       if (i)
3030         {
3031           entry->next_entry = bfd_malloc (sizeof * entry);
3032           entry = entry->next_entry;
3033           if (entry == NULL)
3034             return dataend;
3035         }
3036       else
3037         entry->next_entry = NULL;
3038     }
3039
3040   chain->last_entry = entry;
3041
3042   return highest_data;
3043 }
3044
3045 static bfd_byte *
3046 rsrc_parse_directory (bfd *            abfd,
3047                       rsrc_directory * table,
3048                       bfd_byte *       datastart,
3049                       bfd_byte *       data,
3050                       bfd_byte *       dataend,
3051                       bfd_vma          rva_bias,
3052                       rsrc_entry *     entry)
3053 {
3054   bfd_byte * highest_data = data;
3055
3056   if (table == NULL)
3057     return dataend;
3058
3059   table->characteristics = bfd_get_32 (abfd, data);
3060   table->time = bfd_get_32 (abfd, data + 4);
3061   table->major = bfd_get_16 (abfd, data + 8);
3062   table->minor = bfd_get_16 (abfd, data + 10);
3063   table->names.num_entries = bfd_get_16 (abfd, data + 12);
3064   table->ids.num_entries = bfd_get_16 (abfd, data + 14);
3065   table->entry = entry;
3066
3067   data += 16;
3068
3069   highest_data = rsrc_parse_entries (abfd, & table->names, TRUE, data,
3070                                      datastart, data, dataend, rva_bias, table);
3071   data += table->names.num_entries * 8;
3072
3073   highest_data = rsrc_parse_entries (abfd, & table->ids, FALSE, highest_data,
3074                                      datastart, data, dataend, rva_bias, table);
3075   data += table->ids.num_entries * 8;
3076
3077   return max (highest_data, data);
3078 }
3079
3080 typedef struct rsrc_write_data
3081 {
3082   bfd *      abfd;
3083   bfd_byte * datastart;
3084   bfd_byte * next_table;
3085   bfd_byte * next_leaf;
3086   bfd_byte * next_string;
3087   bfd_byte * next_data;
3088   bfd_vma    rva_bias;
3089 } rsrc_write_data;
3090
3091 static void
3092 rsrc_write_string (rsrc_write_data * data,
3093                    rsrc_string *     string)
3094 {
3095   bfd_put_16 (data->abfd, string->len, data->next_string);
3096   memcpy (data->next_string + 2, string->string, string->len * 2);
3097   data->next_string += (string->len + 1) * 2;
3098 }
3099
3100 static inline unsigned int
3101 rsrc_compute_rva (rsrc_write_data * data,
3102                   bfd_byte *        addr)
3103 {
3104   return (addr - data->datastart) + data->rva_bias;
3105 }
3106
3107 static void
3108 rsrc_write_leaf (rsrc_write_data * data,
3109                  rsrc_leaf *       leaf)
3110 {
3111   bfd_put_32 (data->abfd, rsrc_compute_rva (data, data->next_data),
3112               data->next_leaf);
3113   bfd_put_32 (data->abfd, leaf->size,     data->next_leaf + 4);
3114   bfd_put_32 (data->abfd, leaf->codepage, data->next_leaf + 8);
3115   bfd_put_32 (data->abfd, 0 /*reserved*/, data->next_leaf + 12);
3116   data->next_leaf += 16;
3117
3118   memcpy (data->next_data, leaf->data, leaf->size);
3119   data->next_data += leaf->size;
3120 }
3121
3122 static void rsrc_write_directory (rsrc_write_data *, rsrc_directory *);
3123
3124 static void
3125 rsrc_write_entry (rsrc_write_data *  data,
3126                   bfd_byte *         where,
3127                   rsrc_entry *       entry)
3128 {
3129   if (entry->is_name)
3130     {
3131       bfd_put_32 (data->abfd,
3132                   SetHighBit (data->next_string - data->datastart),
3133                   where);
3134       rsrc_write_string (data, & entry->name_id.name);
3135     }
3136   else
3137     bfd_put_32 (data->abfd, entry->name_id.id, where);
3138
3139   if (entry->is_dir)
3140     {
3141       bfd_put_32 (data->abfd,
3142                   SetHighBit (data->next_table - data->datastart),
3143                   where + 4);
3144       rsrc_write_directory (data, entry->value.directory);
3145     }
3146   else
3147     {
3148       bfd_put_32 (data->abfd, data->next_leaf - data->datastart, where + 4);
3149       rsrc_write_leaf (data, entry->value.leaf);
3150     }
3151 }
3152
3153 static void
3154 rsrc_write_directory (rsrc_write_data * data,
3155                       rsrc_directory *  dir)
3156 {
3157   rsrc_entry * entry;
3158   unsigned int i;
3159   bfd_byte * next_entry;
3160   bfd_byte * nt;
3161
3162   bfd_put_32 (data->abfd, dir->characteristics, data->next_table);
3163   bfd_put_32 (data->abfd, 0 /*dir->time*/, data->next_table + 4);
3164   bfd_put_16 (data->abfd, dir->major, data->next_table + 8);
3165   bfd_put_16 (data->abfd, dir->minor, data->next_table + 10);
3166   bfd_put_16 (data->abfd, dir->names.num_entries, data->next_table + 12);
3167   bfd_put_16 (data->abfd, dir->ids.num_entries, data->next_table + 14);
3168
3169   /* Compute where the entries and the next table will be placed.  */
3170   next_entry = data->next_table + 16;
3171   data->next_table = next_entry + (dir->names.num_entries * 8)
3172     + (dir->ids.num_entries * 8);
3173   nt = data->next_table;
3174
3175   /* Write the entries.  */
3176   for (i = dir->names.num_entries, entry = dir->names.first_entry;
3177        i > 0 && entry != NULL;
3178        i--, entry = entry->next_entry)
3179     {
3180       rsrc_write_entry (data, next_entry, entry);
3181       next_entry += 8;
3182     }
3183   BFD_ASSERT (i == 0);
3184   BFD_ASSERT (entry == NULL);
3185
3186   for (i = dir->ids.num_entries, entry = dir->ids.first_entry;
3187        i > 0 && entry != NULL;
3188        i--, entry = entry->next_entry)
3189     {
3190       rsrc_write_entry (data, next_entry, entry);
3191       next_entry += 8;
3192     }
3193   BFD_ASSERT (i == 0);
3194   BFD_ASSERT (entry == NULL);
3195   BFD_ASSERT (nt == next_entry);
3196 }
3197
3198 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3199 /* Return the length (number of units) of the first character in S,
3200    putting its 'ucs4_t' representation in *PUC.  */
3201
3202 static unsigned int
3203 u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n)
3204 {
3205   unsigned short c = * s;
3206
3207   if (c < 0xd800 || c >= 0xe000)
3208     {
3209       *puc = c;
3210       return 1;
3211     }
3212
3213   if (c < 0xdc00)
3214     {
3215       if (n >= 2)
3216         {
3217           if (s[1] >= 0xdc00 && s[1] < 0xe000)
3218             {
3219               *puc = 0x10000 + ((c - 0xd800) << 10) + (s[1] - 0xdc00);
3220               return 2;
3221             }
3222         }
3223       else
3224         {
3225           /* Incomplete multibyte character.  */
3226           *puc = 0xfffd;
3227           return n;
3228         }
3229     }
3230
3231   /* Invalid multibyte character.  */
3232   *puc = 0xfffd;
3233   return 1;
3234 }
3235 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3236
3237 /* Perform a comparison of two entries.  */
3238 static signed int
3239 rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b)
3240 {
3241   signed int    res;
3242   bfd_byte *    astring;
3243   unsigned int  alen;
3244   bfd_byte *    bstring;
3245   unsigned int  blen;
3246
3247   if (! is_name)
3248     return a->name_id.id - b->name_id.id;
3249
3250   /* We have to perform a case insenstive, unicode string comparison...  */
3251   astring = a->name_id.name.string;
3252   alen    = a->name_id.name.len;
3253   bstring = b->name_id.name.string;
3254   blen    = b->name_id.name.len;
3255
3256 #if defined  __CYGWIN__ || defined __MINGW32__
3257   /* Under Windows hosts (both Cygwin and Mingw types),
3258      unicode == UTF-16 == wchar_t.  The case insensitive string comparison
3259      function however goes by different names in the two environments...  */
3260
3261 #undef rscpcmp
3262 #ifdef __CYGWIN__
3263 #define rscpcmp wcsncasecmp
3264 #endif
3265 #ifdef __MINGW32__
3266 #define rscpcmp wcsnicmp
3267 #endif
3268
3269   res = rscpcmp ((const wchar_t *) astring, (const wchar_t *) bstring,
3270                  min (alen, blen));
3271
3272 #elif defined HAVE_WCHAR_H
3273   {
3274     unsigned int  i;
3275     res = 0;
3276     for (i = min (alen, blen); i--; astring += 2, bstring += 2)
3277       {
3278         wchar_t awc;
3279         wchar_t bwc;
3280
3281         /* Convert UTF-16 unicode characters into wchar_t characters so
3282            that we can then perform a case insensitive comparison.  */
3283         int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2);
3284         int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2);
3285
3286         if (Alen != Blen)
3287           return Alen - Blen;
3288         res = wcsncasecmp (& awc, & bwc, 1);
3289         if (res)
3290           break;
3291       }
3292   }
3293 #else
3294   /* Do the best we can - a case sensitive, untranslated comparison.  */
3295   res = memcmp (astring, bstring, min (alen, blen) * 2);
3296 #endif
3297
3298   if (res == 0)
3299     res = alen - blen;
3300
3301   return res;
3302 }
3303
3304 static void
3305 rsrc_print_name (char * buffer, rsrc_string string)
3306 {
3307   unsigned int  i;
3308   bfd_byte *    name = string.string;
3309
3310   for (i = string.len; i--; name += 2)
3311     sprintf (buffer + strlen (buffer), "%.1s", name);
3312 }
3313
3314 static const char *
3315 rsrc_resource_name (rsrc_entry * entry, rsrc_directory * dir)
3316 {
3317   static char buffer [256];
3318   bfd_boolean is_string = FALSE;
3319
3320   buffer[0] = 0;
3321
3322   if (dir != NULL && dir->entry != NULL && dir->entry->parent != NULL
3323       && dir->entry->parent->entry != NULL)
3324     {
3325       strcpy (buffer, "type: ");
3326       if (dir->entry->parent->entry->is_name)
3327         rsrc_print_name (buffer + strlen (buffer),
3328                          dir->entry->parent->entry->name_id.name);
3329       else
3330         {
3331           unsigned int id = dir->entry->parent->entry->name_id.id;
3332
3333           sprintf (buffer + strlen (buffer), "%x", id);
3334           switch (id)
3335             {
3336             case 1: strcat (buffer, " (CURSOR)"); break;
3337             case 2: strcat (buffer, " (BITMAP)"); break;
3338             case 3: strcat (buffer, " (ICON)"); break;
3339             case 4: strcat (buffer, " (MENU)"); break;
3340             case 5: strcat (buffer, " (DIALOG)"); break;
3341             case 6: strcat (buffer, " (STRING)"); is_string = TRUE; break;
3342             case 7: strcat (buffer, " (FONTDIR)"); break;
3343             case 8: strcat (buffer, " (FONT)"); break;
3344             case 9: strcat (buffer, " (ACCELERATOR)"); break;
3345             case 10: strcat (buffer, " (RCDATA)"); break;
3346             case 11: strcat (buffer, " (MESSAGETABLE)"); break;
3347             case 12: strcat (buffer, " (GROUP_CURSOR)"); break;
3348             case 14: strcat (buffer, " (GROUP_ICON)"); break;
3349             case 16: strcat (buffer, " (VERSION)"); break;
3350             case 17: strcat (buffer, " (DLGINCLUDE)"); break;
3351             case 19: strcat (buffer, " (PLUGPLAY)"); break;
3352             case 20: strcat (buffer, " (VXD)"); break;
3353             case 21: strcat (buffer, " (ANICURSOR)"); break;
3354             case 22: strcat (buffer, " (ANIICON)"); break;
3355             case 23: strcat (buffer, " (HTML)"); break;
3356             case 24: strcat (buffer, " (MANIFEST)"); break;
3357             case 240: strcat (buffer, " (DLGINIT)"); break;
3358             case 241: strcat (buffer, " (TOOLBAR)"); break;
3359             }
3360         }
3361     }
3362
3363   if (dir != NULL && dir->entry != NULL)
3364     {
3365       strcat (buffer, " name: ");
3366       if (dir->entry->is_name)
3367         rsrc_print_name (buffer + strlen (buffer), dir->entry->name_id.name);
3368       else
3369         {
3370           unsigned int id = dir->entry->name_id.id;
3371
3372           sprintf (buffer + strlen (buffer), "%x", id);
3373
3374           if (is_string)
3375             sprintf (buffer + strlen (buffer), " (resource id range: %d - %d)",
3376                      (id - 1) << 4, (id << 4) - 1);
3377         }
3378     }
3379
3380   if (entry != NULL)
3381     {
3382       strcat (buffer, " lang: ");
3383
3384       if (entry->is_name)
3385         rsrc_print_name (buffer + strlen (buffer), entry->name_id.name);
3386       else
3387         sprintf (buffer + strlen (buffer), "%x", entry->name_id.id);
3388     }
3389
3390   return buffer;
3391 }
3392
3393 /* *sigh* Windows resource strings are special.  Only the top 28-bits of
3394    their ID is stored in the NAME entry.  The bottom four bits are used as
3395    an index into unicode string table that makes up the data of the leaf.
3396    So identical type-name-lang string resources may not actually be
3397    identical at all.
3398
3399    This function is called when we have detected two string resources with
3400    match top-28-bit IDs.  We have to scan the string tables inside the leaves
3401    and discover if there are any real collisions.  If there are then we report
3402    them and return FALSE.  Otherwise we copy any strings from B into A and
3403    then return TRUE.  */
3404
3405 static bfd_boolean
3406 rsrc_merge_string_entries (rsrc_entry * a ATTRIBUTE_UNUSED,
3407                            rsrc_entry * b ATTRIBUTE_UNUSED)
3408 {
3409   unsigned int copy_needed = 0;
3410   unsigned int i;
3411   bfd_byte * astring;
3412   bfd_byte * bstring;
3413   bfd_byte * new_data;
3414   bfd_byte * nstring;
3415
3416   /* Step one: Find out what we have to do.  */
3417   BFD_ASSERT (! a->is_dir);
3418   astring = a->value.leaf->data;
3419
3420   BFD_ASSERT (! b->is_dir);
3421   bstring = b->value.leaf->data;
3422
3423   for (i = 0; i < 16; i++)
3424     {
3425       unsigned int alen = astring[0] + (astring[1] << 8);
3426       unsigned int blen = bstring[0] + (bstring[1] << 8);
3427
3428       if (alen == 0)
3429         {
3430           copy_needed += blen * 2;
3431         }
3432       else if (blen == 0)
3433         ;
3434       else if (alen != blen)
3435         /* FIXME: Should we continue the loop in order to report other duplicates ?  */
3436         break;
3437       /* alen == blen != 0.  We might have two identical strings.  If so we
3438          can ignore the second one.  There is no need for wchar_t vs UTF-16
3439          theatrics here - we are only interested in (case sensitive) equality.  */
3440       else if (memcmp (astring + 2, bstring + 2, alen * 2) != 0)
3441         break;
3442
3443       astring += (alen + 1) * 2;
3444       bstring += (blen + 1) * 2;
3445     }
3446
3447   if (i != 16)
3448     {
3449       if (a->parent != NULL
3450           && a->parent->entry != NULL
3451           && a->parent->entry->is_name == FALSE)
3452         _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3453                             ((a->parent->entry->name_id.id - 1) << 4) + i);
3454       return FALSE;
3455     }
3456
3457   if (copy_needed == 0)
3458     return TRUE;
3459
3460   /* If we reach here then A and B must both have non-colliding strings.
3461      (We never get string resources with fully empty string tables).
3462      We need to allocate an extra COPY_NEEDED bytes in A and then bring
3463      in B's strings.  */
3464   new_data = bfd_malloc (a->value.leaf->size + copy_needed);
3465   if (new_data == NULL)
3466     return FALSE;
3467
3468   nstring = new_data;
3469   astring = a->value.leaf->data;
3470   bstring = b->value.leaf->data;
3471
3472   for (i = 0; i < 16; i++)
3473     {
3474       unsigned int alen = astring[0] + (astring[1] << 8);
3475       unsigned int blen = bstring[0] + (bstring[1] << 8);
3476
3477       if (alen != 0)
3478         {
3479           memcpy (nstring, astring, (alen + 1) * 2);
3480           nstring += (alen + 1) * 2;
3481         }
3482       else if (blen != 0)
3483         {
3484           memcpy (nstring, bstring, (blen + 1) * 2);
3485           nstring += (blen + 1) * 2;
3486         }
3487       else
3488         {
3489           * nstring++ = 0;
3490           * nstring++ = 0;
3491         }
3492
3493       astring += (alen + 1) * 2;
3494       bstring += (blen + 1) * 2;
3495     }
3496
3497   BFD_ASSERT (nstring - new_data == (signed) (a->value.leaf->size + copy_needed));
3498
3499   free (a->value.leaf->data);
3500   a->value.leaf->data = new_data;
3501   a->value.leaf->size += copy_needed;
3502
3503   return TRUE;
3504 }
3505
3506 static void rsrc_merge (rsrc_entry *, rsrc_entry *);
3507
3508 /* Sort the entries in given part of the directory.
3509    We use an old fashioned bubble sort because we are dealing
3510    with lists and we want to handle matches specially.  */
3511
3512 static void
3513 rsrc_sort_entries (rsrc_dir_chain *  chain,
3514                    bfd_boolean       is_name,
3515                    rsrc_directory *  dir)
3516 {
3517   rsrc_entry * entry;
3518   rsrc_entry * next;
3519   rsrc_entry ** points_to_entry;
3520   bfd_boolean swapped;
3521
3522   if (chain->num_entries < 2)
3523     return;
3524
3525   do
3526     {
3527       swapped = FALSE;
3528       points_to_entry = & chain->first_entry;
3529       entry = * points_to_entry;
3530       next  = entry->next_entry;
3531
3532       do
3533         {
3534           signed int cmp = rsrc_cmp (is_name, entry, next);
3535
3536           if (cmp > 0)
3537             {
3538               entry->next_entry = next->next_entry;
3539               next->next_entry = entry;
3540               * points_to_entry = next;
3541               points_to_entry = & next->next_entry;
3542               next = entry->next_entry;
3543               swapped = TRUE;
3544             }
3545           else if (cmp == 0)
3546             {
3547               if (entry->is_dir && next->is_dir)
3548                 {
3549                   /* When we encounter identical directory entries we have to
3550                      merge them together.  The exception to this rule is for
3551                      resource manifests - there can only be one of these,
3552                      even if they differ in language.  Zero-language manifests
3553                      are assumed to be default manifests (provided by the
3554                      cygwin build system) and these can be silently dropped,
3555                      unless that would reduce the number of manifests to zero.
3556                      There should only ever be one non-zero lang manifest -
3557                      if there are more it is an error.  A non-zero lang
3558                      manifest takes precedence over a default manifest.  */
3559                   if (entry->is_name == FALSE
3560                       && entry->name_id.id == 1
3561                       && dir != NULL
3562                       && dir->entry != NULL
3563                       && dir->entry->is_name == FALSE
3564                       && dir->entry->name_id.id == 0x18)
3565                     {
3566                       if (next->value.directory->names.num_entries == 0
3567                           && next->value.directory->ids.num_entries == 1
3568                           && next->value.directory->ids.first_entry->is_name == FALSE
3569                           && next->value.directory->ids.first_entry->name_id.id == 0)
3570                         /* Fall through so that NEXT is dropped.  */
3571                         ;
3572                       else if (entry->value.directory->names.num_entries == 0
3573                                && entry->value.directory->ids.num_entries == 1
3574                                && entry->value.directory->ids.first_entry->is_name == FALSE
3575                                && entry->value.directory->ids.first_entry->name_id.id == 0)
3576                         {
3577                           /* Swap ENTRY and NEXT.  Then fall through so that the old ENTRY is dropped.  */
3578                           entry->next_entry = next->next_entry;
3579                           next->next_entry = entry;
3580                           * points_to_entry = next;
3581                           points_to_entry = & next->next_entry;
3582                           next = entry->next_entry;
3583                           swapped = TRUE;
3584                         }
3585                       else
3586                         {
3587                           _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3588                           bfd_set_error (bfd_error_file_truncated);
3589                           return;
3590                         }
3591
3592                       /* Unhook NEXT from the chain.  */
3593                       /* FIXME: memory loss here.  */
3594                       /* FIXME: do we need to decrement sizeof_tables_and_entries ?  */
3595                       entry->next_entry = next->next_entry;
3596                       chain->num_entries --;
3597                       if (chain->num_entries < 2)
3598                         return;
3599                       next = next->next_entry;
3600                     }
3601                   else
3602                     rsrc_merge (entry, next);
3603                 }
3604               else if (entry->is_dir != next->is_dir)
3605                 {
3606                   _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3607                   bfd_set_error (bfd_error_file_truncated);
3608                   return;
3609                 }
3610               else
3611                 {
3612                   /* Otherwise with identical leaves we issue an error
3613                      message - because there should never be duplicates.
3614                      The exception is Type 18/Name 1/Lang 0 which is the
3615                      defaul manifest - this can just be dropped.  */
3616                   if (entry->is_name == FALSE
3617                       && entry->name_id.id == 0
3618                       && dir != NULL
3619                       && dir->entry != NULL
3620                       && dir->entry->is_name == FALSE
3621                       && dir->entry->name_id.id == 1
3622                       && dir->entry->parent != NULL
3623                       && dir->entry->parent->entry != NULL
3624                       && dir->entry->parent->entry->is_name == FALSE
3625                       && dir->entry->parent->entry->name_id.id == 0x18 /* RT_MANIFEST */)
3626                     ;
3627                   else if (dir != NULL
3628                            && dir->entry != NULL
3629                            && dir->entry->parent != NULL
3630                            && dir->entry->parent->entry != NULL
3631                            && dir->entry->parent->entry->is_name == FALSE
3632                            && dir->entry->parent->entry->name_id.id == 0x6 /* RT_STRING */)
3633                     {
3634                       /* Strings need special handling.  */
3635                       if (! rsrc_merge_string_entries (entry, next))
3636                         {
3637                           /* _bfd_error_handler should have been called inside merge_strings.  */
3638                           bfd_set_error (bfd_error_file_truncated);
3639                           return;
3640                         }
3641                     }
3642                   else
3643                     {
3644                       if (dir == NULL
3645                           || dir->entry == NULL
3646                           || dir->entry->parent == NULL
3647                           || dir->entry->parent->entry == NULL)
3648                         _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
3649                       else
3650                         _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
3651                                             rsrc_resource_name (entry, dir));
3652                       bfd_set_error (bfd_error_file_truncated);
3653                       return;
3654                     }
3655                 }
3656
3657               /* Unhook NEXT from the chain.  */
3658               /* FIXME: do we need to decrement sizeof_tables_and_entries ?  */
3659               entry->next_entry = next->next_entry;
3660               chain->num_entries --;
3661               if (chain->num_entries < 2)
3662                 return;
3663               next = next->next_entry;
3664             }
3665           else
3666             {
3667               points_to_entry = & entry->next_entry;
3668               entry = next;
3669               next = next->next_entry;
3670             }
3671         }
3672       while (next);
3673
3674       chain->last_entry = entry;
3675     }
3676   while (swapped);
3677 }
3678
3679 /* Attach B's chain onto A.  */
3680 static void
3681 rsrc_attach_chain (rsrc_dir_chain * achain, rsrc_dir_chain * bchain)
3682 {
3683   if (bchain->num_entries == 0)
3684     return;
3685
3686   achain->num_entries += bchain->num_entries;
3687
3688   if (achain->first_entry == NULL)
3689     {
3690       achain->first_entry = bchain->first_entry;
3691       achain->last_entry  = bchain->last_entry;
3692     }
3693   else
3694     {
3695       achain->last_entry->next_entry = bchain->first_entry;
3696       achain->last_entry = bchain->last_entry;
3697     }
3698
3699   bchain->num_entries = 0;
3700   bchain->first_entry = bchain->last_entry = NULL;
3701 }
3702
3703 static void
3704 rsrc_merge (struct rsrc_entry * a, struct rsrc_entry * b)
3705 {
3706   rsrc_directory * adir;
3707   rsrc_directory * bdir;
3708
3709   BFD_ASSERT (a->is_dir);
3710   BFD_ASSERT (b->is_dir);
3711
3712   adir = a->value.directory;
3713   bdir = b->value.directory;
3714
3715   if (adir->characteristics != bdir->characteristics)
3716     {
3717       _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
3718       bfd_set_error (bfd_error_file_truncated);
3719       return;
3720     }
3721
3722   if (adir->major != bdir->major || adir->minor != bdir->minor)
3723     {
3724       _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
3725       bfd_set_error (bfd_error_file_truncated);
3726       return;
3727     }
3728
3729   /* Attach B's name chain to A.  */
3730   rsrc_attach_chain (& adir->names, & bdir->names);
3731
3732   /* Attach B's ID chain to A.  */
3733   rsrc_attach_chain (& adir->ids, & bdir->ids);
3734
3735   /* Now sort A's entries.  */
3736   rsrc_sort_entries (& adir->names, TRUE, adir);
3737   rsrc_sort_entries (& adir->ids, FALSE, adir);
3738 }
3739
3740 /* Check the .rsrc section.  If it contains multiple concatenated
3741    resources then we must merge them properly.  Otherwise Windows
3742    will ignore all but the first set.  */
3743
3744 static void
3745 rsrc_process_section (bfd * abfd,
3746                       struct coff_final_link_info * pfinfo)
3747 {
3748   rsrc_directory    new_table;
3749   bfd_size_type     size;
3750   asection *        sec;
3751   pe_data_type *    pe;
3752   bfd_vma           rva_bias;
3753   bfd_byte *        data;
3754   bfd_byte *        datastart;
3755   bfd_byte *        dataend;
3756   bfd_byte *        new_data;
3757   unsigned int      num_resource_sets;
3758   rsrc_directory *  type_tables;
3759   rsrc_write_data   write_data;
3760   unsigned int      indx;
3761   bfd *             input;
3762   unsigned int      num_input_rsrc = 0;
3763   unsigned int      max_num_input_rsrc = 4;
3764   ptrdiff_t *       rsrc_sizes = NULL;
3765
3766   new_table.names.num_entries = 0;
3767   new_table.ids.num_entries = 0;
3768
3769   sec = bfd_get_section_by_name (abfd, ".rsrc");
3770   if (sec == NULL || (size = sec->rawsize) == 0)
3771     return;
3772
3773   pe = pe_data (abfd);
3774   if (pe == NULL)
3775     return;
3776
3777   rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
3778
3779   data = bfd_malloc (size);
3780   if (data == NULL)
3781     return;
3782   datastart = data;
3783
3784   if (! bfd_get_section_contents (abfd, sec, data, 0, size))
3785     goto end;
3786
3787   /* Step zero: Scan the input bfds looking for .rsrc sections and record
3788      their lengths.  Note - we rely upon the fact that the linker script
3789      does *not* sort the input .rsrc sections, so that the order in the
3790      linkinfo list matches the order in the output .rsrc section.
3791
3792      We need to know the lengths because each input .rsrc section has padding
3793      at the end of a variable amount.  (It does not appear to be based upon
3794      the section alignment or the file alignment).  We need to skip any
3795      padding bytes when parsing the input .rsrc sections.  */
3796   rsrc_sizes = bfd_malloc (max_num_input_rsrc * sizeof * rsrc_sizes);
3797   if (rsrc_sizes == NULL)
3798     goto end;
3799
3800   for (input = pfinfo->info->input_bfds;
3801        input != NULL;
3802        input = input->link_next)
3803     {
3804       asection * rsrc_sec = bfd_get_section_by_name (input, ".rsrc");
3805
3806       if (rsrc_sec != NULL)
3807         {
3808           if (num_input_rsrc == max_num_input_rsrc)
3809             {
3810               max_num_input_rsrc += 10;
3811               rsrc_sizes = bfd_realloc (rsrc_sizes, max_num_input_rsrc
3812                                         * sizeof * rsrc_sizes);
3813               if (rsrc_sizes == NULL)
3814                 goto end;
3815             }
3816
3817           BFD_ASSERT (rsrc_sec->size > 0);
3818           rsrc_sizes [num_input_rsrc ++] = rsrc_sec->size;
3819         }
3820     }
3821
3822   if (num_input_rsrc < 2)
3823     goto end;
3824
3825   /* Step one: Walk the section, computing the size of the tables,
3826      leaves and data and decide if we need to do anything.  */
3827   dataend = data + size;
3828   num_resource_sets = 0;
3829   sizeof_leaves = sizeof_strings = sizeof_tables_and_entries = 0;
3830
3831   while (data < dataend)
3832     {
3833       bfd_byte * p = data;
3834
3835       data = rsrc_count_directory (abfd, data, data, dataend, rva_bias);
3836
3837       if (data > dataend)
3838         {
3839           /* Corrupted .rsrc section - cannot merge.  */
3840           _bfd_error_handler (_("%s: .rsrc merge failure: corrupt .rsrc section"),
3841                               bfd_get_filename (abfd));
3842           bfd_set_error (bfd_error_file_truncated);
3843           goto end;
3844         }
3845
3846       if ((data - p) > rsrc_sizes [num_resource_sets])
3847         {
3848           _bfd_error_handler (_("%s: .rsrc merge failure: unexpected .rsrc size"),
3849                               bfd_get_filename (abfd));
3850           bfd_set_error (bfd_error_file_truncated);
3851           goto end;
3852         }
3853       /* FIXME: Should we add a check for "data - p" being much smaller
3854          than rsrc_sizes[num_resource_sets] ?  */
3855
3856       data = p + rsrc_sizes[num_resource_sets];
3857       rva_bias += data - p;
3858       ++ num_resource_sets;
3859     }
3860   BFD_ASSERT (num_resource_sets == num_input_rsrc);
3861
3862   /* Step two: Walk the data again, building trees of the resources.  */
3863   data = datastart;
3864   rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
3865
3866   type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables);
3867   if (type_tables == NULL)
3868     goto end;
3869
3870   indx = 0;
3871   while (data < dataend)
3872     {
3873       bfd_byte * p = data;
3874
3875       (void) rsrc_parse_directory (abfd, type_tables + indx, data, data,
3876                                    dataend, rva_bias, NULL);
3877       data = p + rsrc_sizes[indx];
3878       rva_bias += data - p;
3879       ++ indx;
3880     }
3881   BFD_ASSERT (indx == num_resource_sets);
3882
3883   /* Step three: Merge the top level tables (there can be only one).
3884
3885      We must ensure that the merged entries are in ascending order.
3886
3887      We also thread the top level table entries from the old tree onto
3888      the new table, so that they can be pulled off later.  */
3889
3890   /* FIXME: Should we verify that all type tables are the same ?  */
3891   new_table.characteristics = type_tables[0].characteristics;
3892   new_table.time            = type_tables[0].time;
3893   new_table.major           = type_tables[0].major;
3894   new_table.minor           = type_tables[0].minor;
3895
3896   /* Chain the NAME entries onto the table.  */
3897   new_table.names.first_entry = NULL;
3898   new_table.names.last_entry = NULL;
3899
3900   for (indx = 0; indx < num_resource_sets; indx++)
3901     rsrc_attach_chain (& new_table.names, & type_tables[indx].names);
3902
3903   rsrc_sort_entries (& new_table.names, TRUE, & new_table);
3904
3905   /* Chain the ID entries onto the table.  */
3906   new_table.ids.first_entry = NULL;
3907   new_table.ids.last_entry = NULL;
3908
3909   for (indx = 0; indx < num_resource_sets; indx++)
3910     rsrc_attach_chain (& new_table.ids, & type_tables[indx].ids);
3911
3912   rsrc_sort_entries (& new_table.ids, FALSE, & new_table);
3913
3914   /* Step four: Create new contents for the .rsrc section.  */
3915   new_data = bfd_malloc (size);
3916   if (new_data == NULL)
3917     goto end;
3918
3919   /* We have merged the top level Type Tables of all of the input
3920      .rsrc sections into one Type Table.  So we can (and must)
3921      reduce the count of the number of tables that we will be
3922      emitting appropriately.  */
3923   sizeof_tables_and_entries -= 16 * (num_resource_sets - 1);
3924
3925   write_data.abfd        = abfd;
3926   write_data.datastart   = new_data;
3927   write_data.next_table  = new_data;
3928   write_data.next_leaf   = new_data + sizeof_tables_and_entries;
3929   write_data.next_string = write_data.next_leaf + sizeof_leaves;
3930   write_data.next_data   = write_data.next_string + sizeof_strings;
3931   write_data.rva_bias    = sec->vma - pe->pe_opthdr.ImageBase;
3932
3933   rsrc_write_directory (& write_data, & new_table);
3934
3935   /* Step five: Replace the old contents with the new.
3936      We recompute the size as we may have lost entries due to mergeing.  */
3937   size = ((write_data.next_data - new_data) + 3) & ~ 3;
3938   bfd_set_section_contents (pfinfo->output_bfd, sec, new_data, 0, size);
3939   sec->size = sec->rawsize = size;
3940
3941  end:
3942   /* Step size: Free all the memory that we have used.  */
3943   /* FIXME: Free the resource tree, if we have one.  */
3944   free (datastart);
3945   free (rsrc_sizes);
3946 }
3947
3948 /* Handle the .idata section and other things that need symbol table
3949    access.  */
3950
3951 bfd_boolean
3952 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
3953 {
3954   struct coff_link_hash_entry *h1;
3955   struct bfd_link_info *info = pfinfo->info;
3956   bfd_boolean result = TRUE;
3957
3958   /* There are a few fields that need to be filled in now while we
3959      have symbol table access.
3960
3961      The .idata subsections aren't directly available as sections, but
3962      they are in the symbol table, so get them from there.  */
3963
3964   /* The import directory.  This is the address of .idata$2, with size
3965      of .idata$2 + .idata$3.  */
3966   h1 = coff_link_hash_lookup (coff_hash_table (info),
3967                               ".idata$2", FALSE, FALSE, TRUE);
3968   if (h1 != NULL)
3969     {
3970       /* PR ld/2729: We cannot rely upon all the output sections having been
3971          created properly, so check before referencing them.  Issue a warning
3972          message for any sections tht could not be found.  */
3973       if ((h1->root.type == bfd_link_hash_defined
3974            || h1->root.type == bfd_link_hash_defweak)
3975           && h1->root.u.def.section != NULL
3976           && h1->root.u.def.section->output_section != NULL)
3977         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
3978           (h1->root.u.def.value
3979            + h1->root.u.def.section->output_section->vma
3980            + h1->root.u.def.section->output_offset);
3981       else
3982         {
3983           _bfd_error_handler
3984             (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
3985              abfd);
3986           result = FALSE;
3987         }
3988
3989       h1 = coff_link_hash_lookup (coff_hash_table (info),
3990                                   ".idata$4", FALSE, FALSE, TRUE);
3991       if (h1 != NULL
3992           && (h1->root.type == bfd_link_hash_defined
3993            || h1->root.type == bfd_link_hash_defweak)
3994           && h1->root.u.def.section != NULL
3995           && h1->root.u.def.section->output_section != NULL)
3996         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
3997           ((h1->root.u.def.value
3998             + h1->root.u.def.section->output_section->vma
3999             + h1->root.u.def.section->output_offset)
4000            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
4001       else
4002         {
4003           _bfd_error_handler
4004             (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4005              abfd);
4006           result = FALSE;
4007         }
4008
4009       /* The import address table.  This is the size/address of
4010          .idata$5.  */
4011       h1 = coff_link_hash_lookup (coff_hash_table (info),
4012                                   ".idata$5", FALSE, FALSE, TRUE);
4013       if (h1 != NULL
4014           && (h1->root.type == bfd_link_hash_defined
4015            || h1->root.type == bfd_link_hash_defweak)
4016           && h1->root.u.def.section != NULL
4017           && h1->root.u.def.section->output_section != NULL)
4018         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4019           (h1->root.u.def.value
4020            + h1->root.u.def.section->output_section->vma
4021            + h1->root.u.def.section->output_offset);
4022       else
4023         {
4024           _bfd_error_handler
4025             (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4026              abfd);
4027           result = FALSE;
4028         }
4029
4030       h1 = coff_link_hash_lookup (coff_hash_table (info),
4031                                   ".idata$6", FALSE, FALSE, TRUE);
4032       if (h1 != NULL
4033           && (h1->root.type == bfd_link_hash_defined
4034            || h1->root.type == bfd_link_hash_defweak)
4035           && h1->root.u.def.section != NULL
4036           && h1->root.u.def.section->output_section != NULL)
4037         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4038           ((h1->root.u.def.value
4039             + h1->root.u.def.section->output_section->vma
4040             + h1->root.u.def.section->output_offset)
4041            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
4042       else
4043         {
4044           _bfd_error_handler
4045             (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4046              abfd);
4047           result = FALSE;
4048         }
4049     }
4050   else
4051     {
4052       h1 = coff_link_hash_lookup (coff_hash_table (info),
4053                                   "__IAT_start__", FALSE, FALSE, TRUE);
4054       if (h1 != NULL
4055           && (h1->root.type == bfd_link_hash_defined
4056            || h1->root.type == bfd_link_hash_defweak)
4057           && h1->root.u.def.section != NULL
4058           && h1->root.u.def.section->output_section != NULL)
4059         {
4060           bfd_vma iat_va;
4061
4062           iat_va =
4063             (h1->root.u.def.value
4064              + h1->root.u.def.section->output_section->vma
4065              + h1->root.u.def.section->output_offset);
4066
4067           h1 = coff_link_hash_lookup (coff_hash_table (info),
4068                                       "__IAT_end__", FALSE, FALSE, TRUE);
4069           if (h1 != NULL
4070               && (h1->root.type == bfd_link_hash_defined
4071                || h1->root.type == bfd_link_hash_defweak)
4072               && h1->root.u.def.section != NULL
4073               && h1->root.u.def.section->output_section != NULL)
4074             {
4075               pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4076                 ((h1->root.u.def.value
4077                   + h1->root.u.def.section->output_section->vma
4078                   + h1->root.u.def.section->output_offset)
4079                  - iat_va);
4080               if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
4081                 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4082                   iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
4083             }
4084           else
4085             {
4086               _bfd_error_handler
4087                 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4088                    " because .idata$6 is missing"), abfd);
4089               result = FALSE;
4090             }
4091         }
4092     }
4093
4094   h1 = coff_link_hash_lookup (coff_hash_table (info),
4095                               (bfd_get_symbol_leading_char (abfd) != 0
4096                                ? "__tls_used" : "_tls_used"),
4097                               FALSE, FALSE, TRUE);
4098   if (h1 != NULL)
4099     {
4100       if ((h1->root.type == bfd_link_hash_defined
4101            || h1->root.type == bfd_link_hash_defweak)
4102           && h1->root.u.def.section != NULL
4103           && h1->root.u.def.section->output_section != NULL)
4104         pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
4105           (h1->root.u.def.value
4106            + h1->root.u.def.section->output_section->vma
4107            + h1->root.u.def.section->output_offset
4108            - pe_data (abfd)->pe_opthdr.ImageBase);
4109       else
4110         {
4111           _bfd_error_handler
4112             (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
4113              abfd);
4114           result = FALSE;
4115         }
4116      /* According to PECOFF sepcifications by Microsoft version 8.2
4117         the TLS data directory consists of 4 pointers, followed
4118         by two 4-byte integer. This implies that the total size
4119         is different for 32-bit and 64-bit executables.  */
4120 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4121       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
4122 #else
4123       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
4124 #endif
4125     }
4126
4127 /* If there is a .pdata section and we have linked pdata finally, we
4128      need to sort the entries ascending.  */
4129 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4130   {
4131     asection *sec = bfd_get_section_by_name (abfd, ".pdata");
4132
4133     if (sec)
4134       {
4135         bfd_size_type x = sec->rawsize;
4136         bfd_byte *tmp_data = NULL;
4137
4138         if (x)
4139           tmp_data = bfd_malloc (x);
4140
4141         if (tmp_data != NULL)
4142           {
4143             if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
4144               {
4145                 qsort (tmp_data,
4146                        (size_t) (x / 12),
4147                        12, sort_x64_pdata);
4148                 bfd_set_section_contents (pfinfo->output_bfd, sec,
4149                                           tmp_data, 0, x);
4150               }
4151             free (tmp_data);
4152           }
4153       }
4154   }
4155 #endif
4156
4157   rsrc_process_section (abfd, pfinfo);
4158
4159   /* If we couldn't find idata$2, we either have an excessively
4160      trivial program or are in DEEP trouble; we have to assume trivial
4161      program....  */
4162   return result;
4163 }