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