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