bfd/peXXigen.c

   1 /* Support for the generic parts of PE/PEI; the common executable parts.
   2    Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   3    2005, 2006 Free Software Foundation, Inc.
   4    Written by Cygnus Solutions.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  21
  22 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
  23
  24    PE/PEI rearrangement (and code added): Donn Terry
  25                                           Softway Systems, Inc.  */
  26
  27 /* Hey look, some documentation [and in a place you expect to find it]!
  28
  29    The main reference for the pei format is "Microsoft Portable Executable
  30    and Common Object File Format Specification 4.1".  Get it if you need to
  31    do some serious hacking on this code.
  32
  33    Another reference:
  34    "Peering Inside the PE: A Tour of the Win32 Portable Executable
  35    File Format", MSJ 1994, Volume 9.
  36
  37    The *sole* difference between the pe format and the pei format is that the
  38    latter has an MSDOS 2.0 .exe header on the front that prints the message
  39    "This app must be run under Windows." (or some such).
  40    (FIXME: Whether that statement is *really* true or not is unknown.
  41    Are there more subtle differences between pe and pei formats?
  42    For now assume there aren't.  If you find one, then for God sakes
  43    document it here!)
  44
  45    The Microsoft docs use the word "image" instead of "executable" because
  46    the former can also refer to a DLL (shared library).  Confusion can arise
  47    because the `i' in `pei' also refers to "image".  The `pe' format can
  48    also create images (i.e. executables), it's just that to run on a win32
  49    system you need to use the pei format.
  50
  51    FIXME: Please add more docs here so the next poor fool that has to hack
  52    on this code has a chance of getting something accomplished without
  53    wasting too much time.  */
  54
  55 /* This expands into COFF_WITH_pe or COFF_WITH_pep depending on whether
  56    we're compiling for straight PE or PE+.  */
  57 #define COFF_WITH_XX
  58
  59 #include "bfd.h"
  60 #include "sysdep.h"
  61 #include "libbfd.h"
  62 #include "coff/internal.h"
  63
  64 /* NOTE: it's strange to be including an architecture specific header
  65    in what's supposed to be general (to PE/PEI) code.  However, that's
  66    where the definitions are, and they don't vary per architecture
  67    within PE/PEI, so we get them from there.  FIXME: The lack of
  68    variance is an assumption which may prove to be incorrect if new
  69    PE/PEI targets are created.  */
  70 #ifdef COFF_WITH_pep
  71 # include "coff/ia64.h"
  72 #else
  73 # include "coff/i386.h"
  74 #endif
  75
  76 #include "coff/pe.h"
  77 #include "libcoff.h"
  78 #include "libpei.h"
  79
  80 #ifdef COFF_WITH_pep
  81 # undef AOUTSZ
  82 # define AOUTSZ         PEPAOUTSZ
  83 # define PEAOUTHDR      PEPAOUTHDR
  84 #endif
  85
  86 /* FIXME: This file has various tests of POWERPC_LE_PE.  Those tests
  87    worked when the code was in peicode.h, but no longer work now that
  88    the code is in peigen.c.  PowerPC NT is said to be dead.  If
  89    anybody wants to revive the code, you will have to figure out how
  90    to handle those issues.  */
  91 \f
  92 void
  93 _bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1)
  94 {
  95   SYMENT *ext = (SYMENT *) ext1;
  96   struct internal_syment *in = (struct internal_syment *) in1;
  97
  98   if (ext->e.e_name[0] == 0)
  99     {
 100       in->_n._n_n._n_zeroes = 0;
 101       in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
 102     }
 103   else
 104     memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
 105
 106   in->n_value = H_GET_32 (abfd, ext->e_value);
 107   in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
 108
 109   if (sizeof (ext->e_type) == 2)
 110     in->n_type = H_GET_16 (abfd, ext->e_type);
 111   else
 112     in->n_type = H_GET_32 (abfd, ext->e_type);
 113
 114   in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
 115   in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
 116
 117 #ifndef STRICT_PE_FORMAT
 118   /* This is for Gnu-created DLLs.  */
 119
 120   /* The section symbols for the .idata$ sections have class 0x68
 121      (C_SECTION), which MS documentation indicates is a section
 122      symbol.  Unfortunately, the value field in the symbol is simply a
 123      copy of the .idata section's flags rather than something useful.
 124      When these symbols are encountered, change the value to 0 so that
 125      they will be handled somewhat correctly in the bfd code.  */
 126   if (in->n_sclass == C_SECTION)
 127     {
 128       in->n_value = 0x0;
 129
 130       /* Create synthetic empty sections as needed.  DJ */
 131       if (in->n_scnum == 0)
 132         {
 133           asection *sec;
 134
 135           for (sec = abfd->sections; sec; sec = sec->next)
 136             {
 137               if (strcmp (sec->name, in->n_name) == 0)
 138                 {
 139                   in->n_scnum = sec->target_index;
 140                   break;
 141                 }
 142             }
 143         }
 144
 145       if (in->n_scnum == 0)
 146         {
 147           int unused_section_number = 0;
 148           asection *sec;
 149           char *name;
 150           flagword flags;
 151
 152           for (sec = abfd->sections; sec; sec = sec->next)
 153             if (unused_section_number <= sec->target_index)
 154               unused_section_number = sec->target_index + 1;
 155
 156           name = bfd_alloc (abfd, (bfd_size_type) strlen (in->n_name) + 10);
 157           if (name == NULL)
 158             return;
 159           strcpy (name, in->n_name);
 160           flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
 161           sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
 162
 163           sec->vma = 0;
 164           sec->lma = 0;
 165           sec->size = 0;
 166           sec->filepos = 0;
 167           sec->rel_filepos = 0;
 168           sec->reloc_count = 0;
 169           sec->line_filepos = 0;
 170           sec->lineno_count = 0;
 171           sec->userdata = NULL;
 172           sec->next = NULL;
 173           sec->alignment_power = 2;
 174
 175           sec->target_index = unused_section_number;
 176
 177           in->n_scnum = unused_section_number;
 178         }
 179       in->n_sclass = C_STAT;
 180     }
 181 #endif
 182
 183 #ifdef coff_swap_sym_in_hook
 184   /* This won't work in peigen.c, but since it's for PPC PE, it's not
 185      worth fixing.  */
 186   coff_swap_sym_in_hook (abfd, ext1, in1);
 187 #endif
 188 }
 189
 190 unsigned int
 191 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
 192 {
 193   struct internal_syment *in = (struct internal_syment *) inp;
 194   SYMENT *ext = (SYMENT *) extp;
 195
 196   if (in->_n._n_name[0] == 0)
 197     {
 198       H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
 199       H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
 200     }
 201   else
 202     memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
 203
 204   H_PUT_32 (abfd, in->n_value, ext->e_value);
 205   H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
 206
 207   if (sizeof (ext->e_type) == 2)
 208     H_PUT_16 (abfd, in->n_type, ext->e_type);
 209   else
 210     H_PUT_32 (abfd, in->n_type, ext->e_type);
 211
 212   H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
 213   H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
 214
 215   return SYMESZ;
 216 }
 217
 218 void
 219 _bfd_XXi_swap_aux_in (bfd *     abfd,
 220                       void *    ext1,
 221                       int       type,
 222                       int       class,
 223                       int       indx ATTRIBUTE_UNUSED,
 224                       int       numaux ATTRIBUTE_UNUSED,
 225                       void *    in1)
 226 {
 227   AUXENT *ext = (AUXENT *) ext1;
 228   union internal_auxent *in = (union internal_auxent *) in1;
 229
 230   switch (class)
 231     {
 232     case C_FILE:
 233       if (ext->x_file.x_fname[0] == 0)
 234         {
 235           in->x_file.x_n.x_zeroes = 0;
 236           in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
 237         }
 238       else
 239         memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
 240       return;
 241
 242     case C_STAT:
 243     case C_LEAFSTAT:
 244     case C_HIDDEN:
 245       if (type == T_NULL)
 246         {
 247           in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
 248           in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
 249           in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
 250           in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
 251           in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
 252           in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
 253           return;
 254         }
 255       break;
 256     }
 257
 258   in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
 259   in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
 260
 261   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
 262     {
 263       in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
 264       in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
 265     }
 266   else
 267     {
 268       in->x_sym.x_fcnary.x_ary.x_dimen[0] =
 269         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 270       in->x_sym.x_fcnary.x_ary.x_dimen[1] =
 271         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 272       in->x_sym.x_fcnary.x_ary.x_dimen[2] =
 273         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 274       in->x_sym.x_fcnary.x_ary.x_dimen[3] =
 275         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 276     }
 277
 278   if (ISFCN (type))
 279     {
 280       in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
 281     }
 282   else
 283     {
 284       in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
 285       in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
 286     }
 287 }
 288
 289 unsigned int
 290 _bfd_XXi_swap_aux_out (bfd *  abfd,
 291                        void * inp,
 292                        int    type,
 293                        int    class,
 294                        int    indx ATTRIBUTE_UNUSED,
 295                        int    numaux ATTRIBUTE_UNUSED,
 296                        void * extp)
 297 {
 298   union internal_auxent *in = (union internal_auxent *) inp;
 299   AUXENT *ext = (AUXENT *) extp;
 300
 301   memset (ext, 0, AUXESZ);
 302
 303   switch (class)
 304     {
 305     case C_FILE:
 306       if (in->x_file.x_fname[0] == 0)
 307         {
 308           H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
 309           H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
 310         }
 311       else
 312         memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
 313
 314       return AUXESZ;
 315
 316     case C_STAT:
 317     case C_LEAFSTAT:
 318     case C_HIDDEN:
 319       if (type == T_NULL)
 320         {
 321           PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
 322           PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
 323           PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
 324           H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
 325           H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
 326           H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
 327           return AUXESZ;
 328         }
 329       break;
 330     }
 331
 332   H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
 333   H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
 334
 335   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
 336     {
 337       PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,  ext);
 338       PUT_FCN_ENDNDX  (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
 339     }
 340   else
 341     {
 342       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
 343                 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 344       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
 345                 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 346       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
 347                 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 348       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
 349                 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 350     }
 351
 352   if (ISFCN (type))
 353     H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
 354   else
 355     {
 356       PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
 357       PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
 358     }
 359
 360   return AUXESZ;
 361 }
 362
 363 void
 364 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
 365 {
 366   LINENO *ext = (LINENO *) ext1;
 367   struct internal_lineno *in = (struct internal_lineno *) in1;
 368
 369   in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
 370   in->l_lnno = GET_LINENO_LNNO (abfd, ext);
 371 }
 372
 373 unsigned int
 374 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
 375 {
 376   struct internal_lineno *in = (struct internal_lineno *) inp;
 377   struct external_lineno *ext = (struct external_lineno *) outp;
 378   H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
 379
 380   PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
 381   return LINESZ;
 382 }
 383
 384 void
 385 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
 386                           void * aouthdr_ext1,
 387                           void * aouthdr_int1)
 388 {
 389   struct internal_extra_pe_aouthdr *a;
 390   PEAOUTHDR * src = (PEAOUTHDR *) (aouthdr_ext1);
 391   AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
 392   struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
 393
 394   aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
 395   aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
 396   aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
 397   aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
 398   aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
 399   aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
 400   aouthdr_int->text_start =
 401     GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
 402 #ifndef COFF_WITH_pep
 403   /* PE32+ does not have data_start member!  */
 404   aouthdr_int->data_start =
 405     GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
 406 #endif
 407
 408   a = &aouthdr_int->pe;
 409   a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
 410   a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
 411   a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
 412   a->MajorOperatingSystemVersion =
 413     H_GET_16 (abfd, src->MajorOperatingSystemVersion);
 414   a->MinorOperatingSystemVersion =
 415     H_GET_16 (abfd, src->MinorOperatingSystemVersion);
 416   a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
 417   a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
 418   a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
 419   a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
 420   a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
 421   a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
 422   a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
 423   a->CheckSum = H_GET_32 (abfd, src->CheckSum);
 424   a->Subsystem = H_GET_16 (abfd, src->Subsystem);
 425   a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
 426   a->SizeOfStackReserve =
 427     GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
 428   a->SizeOfStackCommit =
 429     GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
 430   a->SizeOfHeapReserve =
 431     GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
 432   a->SizeOfHeapCommit =
 433     GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
 434   a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
 435   a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
 436
 437   {
 438     int idx;
 439
 440     for (idx = 0; idx < 16; idx++)
 441       {
 442         /* If data directory is empty, rva also should be 0.  */
 443         int size =
 444           H_GET_32 (abfd, src->DataDirectory[idx][1]);
 445         a->DataDirectory[idx].Size = size;
 446
 447         if (size)
 448           a->DataDirectory[idx].VirtualAddress =
 449             H_GET_32 (abfd, src->DataDirectory[idx][0]);
 450         else
 451           a->DataDirectory[idx].VirtualAddress = 0;
 452       }
 453   }
 454
 455   if (aouthdr_int->entry)
 456     {
 457       aouthdr_int->entry += a->ImageBase;
 458 #ifndef COFF_WITH_pep
 459       aouthdr_int->entry &= 0xffffffff;
 460 #endif
 461     }
 462
 463   if (aouthdr_int->tsize)
 464     {
 465       aouthdr_int->text_start += a->ImageBase;
 466 #ifndef COFF_WITH_pep
 467       aouthdr_int->text_start &= 0xffffffff;
 468 #endif
 469     }
 470
 471 #ifndef COFF_WITH_pep
 472   /* PE32+ does not have data_start member!  */
 473   if (aouthdr_int->dsize)
 474     {
 475       aouthdr_int->data_start += a->ImageBase;
 476       aouthdr_int->data_start &= 0xffffffff;
 477     }
 478 #endif
 479
 480 #ifdef POWERPC_LE_PE
 481   /* These three fields are normally set up by ppc_relocate_section.
 482      In the case of reading a file in, we can pick them up from the
 483      DataDirectory.  */
 484   first_thunk_address = a->DataDirectory[12].VirtualAddress;
 485   thunk_size = a->DataDirectory[12].Size;
 486   import_table_size = a->DataDirectory[1].Size;
 487 #endif
 488 }
 489
 490 /* A support function for below.  */
 491
 492 static void
 493 add_data_entry (bfd * abfd,
 494                 struct internal_extra_pe_aouthdr *aout,
 495                 int idx,
 496                 char *name,
 497                 bfd_vma base)
 498 {
 499   asection *sec = bfd_get_section_by_name (abfd, name);
 500
 501   /* Add import directory information if it exists.  */
 502   if ((sec != NULL)
 503       && (coff_section_data (abfd, sec) != NULL)
 504       && (pei_section_data (abfd, sec) != NULL))
 505     {
 506       /* If data directory is empty, rva also should be 0.  */
 507       int size = pei_section_data (abfd, sec)->virt_size;
 508       aout->DataDirectory[idx].Size = size;
 509
 510       if (size)
 511         {
 512           aout->DataDirectory[idx].VirtualAddress =
 513             (sec->vma - base) & 0xffffffff;
 514           sec->flags |= SEC_DATA;
 515         }
 516     }
 517 }
 518
 519 unsigned int
 520 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
 521 {
 522   struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
 523   pe_data_type *pe = pe_data (abfd);
 524   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
 525   PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
 526   bfd_vma sa, fa, ib;
 527   IMAGE_DATA_DIRECTORY idata2, idata5, tls;
 528
 529   if (pe->force_minimum_alignment)
 530     {
 531       if (!extra->FileAlignment)
 532         extra->FileAlignment = PE_DEF_FILE_ALIGNMENT;
 533       if (!extra->SectionAlignment)
 534         extra->SectionAlignment = PE_DEF_SECTION_ALIGNMENT;
 535     }
 536
 537   if (extra->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
 538     extra->Subsystem = pe->target_subsystem;
 539
 540   sa = extra->SectionAlignment;
 541   fa = extra->FileAlignment;
 542   ib = extra->ImageBase;
 543
 544   idata2 = pe->pe_opthdr.DataDirectory[1];
 545   idata5 = pe->pe_opthdr.DataDirectory[12];
 546   tls = pe->pe_opthdr.DataDirectory[9];
 547
 548   if (aouthdr_in->tsize)
 549     {
 550       aouthdr_in->text_start -= ib;
 551 #ifndef COFF_WITH_pep
 552       aouthdr_in->text_start &= 0xffffffff;
 553 #endif
 554     }
 555
 556   if (aouthdr_in->dsize)
 557     {
 558       aouthdr_in->data_start -= ib;
 559 #ifndef COFF_WITH_pep
 560       aouthdr_in->data_start &= 0xffffffff;
 561 #endif
 562     }
 563
 564   if (aouthdr_in->entry)
 565     {
 566       aouthdr_in->entry -= ib;
 567 #ifndef COFF_WITH_pep
 568       aouthdr_in->entry &= 0xffffffff;
 569 #endif
 570     }
 571
 572 #define FA(x) (((x) + fa -1 ) & (- fa))
 573 #define SA(x) (((x) + sa -1 ) & (- sa))
 574
 575   /* We like to have the sizes aligned.  */
 576   aouthdr_in->bsize = FA (aouthdr_in->bsize);
 577
 578   extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
 579
 580   /* First null out all data directory entries.  */
 581   memset (extra->DataDirectory, 0, sizeof (extra->DataDirectory));
 582
 583   add_data_entry (abfd, extra, 0, ".edata", ib);
 584   add_data_entry (abfd, extra, 2, ".rsrc", ib);
 585   add_data_entry (abfd, extra, 3, ".pdata", ib);
 586
 587   /* In theory we do not need to call add_data_entry for .idata$2 or
 588      .idata$5.  It will be done in bfd_coff_final_link where all the
 589      required information is available.  If however, we are not going
 590      to perform a final link, eg because we have been invoked by objcopy
 591      or strip, then we need to make sure that these Data Directory
 592      entries are initialised properly.
 593
 594      So - we copy the input values into the output values, and then, if
 595      a final link is going to be performed, it can overwrite them.  */
 596   extra->DataDirectory[1]  = idata2;
 597   extra->DataDirectory[12] = idata5;
 598   extra->DataDirectory[9] = tls;
 599
 600   if (extra->DataDirectory[1].VirtualAddress == 0)
 601     /* Until other .idata fixes are made (pending patch), the entry for
 602        .idata is needed for backwards compatibility.  FIXME.  */
 603     add_data_entry (abfd, extra, 1, ".idata", ib);
 604
 605   /* For some reason, the virtual size (which is what's set by
 606      add_data_entry) for .reloc is not the same as the size recorded
 607      in this slot by MSVC; it doesn't seem to cause problems (so far),
 608      but since it's the best we've got, use it.  It does do the right
 609      thing for .pdata.  */
 610   if (pe->has_reloc_section)
 611     add_data_entry (abfd, extra, 5, ".reloc", ib);
 612
 613   {
 614     asection *sec;
 615     bfd_vma hsize = 0;
 616     bfd_vma dsize = 0;
 617     bfd_vma isize = 0;
 618     bfd_vma tsize = 0;
 619
 620     for (sec = abfd->sections; sec; sec = sec->next)
 621       {
 622         int rounded = FA (sec->size);
 623
 624         /* The first non-zero section filepos is the header size.
 625            Sections without contents will have a filepos of 0.  */
 626         if (hsize == 0)
 627           hsize = sec->filepos;
 628         if (sec->flags & SEC_DATA)
 629           dsize += rounded;
 630         if (sec->flags & SEC_CODE)
 631           tsize += rounded;
 632         /* The image size is the total VIRTUAL size (which is what is
 633            in the virt_size field).  Files have been seen (from MSVC
 634            5.0 link.exe) where the file size of the .data segment is
 635            quite small compared to the virtual size.  Without this
 636            fix, strip munges the file.  */
 637         if (coff_section_data (abfd, sec) != NULL
 638             && pei_section_data (abfd, sec) != NULL)
 639           isize += SA (FA (pei_section_data (abfd, sec)->virt_size));
 640       }
 641
 642     aouthdr_in->dsize = dsize;
 643     aouthdr_in->tsize = tsize;
 644     extra->SizeOfHeaders = hsize;
 645     extra->SizeOfImage = SA (hsize) + isize;
 646   }
 647
 648   H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
 649
 650 #define LINKER_VERSION 256 /* That is, 2.56 */
 651
 652   /* This piece of magic sets the "linker version" field to
 653      LINKER_VERSION.  */
 654   H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
 655             aouthdr_out->standard.vstamp);
 656
 657   PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
 658   PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
 659   PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
 660   PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
 661   PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
 662                           aouthdr_out->standard.text_start);
 663
 664 #ifndef COFF_WITH_pep
 665   /* PE32+ does not have data_start member!  */
 666   PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
 667                           aouthdr_out->standard.data_start);
 668 #endif
 669
 670   PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
 671   H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
 672   H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
 673   H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
 674             aouthdr_out->MajorOperatingSystemVersion);
 675   H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
 676             aouthdr_out->MinorOperatingSystemVersion);
 677   H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
 678   H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
 679   H_PUT_16 (abfd, extra->MajorSubsystemVersion,
 680             aouthdr_out->MajorSubsystemVersion);
 681   H_PUT_16 (abfd, extra->MinorSubsystemVersion,
 682             aouthdr_out->MinorSubsystemVersion);
 683   H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
 684   H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
 685   H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
 686   H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
 687   H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
 688   H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
 689   PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
 690                                     aouthdr_out->SizeOfStackReserve);
 691   PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
 692                                    aouthdr_out->SizeOfStackCommit);
 693   PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
 694                                    aouthdr_out->SizeOfHeapReserve);
 695   PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
 696                                   aouthdr_out->SizeOfHeapCommit);
 697   H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
 698   H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
 699             aouthdr_out->NumberOfRvaAndSizes);
 700   {
 701     int idx;
 702
 703     for (idx = 0; idx < 16; idx++)
 704       {
 705         H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
 706                   aouthdr_out->DataDirectory[idx][0]);
 707         H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
 708                   aouthdr_out->DataDirectory[idx][1]);
 709       }
 710   }
 711
 712   return AOUTSZ;
 713 }
 714
 715 unsigned int
 716 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
 717 {
 718   int idx;
 719   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 720   struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
 721
 722   if (pe_data (abfd)->has_reloc_section)
 723     filehdr_in->f_flags &= ~F_RELFLG;
 724
 725   if (pe_data (abfd)->dll)
 726     filehdr_in->f_flags |= F_DLL;
 727
 728   filehdr_in->pe.e_magic    = DOSMAGIC;
 729   filehdr_in->pe.e_cblp     = 0x90;
 730   filehdr_in->pe.e_cp       = 0x3;
 731   filehdr_in->pe.e_crlc     = 0x0;
 732   filehdr_in->pe.e_cparhdr  = 0x4;
 733   filehdr_in->pe.e_minalloc = 0x0;
 734   filehdr_in->pe.e_maxalloc = 0xffff;
 735   filehdr_in->pe.e_ss       = 0x0;
 736   filehdr_in->pe.e_sp       = 0xb8;
 737   filehdr_in->pe.e_csum     = 0x0;
 738   filehdr_in->pe.e_ip       = 0x0;
 739   filehdr_in->pe.e_cs       = 0x0;
 740   filehdr_in->pe.e_lfarlc   = 0x40;
 741   filehdr_in->pe.e_ovno     = 0x0;
 742
 743   for (idx = 0; idx < 4; idx++)
 744     filehdr_in->pe.e_res[idx] = 0x0;
 745
 746   filehdr_in->pe.e_oemid   = 0x0;
 747   filehdr_in->pe.e_oeminfo = 0x0;
 748
 749   for (idx = 0; idx < 10; idx++)
 750     filehdr_in->pe.e_res2[idx] = 0x0;
 751
 752   filehdr_in->pe.e_lfanew = 0x80;
 753
 754   /* This next collection of data are mostly just characters.  It
 755      appears to be constant within the headers put on NT exes.  */
 756   filehdr_in->pe.dos_message[0]  = 0x0eba1f0e;
 757   filehdr_in->pe.dos_message[1]  = 0xcd09b400;
 758   filehdr_in->pe.dos_message[2]  = 0x4c01b821;
 759   filehdr_in->pe.dos_message[3]  = 0x685421cd;
 760   filehdr_in->pe.dos_message[4]  = 0x70207369;
 761   filehdr_in->pe.dos_message[5]  = 0x72676f72;
 762   filehdr_in->pe.dos_message[6]  = 0x63206d61;
 763   filehdr_in->pe.dos_message[7]  = 0x6f6e6e61;
 764   filehdr_in->pe.dos_message[8]  = 0x65622074;
 765   filehdr_in->pe.dos_message[9]  = 0x6e757220;
 766   filehdr_in->pe.dos_message[10] = 0x206e6920;
 767   filehdr_in->pe.dos_message[11] = 0x20534f44;
 768   filehdr_in->pe.dos_message[12] = 0x65646f6d;
 769   filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
 770   filehdr_in->pe.dos_message[14] = 0x24;
 771   filehdr_in->pe.dos_message[15] = 0x0;
 772   filehdr_in->pe.nt_signature = NT_SIGNATURE;
 773
 774   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
 775   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 776
 777   H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
 778   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
 779                       filehdr_out->f_symptr);
 780   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 781   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 782   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 783
 784   /* Put in extra dos header stuff.  This data remains essentially
 785      constant, it just has to be tacked on to the beginning of all exes
 786      for NT.  */
 787   H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
 788   H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
 789   H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
 790   H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
 791   H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
 792   H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
 793   H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
 794   H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
 795   H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
 796   H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
 797   H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
 798   H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
 799   H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
 800   H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
 801
 802   for (idx = 0; idx < 4; idx++)
 803     H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
 804
 805   H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
 806   H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
 807
 808   for (idx = 0; idx < 10; idx++)
 809     H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
 810
 811   H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
 812
 813   for (idx = 0; idx < 16; idx++)
 814     H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
 815               filehdr_out->dos_message[idx]);
 816
 817   /* Also put in the NT signature.  */
 818   H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
 819
 820   return FILHSZ;
 821 }
 822
 823 unsigned int
 824 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
 825 {
 826   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 827   FILHDR *filehdr_out = (FILHDR *) out;
 828
 829   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
 830   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 831   H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
 832   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
 833   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 834   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 835   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 836
 837   return FILHSZ;
 838 }
 839
 840 unsigned int
 841 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
 842 {
 843   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 844   SCNHDR *scnhdr_ext = (SCNHDR *) out;
 845   unsigned int ret = SCNHSZ;
 846   bfd_vma ps;
 847   bfd_vma ss;
 848
 849   memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
 850
 851   PUT_SCNHDR_VADDR (abfd,
 852                     ((scnhdr_int->s_vaddr
 853                       - pe_data (abfd)->pe_opthdr.ImageBase)
 854                      & 0xffffffff),
 855                     scnhdr_ext->s_vaddr);
 856
 857   /* NT wants the size data to be rounded up to the next
 858      NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
 859      sometimes).  */
 860   if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
 861     {
 862       if (bfd_pe_executable_p (abfd))
 863         {
 864           ps = scnhdr_int->s_size;
 865           ss = 0;
 866         }
 867       else
 868        {
 869          ps = 0;
 870          ss = scnhdr_int->s_size;
 871        }
 872     }
 873   else
 874     {
 875       if (bfd_pe_executable_p (abfd))
 876         ps = scnhdr_int->s_paddr;
 877       else
 878         ps = 0;
 879
 880       ss = scnhdr_int->s_size;
 881     }
 882
 883   PUT_SCNHDR_SIZE (abfd, ss,
 884                    scnhdr_ext->s_size);
 885
 886   /* s_paddr in PE is really the virtual size.  */
 887   PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
 888
 889   PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
 890                      scnhdr_ext->s_scnptr);
 891   PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
 892                      scnhdr_ext->s_relptr);
 893   PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
 894                       scnhdr_ext->s_lnnoptr);
 895
 896   {
 897     /* Extra flags must be set when dealing with PE.  All sections should also
 898        have the IMAGE_SCN_MEM_READ (0x40000000) flag set.  In addition, the
 899        .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
 900        sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
 901        (this is especially important when dealing with the .idata section since
 902        the addresses for routines from .dlls must be overwritten).  If .reloc
 903        section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
 904        (0x02000000).  Also, the resource data should also be read and
 905        writable.  */
 906
 907     /* FIXME: Alignment is also encoded in this field, at least on PPC and
 908        ARM-WINCE.  Although - how do we get the original alignment field
 909        back ?  */
 910
 911     typedef struct
 912     {
 913       const char *      section_name;
 914       unsigned long     must_have;
 915     }
 916     pe_required_section_flags;
 917
 918     pe_required_section_flags known_sections [] =
 919       {
 920         { ".arch",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
 921         { ".bss",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 922         { ".data",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 923         { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
 924         { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 925         { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
 926         { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
 927         { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
 928         { ".rsrc",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 929         { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
 930         { ".tls",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
 931         { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
 932         { NULL, 0}
 933       };
 934
 935     pe_required_section_flags * p;
 936
 937     /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
 938        we know exactly what this specific section wants so we remove it
 939        and then allow the must_have field to add it back in if necessary.
 940        However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
 941        default WP_TEXT file flag has been cleared.  WP_TEXT may be cleared
 942        by ld --enable-auto-import (if auto-import is actually needed),
 943        by ld --omagic, or by obcopy --writable-text.  */
 944
 945     for (p = known_sections; p->section_name; p++)
 946       if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
 947         {
 948           if (strcmp (scnhdr_int->s_name, ".text")
 949               || (bfd_get_file_flags (abfd) & WP_TEXT))
 950             scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
 951           scnhdr_int->s_flags |= p->must_have;
 952           break;
 953         }
 954
 955     H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
 956   }
 957
 958   if (coff_data (abfd)->link_info
 959       && ! coff_data (abfd)->link_info->relocatable
 960       && ! coff_data (abfd)->link_info->shared
 961       && strcmp (scnhdr_int->s_name, ".text") == 0)
 962     {
 963       /* By inference from looking at MS output, the 32 bit field
 964          which is the combination of the number_of_relocs and
 965          number_of_linenos is used for the line number count in
 966          executables.  A 16-bit field won't do for cc1.  The MS
 967          document says that the number of relocs is zero for
 968          executables, but the 17-th bit has been observed to be there.
 969          Overflow is not an issue: a 4G-line program will overflow a
 970          bunch of other fields long before this!  */
 971       H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
 972       H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
 973     }
 974   else
 975     {
 976       if (scnhdr_int->s_nlnno <= 0xffff)
 977         H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
 978       else
 979         {
 980           (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
 981                                  bfd_get_filename (abfd),
 982                                  scnhdr_int->s_nlnno);
 983           bfd_set_error (bfd_error_file_truncated);
 984           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
 985           ret = 0;
 986         }
 987
 988       /* Although we could encode 0xffff relocs here, we do not, to be
 989          consistent with other parts of bfd. Also it lets us warn, as
 990          we should never see 0xffff here w/o having the overflow flag
 991          set.  */
 992       if (scnhdr_int->s_nreloc < 0xffff)
 993         H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
 994       else
 995         {
 996           /* PE can deal with large #s of relocs, but not here.  */
 997           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
 998           scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
 999           H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1000         }
1001     }
1002   return ret;
1003 }
1004
1005 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1006 {
1007   N_("Export Directory [.edata (or where ever we found it)]"),
1008   N_("Import Directory [parts of .idata]"),
1009   N_("Resource Directory [.rsrc]"),
1010   N_("Exception Directory [.pdata]"),
1011   N_("Security Directory"),
1012   N_("Base Relocation Directory [.reloc]"),
1013   N_("Debug Directory"),
1014   N_("Description Directory"),
1015   N_("Special Directory"),
1016   N_("Thread Storage Directory [.tls]"),
1017   N_("Load Configuration Directory"),
1018   N_("Bound Import Directory"),
1019   N_("Import Address Table Directory"),
1020   N_("Delay Import Directory"),
1021   N_("Reserved"),
1022   N_("Reserved")
1023 };
1024
1025 #ifdef POWERPC_LE_PE
1026 /* The code for the PPC really falls in the "architecture dependent"
1027    category.  However, it's not clear that anyone will ever care, so
1028    we're ignoring the issue for now; if/when PPC matters, some of this
1029    may need to go into peicode.h, or arguments passed to enable the
1030    PPC- specific code.  */
1031 #endif
1032
1033 static bfd_boolean
1034 pe_print_idata (bfd * abfd, void * vfile)
1035 {
1036   FILE *file = (FILE *) vfile;
1037   bfd_byte *data;
1038   asection *section;
1039   bfd_signed_vma adj;
1040
1041 #ifdef POWERPC_LE_PE
1042   asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1043 #endif
1044
1045   bfd_size_type datasize = 0;
1046   bfd_size_type dataoff;
1047   bfd_size_type i;
1048   int onaline = 20;
1049
1050   pe_data_type *pe = pe_data (abfd);
1051   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1052
1053   bfd_vma addr;
1054
1055   addr = extra->DataDirectory[1].VirtualAddress;
1056
1057   if (addr == 0 && extra->DataDirectory[1].Size == 0)
1058     {
1059       /* Maybe the extra header isn't there.  Look for the section.  */
1060       section = bfd_get_section_by_name (abfd, ".idata");
1061       if (section == NULL)
1062         return TRUE;
1063
1064       addr = section->vma;
1065       datasize = section->size;
1066       if (datasize == 0)
1067         return TRUE;
1068     }
1069   else
1070     {
1071       addr += extra->ImageBase;
1072       for (section = abfd->sections; section != NULL; section = section->next)
1073         {
1074           datasize = section->size;
1075           if (addr >= section->vma && addr < section->vma + datasize)
1076             break;
1077         }
1078
1079       if (section == NULL)
1080         {
1081           fprintf (file,
1082                    _("\nThere is an import table, but the section containing it could not be found\n"));
1083           return TRUE;
1084         }
1085     }
1086
1087   fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1088            section->name, (unsigned long) addr);
1089
1090   dataoff = addr - section->vma;
1091   datasize -= dataoff;
1092
1093 #ifdef POWERPC_LE_PE
1094   if (rel_section != 0 && rel_section->size != 0)
1095     {
1096       /* The toc address can be found by taking the starting address,
1097          which on the PPC locates a function descriptor. The
1098          descriptor consists of the function code starting address
1099          followed by the address of the toc. The starting address we
1100          get from the bfd, and the descriptor is supposed to be in the
1101          .reldata section.  */
1102
1103       bfd_vma loadable_toc_address;
1104       bfd_vma toc_address;
1105       bfd_vma start_address;
1106       bfd_byte *data;
1107       bfd_vma offset;
1108
1109       if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1110         {
1111           if (data != NULL)
1112             free (data);
1113           return FALSE;
1114         }
1115
1116       offset = abfd->start_address - rel_section->vma;
1117
1118       if (offset >= rel_section->size || offset + 8 > rel_section->size)
1119         {
1120           if (data != NULL)
1121             free (data);
1122           return FALSE;
1123         }
1124
1125       start_address = bfd_get_32 (abfd, data + offset);
1126       loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1127       toc_address = loadable_toc_address - 32768;
1128
1129       fprintf (file,
1130                _("\nFunction descriptor located at the start address: %04lx\n"),
1131                (unsigned long int) (abfd->start_address));
1132       fprintf (file,
1133                _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1134                start_address, loadable_toc_address, toc_address);
1135       if (data != NULL)
1136         free (data);
1137     }
1138   else
1139     {
1140       fprintf (file,
1141                _("\nNo reldata section! Function descriptor not decoded.\n"));
1142     }
1143 #endif
1144
1145   fprintf (file,
1146            _("\nThe Import Tables (interpreted %s section contents)\n"),
1147            section->name);
1148   fprintf (file,
1149            _("\
1150  vma:            Hint    Time      Forward  DLL       First\n\
1151                  Table   Stamp     Chain    Name      Thunk\n"));
1152
1153   /* Read the whole section.  Some of the fields might be before dataoff.  */
1154   if (!bfd_malloc_and_get_section (abfd, section, &data))
1155     {
1156       if (data != NULL)
1157         free (data);
1158       return FALSE;
1159     }
1160
1161   adj = section->vma - extra->ImageBase;
1162
1163   /* Print all image import descriptors.  */
1164   for (i = 0; i < datasize; i += onaline)
1165     {
1166       bfd_vma hint_addr;
1167       bfd_vma time_stamp;
1168       bfd_vma forward_chain;
1169       bfd_vma dll_name;
1170       bfd_vma first_thunk;
1171       int idx = 0;
1172       bfd_size_type j;
1173       char *dll;
1174
1175       /* Print (i + extra->DataDirectory[1].VirtualAddress).  */
1176       fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
1177       hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1178       time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1179       forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1180       dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1181       first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1182
1183       fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1184                (unsigned long) hint_addr,
1185                (unsigned long) time_stamp,
1186                (unsigned long) forward_chain,
1187                (unsigned long) dll_name,
1188                (unsigned long) first_thunk);
1189
1190       if (hint_addr == 0 && first_thunk == 0)
1191         break;
1192
1193       if (dll_name - adj >= section->size)
1194         break;
1195
1196       dll = (char *) data + dll_name - adj;
1197       fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1198
1199       if (hint_addr != 0)
1200         {
1201           bfd_byte *ft_data;
1202           asection *ft_section;
1203           bfd_vma ft_addr;
1204           bfd_size_type ft_datasize;
1205           int ft_idx;
1206           int ft_allocated = 0;
1207
1208           fprintf (file, _("\tvma:  Hint/Ord Member-Name Bound-To\n"));
1209
1210           idx = hint_addr - adj;
1211
1212           ft_addr = first_thunk + extra->ImageBase;
1213           ft_data = data;
1214           ft_idx = first_thunk - adj;
1215           ft_allocated = 0;
1216
1217           if (first_thunk != hint_addr)
1218             {
1219               /* Find the section which contains the first thunk.  */
1220               for (ft_section = abfd->sections;
1221                    ft_section != NULL;
1222                    ft_section = ft_section->next)
1223                 {
1224                   ft_datasize = ft_section->size;
1225                   if (ft_addr >= ft_section->vma
1226                       && ft_addr < ft_section->vma + ft_datasize)
1227                     break;
1228                 }
1229
1230               if (ft_section == NULL)
1231                 {
1232                   fprintf (file,
1233                        _("\nThere is a first thunk, but the section containing it could not be found\n"));
1234                   continue;
1235                 }
1236
1237               /* Now check to see if this section is the same as our current
1238                  section.  If it is not then we will have to load its data in.  */
1239               if (ft_section == section)
1240                 {
1241                   ft_data = data;
1242                   ft_idx = first_thunk - adj;
1243                 }
1244               else
1245                 {
1246                   ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1247                   ft_data = bfd_malloc (datasize);
1248                   if (ft_data == NULL)
1249                     continue;
1250
1251                   /* Read datasize bfd_bytes starting at offset ft_idx.  */
1252                   if (! bfd_get_section_contents
1253                       (abfd, ft_section, ft_data, (bfd_vma) ft_idx, datasize))
1254                     {
1255                       free (ft_data);
1256                       continue;
1257                     }
1258
1259                   ft_idx = 0;
1260                   ft_allocated = 1;
1261                 }
1262             }
1263
1264           /* Print HintName vector entries.  */
1265           for (j = 0; j < datasize; j += 4)
1266             {
1267               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1268
1269               /* Print single IMAGE_IMPORT_BY_NAME vector.  */
1270               if (member == 0)
1271                 break;
1272
1273               if (member & 0x80000000)
1274                 fprintf (file, "\t%04lx\t %4lu  <none>",
1275                          member, member & 0x7fffffff);
1276               else
1277                 {
1278                   int ordinal;
1279                   char *member_name;
1280
1281                   ordinal = bfd_get_16 (abfd, data + member - adj);
1282                   member_name = (char *) data + member - adj + 2;
1283                   fprintf (file, "\t%04lx\t %4d  %s",
1284                            member, ordinal, member_name);
1285                 }
1286
1287               /* If the time stamp is not zero, the import address
1288                  table holds actual addresses.  */
1289               if (time_stamp != 0
1290                   && first_thunk != 0
1291                   && first_thunk != hint_addr)
1292                 fprintf (file, "\t%04lx",
1293                          (long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1294
1295               fprintf (file, "\n");
1296             }
1297
1298           if (ft_allocated)
1299             free (ft_data);
1300         }
1301
1302       fprintf (file, "\n");
1303     }
1304
1305   free (data);
1306
1307   return TRUE;
1308 }
1309
1310 static bfd_boolean
1311 pe_print_edata (bfd * abfd, void * vfile)
1312 {
1313   FILE *file = (FILE *) vfile;
1314   bfd_byte *data;
1315   asection *section;
1316   bfd_size_type datasize = 0;
1317   bfd_size_type dataoff;
1318   bfd_size_type i;
1319   bfd_signed_vma adj;
1320   struct EDT_type
1321   {
1322     long export_flags;          /* Reserved - should be zero.  */
1323     long time_stamp;
1324     short major_ver;
1325     short minor_ver;
1326     bfd_vma name;               /* RVA - relative to image base.  */
1327     long base;                  /* Ordinal base.  */
1328     unsigned long num_functions;/* Number in the export address table.  */
1329     unsigned long num_names;    /* Number in the name pointer table.  */
1330     bfd_vma eat_addr;           /* RVA to the export address table.  */
1331     bfd_vma npt_addr;           /* RVA to the Export Name Pointer Table.  */
1332     bfd_vma ot_addr;            /* RVA to the Ordinal Table.  */
1333   } edt;
1334
1335   pe_data_type *pe = pe_data (abfd);
1336   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1337
1338   bfd_vma addr;
1339
1340   addr = extra->DataDirectory[0].VirtualAddress;
1341
1342   if (addr == 0 && extra->DataDirectory[0].Size == 0)
1343     {
1344       /* Maybe the extra header isn't there.  Look for the section.  */
1345       section = bfd_get_section_by_name (abfd, ".edata");
1346       if (section == NULL)
1347         return TRUE;
1348
1349       addr = section->vma;
1350       dataoff = 0;
1351       datasize = section->size;
1352       if (datasize == 0)
1353         return TRUE;
1354     }
1355   else
1356     {
1357       addr += extra->ImageBase;
1358
1359       for (section = abfd->sections; section != NULL; section = section->next)
1360         if (addr >= section->vma && addr < section->vma + section->size)
1361           break;
1362
1363       if (section == NULL)
1364         {
1365           fprintf (file,
1366                    _("\nThere is an export table, but the section containing it could not be found\n"));
1367           return TRUE;
1368         }
1369
1370       dataoff = addr - section->vma;
1371       datasize = extra->DataDirectory[0].Size;
1372       if (datasize > section->size - dataoff)
1373         {
1374           fprintf (file,
1375                    _("\nThere is an export table in %s, but it does not fit into that section\n"),
1376                    section->name);
1377           return TRUE;
1378         }
1379     }
1380
1381   fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1382            section->name, (unsigned long) addr);
1383
1384   data = bfd_malloc (datasize);
1385   if (data == NULL)
1386     return FALSE;
1387
1388   if (! bfd_get_section_contents (abfd, section, data,
1389                                   (file_ptr) dataoff, datasize))
1390     return FALSE;
1391
1392   /* Go get Export Directory Table.  */
1393   edt.export_flags   = bfd_get_32 (abfd, data +  0);
1394   edt.time_stamp     = bfd_get_32 (abfd, data +  4);
1395   edt.major_ver      = bfd_get_16 (abfd, data +  8);
1396   edt.minor_ver      = bfd_get_16 (abfd, data + 10);
1397   edt.name           = bfd_get_32 (abfd, data + 12);
1398   edt.base           = bfd_get_32 (abfd, data + 16);
1399   edt.num_functions  = bfd_get_32 (abfd, data + 20);
1400   edt.num_names      = bfd_get_32 (abfd, data + 24);
1401   edt.eat_addr       = bfd_get_32 (abfd, data + 28);
1402   edt.npt_addr       = bfd_get_32 (abfd, data + 32);
1403   edt.ot_addr        = bfd_get_32 (abfd, data + 36);
1404
1405   adj = section->vma - extra->ImageBase + dataoff;
1406
1407   /* Dump the EDT first.  */
1408   fprintf (file,
1409            _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1410            section->name);
1411
1412   fprintf (file,
1413            _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1414
1415   fprintf (file,
1416            _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1417
1418   fprintf (file,
1419            _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1420
1421   fprintf (file,
1422            _("Name \t\t\t\t"));
1423   fprintf_vma (file, edt.name);
1424   fprintf (file,
1425            " %s\n", data + edt.name - adj);
1426
1427   fprintf (file,
1428            _("Ordinal Base \t\t\t%ld\n"), edt.base);
1429
1430   fprintf (file,
1431            _("Number in:\n"));
1432
1433   fprintf (file,
1434            _("\tExport Address Table \t\t%08lx\n"),
1435            edt.num_functions);
1436
1437   fprintf (file,
1438            _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1439
1440   fprintf (file,
1441            _("Table Addresses\n"));
1442
1443   fprintf (file,
1444            _("\tExport Address Table \t\t"));
1445   fprintf_vma (file, edt.eat_addr);
1446   fprintf (file, "\n");
1447
1448   fprintf (file,
1449            _("\tName Pointer Table \t\t"));
1450   fprintf_vma (file, edt.npt_addr);
1451   fprintf (file, "\n");
1452
1453   fprintf (file,
1454            _("\tOrdinal Table \t\t\t"));
1455   fprintf_vma (file, edt.ot_addr);
1456   fprintf (file, "\n");
1457
1458   /* The next table to find is the Export Address Table. It's basically
1459      a list of pointers that either locate a function in this dll, or
1460      forward the call to another dll. Something like:
1461       typedef union
1462       {
1463         long export_rva;
1464         long forwarder_rva;
1465       } export_address_table_entry;  */
1466
1467   fprintf (file,
1468           _("\nExport Address Table -- Ordinal Base %ld\n"),
1469           edt.base);
1470
1471   for (i = 0; i < edt.num_functions; ++i)
1472     {
1473       bfd_vma eat_member = bfd_get_32 (abfd,
1474                                        data + edt.eat_addr + (i * 4) - adj);
1475       if (eat_member == 0)
1476         continue;
1477
1478       if (eat_member - adj <= datasize)
1479         {
1480           /* This rva is to a name (forwarding function) in our section.  */
1481           /* Should locate a function descriptor.  */
1482           fprintf (file,
1483                    "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1484                    (long) i,
1485                    (long) (i + edt.base),
1486                    (unsigned long) eat_member,
1487                    _("Forwarder RVA"),
1488                    data + eat_member - adj);
1489         }
1490       else
1491         {
1492           /* Should locate a function descriptor in the reldata section.  */
1493           fprintf (file,
1494                    "\t[%4ld] +base[%4ld] %04lx %s\n",
1495                    (long) i,
1496                    (long) (i + edt.base),
1497                    (unsigned long) eat_member,
1498                    _("Export RVA"));
1499         }
1500     }
1501
1502   /* The Export Name Pointer Table is paired with the Export Ordinal Table.  */
1503   /* Dump them in parallel for clarity.  */
1504   fprintf (file,
1505            _("\n[Ordinal/Name Pointer] Table\n"));
1506
1507   for (i = 0; i < edt.num_names; ++i)
1508     {
1509       bfd_vma name_ptr = bfd_get_32 (abfd,
1510                                     data +
1511                                     edt.npt_addr
1512                                     + (i*4) - adj);
1513
1514       char *name = (char *) data + name_ptr - adj;
1515
1516       bfd_vma ord = bfd_get_16 (abfd,
1517                                     data +
1518                                     edt.ot_addr
1519                                     + (i*2) - adj);
1520       fprintf (file,
1521               "\t[%4ld] %s\n", (long) ord, name);
1522     }
1523
1524   free (data);
1525
1526   return TRUE;
1527 }
1528
1529 /* This really is architecture dependent.  On IA-64, a .pdata entry
1530    consists of three dwords containing relative virtual addresses that
1531    specify the start and end address of the code range the entry
1532    covers and the address of the corresponding unwind info data.  */
1533
1534 static bfd_boolean
1535 pe_print_pdata (bfd * abfd, void * vfile)
1536 {
1537 #ifdef COFF_WITH_pep
1538 # define PDATA_ROW_SIZE (3*8)
1539 #else
1540 # define PDATA_ROW_SIZE (5*4)
1541 #endif
1542   FILE *file = (FILE *) vfile;
1543   bfd_byte *data = 0;
1544   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1545   bfd_size_type datasize = 0;
1546   bfd_size_type i;
1547   bfd_size_type start, stop;
1548   int onaline = PDATA_ROW_SIZE;
1549
1550   if (section == NULL
1551       || coff_section_data (abfd, section) == NULL
1552       || pei_section_data (abfd, section) == NULL)
1553     return TRUE;
1554
1555   stop = pei_section_data (abfd, section)->virt_size;
1556   if ((stop % onaline) != 0)
1557     fprintf (file,
1558              _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1559              (long) stop, onaline);
1560
1561   fprintf (file,
1562            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1563 #ifdef COFF_WITH_pep
1564   fprintf (file,
1565            _(" vma:\t\t\tBegin Address    End Address      Unwind Info\n"));
1566 #else
1567   fprintf (file, _("\
1568  vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n\
1569      \t\tAddress  Address  Handler  Data     Address    Mask\n"));
1570 #endif
1571
1572   datasize = section->size;
1573   if (datasize == 0)
1574     return TRUE;
1575
1576   if (! bfd_malloc_and_get_section (abfd, section, &data))
1577     {
1578       if (data != NULL)
1579         free (data);
1580       return FALSE;
1581     }
1582
1583   start = 0;
1584
1585   for (i = start; i < stop; i += onaline)
1586     {
1587       bfd_vma begin_addr;
1588       bfd_vma end_addr;
1589       bfd_vma eh_handler;
1590       bfd_vma eh_data;
1591       bfd_vma prolog_end_addr;
1592       int em_data;
1593
1594       if (i + PDATA_ROW_SIZE > stop)
1595         break;
1596
1597       begin_addr      = GET_PDATA_ENTRY (abfd, data + i     );
1598       end_addr        = GET_PDATA_ENTRY (abfd, data + i +  4);
1599       eh_handler      = GET_PDATA_ENTRY (abfd, data + i +  8);
1600       eh_data         = GET_PDATA_ENTRY (abfd, data + i + 12);
1601       prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1602
1603       if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1604           && eh_data == 0 && prolog_end_addr == 0)
1605         /* We are probably into the padding of the section now.  */
1606         break;
1607
1608       em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1609       eh_handler &= ~(bfd_vma) 0x3;
1610       prolog_end_addr &= ~(bfd_vma) 0x3;
1611
1612       fputc (' ', file);
1613       fprintf_vma (file, i + section->vma); fputc ('\t', file);
1614       fprintf_vma (file, begin_addr); fputc (' ', file);
1615       fprintf_vma (file, end_addr); fputc (' ', file);
1616       fprintf_vma (file, eh_handler);
1617 #ifndef COFF_WITH_pep
1618       fputc (' ', file);
1619       fprintf_vma (file, eh_data); fputc (' ', file);
1620       fprintf_vma (file, prolog_end_addr);
1621       fprintf (file, "   %x", em_data);
1622 #endif
1623
1624 #ifdef POWERPC_LE_PE
1625       if (eh_handler == 0 && eh_data != 0)
1626         {
1627           /* Special bits here, although the meaning may be a little
1628              mysterious. The only one I know for sure is 0x03
1629              Code Significance
1630              0x00 None
1631              0x01 Register Save Millicode
1632              0x02 Register Restore Millicode
1633              0x03 Glue Code Sequence.  */
1634           switch (eh_data)
1635             {
1636             case 0x01:
1637               fprintf (file, _(" Register save millicode"));
1638               break;
1639             case 0x02:
1640               fprintf (file, _(" Register restore millicode"));
1641               break;
1642             case 0x03:
1643               fprintf (file, _(" Glue code sequence"));
1644               break;
1645             default:
1646               break;
1647             }
1648         }
1649 #endif
1650       fprintf (file, "\n");
1651     }
1652
1653   free (data);
1654
1655   return TRUE;
1656 }
1657
1658 #define IMAGE_REL_BASED_HIGHADJ 4
1659 static const char * const tbl[] =
1660 {
1661   "ABSOLUTE",
1662   "HIGH",
1663   "LOW",
1664   "HIGHLOW",
1665   "HIGHADJ",
1666   "MIPS_JMPADDR",
1667   "SECTION",
1668   "REL32",
1669   "RESERVED1",
1670   "MIPS_JMPADDR16",
1671   "DIR64",
1672   "HIGH3ADJ",
1673   "UNKNOWN",   /* MUST be last.  */
1674 };
1675
1676 static bfd_boolean
1677 pe_print_reloc (bfd * abfd, void * vfile)
1678 {
1679   FILE *file = (FILE *) vfile;
1680   bfd_byte *data = 0;
1681   asection *section = bfd_get_section_by_name (abfd, ".reloc");
1682   bfd_size_type datasize;
1683   bfd_size_type i;
1684   bfd_size_type start, stop;
1685
1686   if (section == NULL)
1687     return TRUE;
1688
1689   if (section->size == 0)
1690     return TRUE;
1691
1692   fprintf (file,
1693            _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1694
1695   datasize = section->size;
1696   if (! bfd_malloc_and_get_section (abfd, section, &data))
1697     {
1698       if (data != NULL)
1699         free (data);
1700       return FALSE;
1701     }
1702
1703   start = 0;
1704
1705   stop = section->size;
1706
1707   for (i = start; i < stop;)
1708     {
1709       int j;
1710       bfd_vma virtual_address;
1711       long number, size;
1712
1713       /* The .reloc section is a sequence of blocks, with a header consisting
1714          of two 32 bit quantities, followed by a number of 16 bit entries.  */
1715       virtual_address = bfd_get_32 (abfd, data+i);
1716       size = bfd_get_32 (abfd, data+i+4);
1717       number = (size - 8) / 2;
1718
1719       if (size == 0)
1720         break;
1721
1722       fprintf (file,
1723                _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1724                (unsigned long) virtual_address, size, size, number);
1725
1726       for (j = 0; j < number; ++j)
1727         {
1728           unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1729           unsigned int t = (e & 0xF000) >> 12;
1730           int off = e & 0x0FFF;
1731
1732           if (t >= sizeof (tbl) / sizeof (tbl[0]))
1733             t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1734
1735           fprintf (file,
1736                    _("\treloc %4d offset %4x [%4lx] %s"),
1737                    j, off, (long) (off + virtual_address), tbl[t]);
1738
1739           /* HIGHADJ takes an argument, - the next record *is* the
1740              low 16 bits of addend.  */
1741           if (t == IMAGE_REL_BASED_HIGHADJ)
1742             {
1743               fprintf (file, " (%4x)",
1744                        ((unsigned int)
1745                         bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1746               j++;
1747             }
1748
1749           fprintf (file, "\n");
1750         }
1751
1752       i += size;
1753     }
1754
1755   free (data);
1756
1757   return TRUE;
1758 }
1759
1760 /* Print out the program headers.  */
1761
1762 bfd_boolean
1763 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
1764 {
1765   FILE *file = (FILE *) vfile;
1766   int j;
1767   pe_data_type *pe = pe_data (abfd);
1768   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
1769   const char *subsystem_name = NULL;
1770
1771   /* The MS dumpbin program reportedly ands with 0xff0f before
1772      printing the characteristics field.  Not sure why.  No reason to
1773      emulate it here.  */
1774   fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
1775 #undef PF
1776 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
1777   PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
1778   PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
1779   PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
1780   PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
1781   PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
1782   PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
1783   PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
1784   PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
1785   PF (IMAGE_FILE_SYSTEM, "system file");
1786   PF (IMAGE_FILE_DLL, "DLL");
1787   PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
1788 #undef PF
1789
1790   /* ctime implies '\n'.  */
1791   {
1792     time_t t = pe->coff.timestamp;
1793     fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
1794   }
1795   fprintf (file, "\nImageBase\t\t");
1796   fprintf_vma (file, i->ImageBase);
1797   fprintf (file, "\nSectionAlignment\t");
1798   fprintf_vma (file, i->SectionAlignment);
1799   fprintf (file, "\nFileAlignment\t\t");
1800   fprintf_vma (file, i->FileAlignment);
1801   fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1802   fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1803   fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
1804   fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
1805   fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1806   fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1807   fprintf (file, "Win32Version\t\t%08lx\n", i->Reserved1);
1808   fprintf (file, "SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1809   fprintf (file, "SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1810   fprintf (file, "CheckSum\t\t%08lx\n", i->CheckSum);
1811
1812   switch (i->Subsystem)
1813     {
1814     case IMAGE_SUBSYSTEM_UNKNOWN:
1815       subsystem_name = "unspecified";
1816       break;
1817     case IMAGE_SUBSYSTEM_NATIVE:
1818       subsystem_name = "NT native";
1819       break;
1820     case IMAGE_SUBSYSTEM_WINDOWS_GUI:
1821       subsystem_name = "Windows GUI";
1822       break;
1823     case IMAGE_SUBSYSTEM_WINDOWS_CUI:
1824       subsystem_name = "Windows CUI";
1825       break;
1826     case IMAGE_SUBSYSTEM_POSIX_CUI:
1827       subsystem_name = "POSIX CUI";
1828       break;
1829     case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
1830       subsystem_name = "Wince CUI";
1831       break;
1832     case IMAGE_SUBSYSTEM_EFI_APPLICATION:
1833       subsystem_name = "EFI application";
1834       break;
1835     case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
1836       subsystem_name = "EFI boot service driver";
1837       break;
1838     case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
1839       subsystem_name = "EFI runtime driver";
1840       break;
1841     }
1842
1843   fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
1844   if (subsystem_name)
1845     fprintf (file, "\t(%s)", subsystem_name);
1846   fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
1847   fprintf (file, "SizeOfStackReserve\t");
1848   fprintf_vma (file, i->SizeOfStackReserve);
1849   fprintf (file, "\nSizeOfStackCommit\t");
1850   fprintf_vma (file, i->SizeOfStackCommit);
1851   fprintf (file, "\nSizeOfHeapReserve\t");
1852   fprintf_vma (file, i->SizeOfHeapReserve);
1853   fprintf (file, "\nSizeOfHeapCommit\t");
1854   fprintf_vma (file, i->SizeOfHeapCommit);
1855   fprintf (file, "\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
1856   fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1857
1858   fprintf (file, "\nThe Data Directory\n");
1859   for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1860     {
1861       fprintf (file, "Entry %1x ", j);
1862       fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1863       fprintf (file, " %08lx ", i->DataDirectory[j].Size);
1864       fprintf (file, "%s\n", dir_names[j]);
1865     }
1866
1867   pe_print_idata (abfd, vfile);
1868   pe_print_edata (abfd, vfile);
1869   pe_print_pdata (abfd, vfile);
1870   pe_print_reloc (abfd, vfile);
1871
1872   return TRUE;
1873 }
1874
1875 /* Copy any private info we understand from the input bfd
1876    to the output bfd.  */
1877
1878 bfd_boolean
1879 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
1880 {
1881   /* One day we may try to grok other private data.  */
1882   if (ibfd->xvec->flavour != bfd_target_coff_flavour
1883       || obfd->xvec->flavour != bfd_target_coff_flavour)
1884     return TRUE;
1885
1886   pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr;
1887   pe_data (obfd)->dll = pe_data (ibfd)->dll;
1888
1889   /* For strip: if we removed .reloc, we'll make a real mess of things
1890      if we don't remove this entry as well.  */
1891   if (! pe_data (obfd)->has_reloc_section)
1892     {
1893       pe_data (obfd)->pe_opthdr.DataDirectory[5].VirtualAddress = 0;
1894       pe_data (obfd)->pe_opthdr.DataDirectory[5].Size = 0;
1895     }
1896   return TRUE;
1897 }
1898
1899 /* Copy private section data.  */
1900
1901 bfd_boolean
1902 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
1903                                        asection *isec,
1904                                        bfd *obfd,
1905                                        asection *osec)
1906 {
1907   if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
1908       || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
1909     return TRUE;
1910
1911   if (coff_section_data (ibfd, isec) != NULL
1912       && pei_section_data (ibfd, isec) != NULL)
1913     {
1914       if (coff_section_data (obfd, osec) == NULL)
1915         {
1916           bfd_size_type amt = sizeof (struct coff_section_tdata);
1917           osec->used_by_bfd = bfd_zalloc (obfd, amt);
1918           if (osec->used_by_bfd == NULL)
1919             return FALSE;
1920         }
1921
1922       if (pei_section_data (obfd, osec) == NULL)
1923         {
1924           bfd_size_type amt = sizeof (struct pei_section_tdata);
1925           coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
1926           if (coff_section_data (obfd, osec)->tdata == NULL)
1927             return FALSE;
1928         }
1929
1930       pei_section_data (obfd, osec)->virt_size =
1931         pei_section_data (ibfd, isec)->virt_size;
1932       pei_section_data (obfd, osec)->pe_flags =
1933         pei_section_data (ibfd, isec)->pe_flags;
1934     }
1935
1936   return TRUE;
1937 }
1938
1939 void
1940 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
1941 {
1942   coff_get_symbol_info (abfd, symbol, ret);
1943 }
1944
1945 /* Handle the .idata section and other things that need symbol table
1946    access.  */
1947
1948 bfd_boolean
1949 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
1950 {
1951   struct coff_link_hash_entry *h1;
1952   struct bfd_link_info *info = pfinfo->info;
1953   bfd_boolean result = TRUE;
1954
1955   /* There are a few fields that need to be filled in now while we
1956      have symbol table access.
1957
1958      The .idata subsections aren't directly available as sections, but
1959      they are in the symbol table, so get them from there.  */
1960
1961   /* The import directory.  This is the address of .idata$2, with size
1962      of .idata$2 + .idata$3.  */
1963   h1 = coff_link_hash_lookup (coff_hash_table (info),
1964                               ".idata$2", FALSE, FALSE, TRUE);
1965   if (h1 != NULL)
1966     {
1967       /* PR ld/2729: We cannot rely upon all the output sections having been
1968          created properly, so check before referencing them.  Issue a warning
1969          message for any sections tht could not be found.  */
1970       if (h1->root.u.def.section != NULL
1971           && h1->root.u.def.section->output_section != NULL)
1972         pe_data (abfd)->pe_opthdr.DataDirectory[1].VirtualAddress =
1973           (h1->root.u.def.value
1974            + h1->root.u.def.section->output_section->vma
1975            + h1->root.u.def.section->output_offset);
1976       else
1977         {
1978           _bfd_error_handler
1979             (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
1980              abfd);
1981           result = FALSE;
1982         }
1983
1984       h1 = coff_link_hash_lookup (coff_hash_table (info),
1985                                   ".idata$4", FALSE, FALSE, TRUE);
1986       if (h1 != NULL
1987           && h1->root.u.def.section != NULL
1988           && h1->root.u.def.section->output_section != NULL)
1989         pe_data (abfd)->pe_opthdr.DataDirectory[1].Size =
1990           ((h1->root.u.def.value
1991             + h1->root.u.def.section->output_section->vma
1992             + h1->root.u.def.section->output_offset)
1993            - pe_data (abfd)->pe_opthdr.DataDirectory[1].VirtualAddress);
1994       else
1995         {
1996           _bfd_error_handler
1997             (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
1998              abfd);
1999           result = FALSE;
2000         }
2001
2002       /* The import address table.  This is the size/address of
2003          .idata$5.  */
2004       h1 = coff_link_hash_lookup (coff_hash_table (info),
2005                                   ".idata$5", FALSE, FALSE, TRUE);
2006       if (h1 != NULL
2007           && h1->root.u.def.section != NULL
2008           && h1->root.u.def.section->output_section != NULL)
2009         pe_data (abfd)->pe_opthdr.DataDirectory[12].VirtualAddress =
2010           (h1->root.u.def.value
2011            + h1->root.u.def.section->output_section->vma
2012            + h1->root.u.def.section->output_offset);
2013       else
2014         {
2015           _bfd_error_handler
2016             (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
2017              abfd);
2018           result = FALSE;
2019         }
2020
2021       h1 = coff_link_hash_lookup (coff_hash_table (info),
2022                                   ".idata$6", FALSE, FALSE, TRUE);
2023       if (h1 != NULL
2024           && h1->root.u.def.section != NULL
2025           && h1->root.u.def.section->output_section != NULL)
2026         pe_data (abfd)->pe_opthdr.DataDirectory[12].Size =
2027           ((h1->root.u.def.value
2028             + h1->root.u.def.section->output_section->vma
2029             + h1->root.u.def.section->output_offset)
2030            - pe_data (abfd)->pe_opthdr.DataDirectory[12].VirtualAddress);
2031       else
2032         {
2033           _bfd_error_handler
2034             (_("%B: unable to fill in DataDictionary[12] because .idata$6 is missing"),
2035              abfd);
2036           result = FALSE;
2037         }
2038     }
2039
2040   h1 = coff_link_hash_lookup (coff_hash_table (info),
2041                               "__tls_used", FALSE, FALSE, TRUE);
2042   if (h1 != NULL)
2043     {
2044       if (h1->root.u.def.section != NULL
2045           && h1->root.u.def.section->output_section != NULL)
2046         pe_data (abfd)->pe_opthdr.DataDirectory[9].VirtualAddress =
2047           (h1->root.u.def.value
2048            + h1->root.u.def.section->output_section->vma
2049            + h1->root.u.def.section->output_offset
2050            - pe_data (abfd)->pe_opthdr.ImageBase);
2051       else
2052         {
2053           _bfd_error_handler
2054             (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
2055              abfd);
2056           result = FALSE;
2057         }
2058
2059       pe_data (abfd)->pe_opthdr.DataDirectory[9].Size = 0x18;
2060     }
2061
2062   /* If we couldn't find idata$2, we either have an excessively
2063      trivial program or are in DEEP trouble; we have to assume trivial
2064      program....  */
2065   return result;
2066 }