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