bfd/peXXigen.c

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