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