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