bfd/peXXigen.c

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