bfd/peXXigen.c

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