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