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         isize += SA (FA (pei_section_data (abfd, sec)->virt_size));
 678       }
 679
 680     aouthdr_in->dsize = dsize;
 681     aouthdr_in->tsize = tsize;
 682     extra->SizeOfImage = isize;
 683   }
 684
 685   extra->SizeOfHeaders = abfd->sections->filepos;
 686   H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
 687
 688 #define LINKER_VERSION 256 /* That is, 2.56 */
 689
 690   /* This piece of magic sets the "linker version" field to
 691      LINKER_VERSION.  */
 692   H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
 693             aouthdr_out->standard.vstamp);
 694
 695   PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
 696   PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
 697   PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
 698   PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
 699   PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
 700                           aouthdr_out->standard.text_start);
 701
 702 #ifndef COFF_WITH_pep
 703   /* PE32+ does not have data_start member!  */
 704   PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
 705                           aouthdr_out->standard.data_start);
 706 #endif
 707
 708   PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
 709   H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
 710   H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
 711   H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
 712             aouthdr_out->MajorOperatingSystemVersion);
 713   H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
 714             aouthdr_out->MinorOperatingSystemVersion);
 715   H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
 716   H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
 717   H_PUT_16 (abfd, extra->MajorSubsystemVersion,
 718             aouthdr_out->MajorSubsystemVersion);
 719   H_PUT_16 (abfd, extra->MinorSubsystemVersion,
 720             aouthdr_out->MinorSubsystemVersion);
 721   H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
 722   H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
 723   H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
 724   H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
 725   H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
 726   H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
 727   PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
 728                                     aouthdr_out->SizeOfStackReserve);
 729   PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
 730                                    aouthdr_out->SizeOfStackCommit);
 731   PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
 732                                    aouthdr_out->SizeOfHeapReserve);
 733   PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
 734                                   aouthdr_out->SizeOfHeapCommit);
 735   H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
 736   H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
 737             aouthdr_out->NumberOfRvaAndSizes);
 738   {
 739     int idx;
 740
 741     for (idx = 0; idx < 16; idx++)
 742       {
 743         H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
 744                   aouthdr_out->DataDirectory[idx][0]);
 745         H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
 746                   aouthdr_out->DataDirectory[idx][1]);
 747       }
 748   }
 749
 750   return AOUTSZ;
 751 }
 752
 753 unsigned int
 754 _bfd_XXi_only_swap_filehdr_out (abfd, in, out)
 755      bfd       *abfd;
 756      PTR        in;
 757      PTR        out;
 758 {
 759   int idx;
 760   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 761   struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
 762
 763   if (pe_data (abfd)->has_reloc_section)
 764     filehdr_in->f_flags &= ~F_RELFLG;
 765
 766   if (pe_data (abfd)->dll)
 767     filehdr_in->f_flags |= F_DLL;
 768
 769   filehdr_in->pe.e_magic    = DOSMAGIC;
 770   filehdr_in->pe.e_cblp     = 0x90;
 771   filehdr_in->pe.e_cp       = 0x3;
 772   filehdr_in->pe.e_crlc     = 0x0;
 773   filehdr_in->pe.e_cparhdr  = 0x4;
 774   filehdr_in->pe.e_minalloc = 0x0;
 775   filehdr_in->pe.e_maxalloc = 0xffff;
 776   filehdr_in->pe.e_ss       = 0x0;
 777   filehdr_in->pe.e_sp       = 0xb8;
 778   filehdr_in->pe.e_csum     = 0x0;
 779   filehdr_in->pe.e_ip       = 0x0;
 780   filehdr_in->pe.e_cs       = 0x0;
 781   filehdr_in->pe.e_lfarlc   = 0x40;
 782   filehdr_in->pe.e_ovno     = 0x0;
 783
 784   for (idx = 0; idx < 4; idx++)
 785     filehdr_in->pe.e_res[idx] = 0x0;
 786
 787   filehdr_in->pe.e_oemid   = 0x0;
 788   filehdr_in->pe.e_oeminfo = 0x0;
 789
 790   for (idx = 0; idx < 10; idx++)
 791     filehdr_in->pe.e_res2[idx] = 0x0;
 792
 793   filehdr_in->pe.e_lfanew = 0x80;
 794
 795   /* This next collection of data are mostly just characters.  It
 796      appears to be constant within the headers put on NT exes.  */
 797   filehdr_in->pe.dos_message[0]  = 0x0eba1f0e;
 798   filehdr_in->pe.dos_message[1]  = 0xcd09b400;
 799   filehdr_in->pe.dos_message[2]  = 0x4c01b821;
 800   filehdr_in->pe.dos_message[3]  = 0x685421cd;
 801   filehdr_in->pe.dos_message[4]  = 0x70207369;
 802   filehdr_in->pe.dos_message[5]  = 0x72676f72;
 803   filehdr_in->pe.dos_message[6]  = 0x63206d61;
 804   filehdr_in->pe.dos_message[7]  = 0x6f6e6e61;
 805   filehdr_in->pe.dos_message[8]  = 0x65622074;
 806   filehdr_in->pe.dos_message[9]  = 0x6e757220;
 807   filehdr_in->pe.dos_message[10] = 0x206e6920;
 808   filehdr_in->pe.dos_message[11] = 0x20534f44;
 809   filehdr_in->pe.dos_message[12] = 0x65646f6d;
 810   filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
 811   filehdr_in->pe.dos_message[14] = 0x24;
 812   filehdr_in->pe.dos_message[15] = 0x0;
 813   filehdr_in->pe.nt_signature = NT_SIGNATURE;
 814
 815   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
 816   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 817
 818   H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
 819   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
 820                       filehdr_out->f_symptr);
 821   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 822   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 823   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 824
 825   /* Put in extra dos header stuff.  This data remains essentially
 826      constant, it just has to be tacked on to the beginning of all exes
 827      for NT.  */
 828   H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
 829   H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
 830   H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
 831   H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
 832   H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
 833   H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
 834   H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
 835   H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
 836   H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
 837   H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
 838   H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
 839   H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
 840   H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
 841   H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
 842
 843   for (idx = 0; idx < 4; idx++)
 844     H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
 845
 846   H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
 847   H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
 848
 849   for (idx = 0; idx < 10; idx++)
 850     H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
 851
 852   H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
 853
 854   for (idx = 0; idx < 16; idx++)
 855     H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
 856               filehdr_out->dos_message[idx]);
 857
 858   /* Also put in the NT signature.  */
 859   H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
 860
 861   return FILHSZ;
 862 }
 863
 864 unsigned int
 865 _bfd_XX_only_swap_filehdr_out (abfd, in, out)
 866      bfd       *abfd;
 867      PTR        in;
 868      PTR        out;
 869 {
 870   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 871   FILHDR *filehdr_out = (FILHDR *) out;
 872
 873   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
 874   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
 875   H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
 876   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
 877   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
 878   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
 879   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
 880
 881   return FILHSZ;
 882 }
 883
 884 unsigned int
 885 _bfd_XXi_swap_scnhdr_out (abfd, in, out)
 886      bfd       *abfd;
 887      PTR        in;
 888      PTR        out;
 889 {
 890   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 891   SCNHDR *scnhdr_ext = (SCNHDR *) out;
 892   unsigned int ret = SCNHSZ;
 893   bfd_vma ps;
 894   bfd_vma ss;
 895
 896   memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
 897
 898   PUT_SCNHDR_VADDR (abfd,
 899                     ((scnhdr_int->s_vaddr
 900                       - pe_data (abfd)->pe_opthdr.ImageBase)
 901                      & 0xffffffff),
 902                     scnhdr_ext->s_vaddr);
 903
 904   /* NT wants the size data to be rounded up to the next
 905      NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
 906      sometimes).  */
 907   if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
 908     {
 909       if (bfd_pe_executable_p (abfd))
 910         {
 911           ps = scnhdr_int->s_size;
 912           ss = 0;
 913         }
 914       else
 915        {
 916          ps = 0;
 917          ss = scnhdr_int->s_size;
 918        }
 919     }
 920   else
 921     {
 922       if (bfd_pe_executable_p (abfd))
 923         ps = scnhdr_int->s_paddr;
 924       else
 925         ps = 0;
 926
 927       ss = scnhdr_int->s_size;
 928     }
 929
 930   PUT_SCNHDR_SIZE (abfd, ss,
 931                    scnhdr_ext->s_size);
 932
 933   /* s_paddr in PE is really the virtual size.  */
 934   PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
 935
 936   PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
 937                      scnhdr_ext->s_scnptr);
 938   PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
 939                      scnhdr_ext->s_relptr);
 940   PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
 941                       scnhdr_ext->s_lnnoptr);
 942
 943   /* Extra flags must be set when dealing with NT.  All sections should also
 944      have the IMAGE_SCN_MEM_READ (0x40000000) flag set.  In addition, the
 945      .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
 946      sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
 947      (this is especially important when dealing with the .idata section since
 948      the addresses for routines from .dlls must be overwritten).  If .reloc
 949      section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
 950      (0x02000000).  Also, the resource data should also be read and
 951      writable.  */
 952
 953   /* FIXME: alignment is also encoded in this field, at least on ppc (krk) */
 954   /* FIXME: even worse, I don't see how to get the original alignment field*/
 955   /*        back...                                                        */
 956
 957   {
 958     int flags = scnhdr_int->s_flags;
 959
 960     H_PUT_32 (abfd, flags, scnhdr_ext->s_flags);
 961   }
 962
 963   if (coff_data (abfd)->link_info
 964       && ! coff_data (abfd)->link_info->relocateable
 965       && ! coff_data (abfd)->link_info->shared
 966       && strcmp (scnhdr_int->s_name, ".text") == 0)
 967     {
 968       /* By inference from looking at MS output, the 32 bit field
 969          which is the combintion of the number_of_relocs and
 970          number_of_linenos is used for the line number count in
 971          executables.  A 16-bit field won't do for cc1.  The MS
 972          document says that the number of relocs is zero for
 973          executables, but the 17-th bit has been observed to be there.
 974          Overflow is not an issue: a 4G-line program will overflow a
 975          bunch of other fields long before this!  */
 976       H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
 977       H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
 978     }
 979   else
 980     {
 981       if (scnhdr_int->s_nlnno <= 0xffff)
 982         H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
 983       else
 984         {
 985           (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
 986                                  bfd_get_filename (abfd),
 987                                  scnhdr_int->s_nlnno);
 988           bfd_set_error (bfd_error_file_truncated);
 989           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
 990           ret = 0;
 991         }
 992
 993       if (scnhdr_int->s_nreloc <= 0xffff)
 994         H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
 995       else
 996         {
 997           /* PE can deal with large #s of relocs, but not here.  */
 998           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
 999           scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1000           H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1001 #if 0
1002           (*_bfd_error_handler) (_("%s: reloc overflow 1: 0x%lx > 0xffff"),
1003                                  bfd_get_filename (abfd),
1004                                  scnhdr_int->s_nreloc);
1005           bfd_set_error (bfd_error_file_truncated);
1006           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1007           ret = 0;
1008 #endif
1009         }
1010     }
1011   return ret;
1012 }
1013
1014 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1015   {
1016     N_("Export Directory [.edata (or where ever we found it)]"),
1017     N_("Import Directory [parts of .idata]"),
1018     N_("Resource Directory [.rsrc]"),
1019     N_("Exception Directory [.pdata]"),
1020     N_("Security Directory"),
1021     N_("Base Relocation Directory [.reloc]"),
1022     N_("Debug Directory"),
1023     N_("Description Directory"),
1024     N_("Special Directory"),
1025     N_("Thread Storage Directory [.tls]"),
1026     N_("Load Configuration Directory"),
1027     N_("Bound Import Directory"),
1028     N_("Import Address Table Directory"),
1029     N_("Delay Import Directory"),
1030     N_("Reserved"),
1031     N_("Reserved")
1032   };
1033
1034 #ifdef POWERPC_LE_PE
1035 /* The code for the PPC really falls in the "architecture dependent"
1036    category.  However, it's not clear that anyone will ever care, so
1037    we're ignoring the issue for now; if/when PPC matters, some of this
1038    may need to go into peicode.h, or arguments passed to enable the
1039    PPC- specific code.  */
1040 #endif
1041
1042 static bfd_boolean
1043 pe_print_idata (abfd, vfile)
1044      bfd *abfd;
1045      PTR vfile;
1046 {
1047   FILE *file = (FILE *) vfile;
1048   bfd_byte *data;
1049   asection *section;
1050   bfd_signed_vma adj;
1051
1052 #ifdef POWERPC_LE_PE
1053   asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1054 #endif
1055
1056   bfd_size_type datasize = 0;
1057   bfd_size_type dataoff;
1058   bfd_size_type i;
1059   bfd_size_type amt;
1060   int onaline = 20;
1061
1062   pe_data_type *pe = pe_data (abfd);
1063   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1064
1065   bfd_vma addr;
1066
1067   addr = extra->DataDirectory[1].VirtualAddress;
1068
1069   if (addr == 0 && extra->DataDirectory[1].Size == 0)
1070     {
1071       /* Maybe the extra header isn't there.  Look for the section.  */
1072       section = bfd_get_section_by_name (abfd, ".idata");
1073       if (section == NULL)
1074         return TRUE;
1075
1076       addr = section->vma;
1077       datasize = bfd_section_size (abfd, section);
1078       if (datasize == 0)
1079         return TRUE;
1080     }
1081   else
1082     {
1083       addr += extra->ImageBase;
1084       for (section = abfd->sections; section != NULL; section = section->next)
1085         {
1086           datasize = bfd_section_size (abfd, section);
1087           if (addr >= section->vma && addr < section->vma + datasize)
1088             break;
1089         }
1090
1091       if (section == NULL)
1092         {
1093           fprintf (file,
1094                    _("\nThere is an import table, but the section containing it could not be found\n"));
1095           return TRUE;
1096         }
1097     }
1098
1099   fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1100            section->name, (unsigned long) addr);
1101
1102   dataoff = addr - section->vma;
1103   datasize -= dataoff;
1104
1105 #ifdef POWERPC_LE_PE
1106   if (rel_section != 0 && bfd_section_size (abfd, rel_section) != 0)
1107     {
1108       /* The toc address can be found by taking the starting address,
1109          which on the PPC locates a function descriptor. The
1110          descriptor consists of the function code starting address
1111          followed by the address of the toc. The starting address we
1112          get from the bfd, and the descriptor is supposed to be in the
1113          .reldata section.  */
1114
1115       bfd_vma loadable_toc_address;
1116       bfd_vma toc_address;
1117       bfd_vma start_address;
1118       bfd_byte *data = 0;
1119       int offset;
1120
1121       amt = bfd_section_size (abfd, rel_section);
1122       data = (bfd_byte *) bfd_malloc (amt);
1123       if (data == NULL && amt != 0)
1124         return FALSE;
1125
1126       bfd_get_section_contents (abfd, rel_section, (PTR) data, (bfd_vma) 0,
1127                                 amt);
1128
1129       offset = abfd->start_address - rel_section->vma;
1130
1131       start_address = bfd_get_32 (abfd, data + offset);
1132       loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1133       toc_address = loadable_toc_address - 32768;
1134
1135       fprintf (file,
1136                _("\nFunction descriptor located at the start address: %04lx\n"),
1137                (unsigned long int) (abfd->start_address));
1138       fprintf (file,
1139                _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1140                start_address, loadable_toc_address, toc_address);
1141     }
1142   else
1143     {
1144       fprintf (file,
1145                _("\nNo reldata section! Function descriptor not decoded.\n"));
1146     }
1147 #endif
1148
1149   fprintf (file,
1150            _("\nThe Import Tables (interpreted %s section contents)\n"),
1151            section->name);
1152   fprintf (file,
1153            _("\
1154  vma:            Hint    Time      Forward  DLL       First\n\
1155                  Table   Stamp     Chain    Name      Thunk\n"));
1156
1157   amt = dataoff + datasize;
1158   data = (bfd_byte *) bfd_malloc (amt);
1159   if (data == NULL)
1160     return FALSE;
1161
1162   /* Read the whole section.  Some of the fields might be before dataoff.  */
1163   if (! bfd_get_section_contents (abfd, section, (PTR) data, (bfd_vma) 0, amt))
1164     return FALSE;
1165
1166   adj = section->vma - extra->ImageBase;
1167
1168   /* Print all image import descriptors.  */
1169   for (i = 0; i < datasize; i += onaline)
1170     {
1171       bfd_vma hint_addr;
1172       bfd_vma time_stamp;
1173       bfd_vma forward_chain;
1174       bfd_vma dll_name;
1175       bfd_vma first_thunk;
1176       int idx = 0;
1177       bfd_size_type j;
1178       char *dll;
1179
1180       /* Print (i + extra->DataDirectory[1].VirtualAddress).  */
1181       fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
1182 #if 0
1183       if (i + 20 > datasize)
1184         /* Check stuff.  */
1185         ;
1186 #endif
1187       hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1188       time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1189       forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1190       dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1191       first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1192
1193       fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1194                (unsigned long) hint_addr,
1195                (unsigned long) time_stamp,
1196                (unsigned long) forward_chain,
1197                (unsigned long) dll_name,
1198                (unsigned long) first_thunk);
1199
1200       if (hint_addr == 0 && first_thunk == 0)
1201         break;
1202
1203       dll = (char *) data + dll_name - adj;
1204       fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1205
1206       if (hint_addr != 0)
1207         {
1208           bfd_byte *ft_data;
1209           asection *ft_section;
1210           bfd_vma ft_addr;
1211           bfd_size_type ft_datasize;
1212           int ft_idx;
1213           int ft_allocated = 0;
1214
1215           fprintf (file, _("\tvma:  Hint/Ord Member-Name Bound-To\n"));
1216
1217           idx = hint_addr - adj;
1218
1219           ft_addr = first_thunk + extra->ImageBase;
1220           ft_data = data;
1221           ft_idx = first_thunk - adj;
1222           ft_allocated = 0;
1223
1224           if (first_thunk != hint_addr)
1225             {
1226               /* Find the section which contains the first thunk.  */
1227               for (ft_section = abfd->sections;
1228                    ft_section != NULL;
1229                    ft_section = ft_section->next)
1230                 {
1231                   ft_datasize = bfd_section_size (abfd, ft_section);
1232                   if (ft_addr >= ft_section->vma
1233                       && ft_addr < ft_section->vma + ft_datasize)
1234                     break;
1235                 }
1236
1237               if (ft_section == NULL)
1238                 {
1239                   fprintf (file,
1240                        _("\nThere is a first thunk, but the section containing it could not be found\n"));
1241                   continue;
1242                 }
1243
1244               /* Now check to see if this section is the same as our current
1245                  section.  If it is not then we will have to load its data in.  */
1246               if (ft_section == section)
1247                 {
1248                   ft_data = data;
1249                   ft_idx = first_thunk - adj;
1250                 }
1251               else
1252                 {
1253                   ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1254                   ft_data = (bfd_byte *) bfd_malloc (datasize);
1255                   if (ft_data == NULL)
1256                     continue;
1257
1258                   /* Read datasize bfd_bytes starting at offset ft_idx.  */
1259                   if (! bfd_get_section_contents (abfd, ft_section,
1260                                                   (PTR) ft_data,
1261                                                   (bfd_vma) ft_idx,
1262                                                   datasize))
1263                     {
1264                       free (ft_data);
1265                       continue;
1266                     }
1267
1268                   ft_idx = 0;
1269                   ft_allocated = 1;
1270                 }
1271             }
1272
1273           /* Print HintName vector entries.  */
1274           for (j = 0; j < datasize; j += 4)
1275             {
1276               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1277
1278               /* Print single IMAGE_IMPORT_BY_NAME vector.  */
1279               if (member == 0)
1280                 break;
1281
1282               if (member & 0x80000000)
1283                 fprintf (file, "\t%04lx\t %4lu  <none>",
1284                          member, member & 0x7fffffff);
1285               else
1286                 {
1287                   int ordinal;
1288                   char *member_name;
1289
1290                   ordinal = bfd_get_16 (abfd, data + member - adj);
1291                   member_name = (char *) data + member - adj + 2;
1292                   fprintf (file, "\t%04lx\t %4d  %s",
1293                            member, ordinal, member_name);
1294                 }
1295
1296               /* If the time stamp is not zero, the import address
1297                  table holds actual addresses.  */
1298               if (time_stamp != 0
1299                   && first_thunk != 0
1300                   && first_thunk != hint_addr)
1301                 fprintf (file, "\t%04lx",
1302                          (long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1303
1304               fprintf (file, "\n");
1305             }
1306
1307           if (ft_allocated)
1308             free (ft_data);
1309         }
1310
1311       fprintf (file, "\n");
1312     }
1313
1314   free (data);
1315
1316   return TRUE;
1317 }
1318
1319 static bfd_boolean
1320 pe_print_edata (abfd, vfile)
1321      bfd *abfd;
1322      PTR vfile;
1323 {
1324   FILE *file = (FILE *) vfile;
1325   bfd_byte *data;
1326   asection *section;
1327   bfd_size_type datasize = 0;
1328   bfd_size_type dataoff;
1329   bfd_size_type i;
1330   bfd_signed_vma adj;
1331   struct EDT_type
1332   {
1333     long export_flags;          /* reserved - should be zero */
1334     long time_stamp;
1335     short major_ver;
1336     short minor_ver;
1337     bfd_vma name;               /* rva - relative to image base */
1338     long base;                  /* ordinal base */
1339     unsigned long num_functions;/* Number in the export address table */
1340     unsigned long num_names;    /* Number in the name pointer table */
1341     bfd_vma eat_addr;           /* rva to the export address table */
1342     bfd_vma npt_addr;           /* rva to the Export Name Pointer Table */
1343     bfd_vma ot_addr;            /* rva to the Ordinal Table */
1344   } edt;
1345
1346   pe_data_type *pe = pe_data (abfd);
1347   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1348
1349   bfd_vma addr;
1350
1351   addr = extra->DataDirectory[0].VirtualAddress;
1352
1353   if (addr == 0 && extra->DataDirectory[0].Size == 0)
1354     {
1355       /* Maybe the extra header isn't there.  Look for the section.  */
1356       section = bfd_get_section_by_name (abfd, ".edata");
1357       if (section == NULL)
1358         return TRUE;
1359
1360       addr = section->vma;
1361       datasize = bfd_section_size (abfd, section);
1362       if (datasize == 0)
1363         return TRUE;
1364     }
1365   else
1366     {
1367       addr += extra->ImageBase;
1368
1369       for (section = abfd->sections; section != NULL; section = section->next)
1370         {
1371           datasize = bfd_section_size (abfd, section);
1372
1373           if (addr >= section->vma && addr < section->vma + datasize)
1374             break;
1375         }
1376
1377       if (section == NULL)
1378         {
1379           fprintf (file,
1380                    _("\nThere is an export table, but the section containing it could not be found\n"));
1381           return TRUE;
1382         }
1383     }
1384
1385   fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1386            section->name, (unsigned long) addr);
1387
1388   dataoff = addr - section->vma;
1389   datasize -= dataoff;
1390
1391   data = (bfd_byte *) bfd_malloc (datasize);
1392   if (data == NULL)
1393     return FALSE;
1394
1395   if (! bfd_get_section_contents (abfd, section, (PTR) data,
1396                                   (file_ptr) dataoff, datasize))
1397     return FALSE;
1398
1399   /* Go get Export Directory Table.  */
1400   edt.export_flags   = bfd_get_32 (abfd, data +  0);
1401   edt.time_stamp     = bfd_get_32 (abfd, data +  4);
1402   edt.major_ver      = bfd_get_16 (abfd, data +  8);
1403   edt.minor_ver      = bfd_get_16 (abfd, data + 10);
1404   edt.name           = bfd_get_32 (abfd, data + 12);
1405   edt.base           = bfd_get_32 (abfd, data + 16);
1406   edt.num_functions  = bfd_get_32 (abfd, data + 20);
1407   edt.num_names      = bfd_get_32 (abfd, data + 24);
1408   edt.eat_addr       = bfd_get_32 (abfd, data + 28);
1409   edt.npt_addr       = bfd_get_32 (abfd, data + 32);
1410   edt.ot_addr        = bfd_get_32 (abfd, data + 36);
1411
1412   adj = section->vma - extra->ImageBase + dataoff;
1413
1414   /* Dump the EDT first.  */
1415   fprintf (file,
1416            _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1417            section->name);
1418
1419   fprintf (file,
1420            _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1421
1422   fprintf (file,
1423            _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1424
1425   fprintf (file,
1426            _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1427
1428   fprintf (file,
1429            _("Name \t\t\t\t"));
1430   fprintf_vma (file, edt.name);
1431   fprintf (file,
1432            " %s\n", data + edt.name - adj);
1433
1434   fprintf (file,
1435            _("Ordinal Base \t\t\t%ld\n"), edt.base);
1436
1437   fprintf (file,
1438            _("Number in:\n"));
1439
1440   fprintf (file,
1441            _("\tExport Address Table \t\t%08lx\n"),
1442            edt.num_functions);
1443
1444   fprintf (file,
1445            _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1446
1447   fprintf (file,
1448            _("Table Addresses\n"));
1449
1450   fprintf (file,
1451            _("\tExport Address Table \t\t"));
1452   fprintf_vma (file, edt.eat_addr);
1453   fprintf (file, "\n");
1454
1455   fprintf (file,
1456            _("\tName Pointer Table \t\t"));
1457   fprintf_vma (file, edt.npt_addr);
1458   fprintf (file, "\n");
1459
1460   fprintf (file,
1461            _("\tOrdinal Table \t\t\t"));
1462   fprintf_vma (file, edt.ot_addr);
1463   fprintf (file, "\n");
1464
1465   /* The next table to find is the Export Address Table. It's basically
1466      a list of pointers that either locate a function in this dll, or
1467      forward the call to another dll. Something like:
1468       typedef union
1469       {
1470         long export_rva;
1471         long forwarder_rva;
1472       } export_address_table_entry;
1473   */
1474
1475   fprintf (file,
1476           _("\nExport Address Table -- Ordinal Base %ld\n"),
1477           edt.base);
1478
1479   for (i = 0; i < edt.num_functions; ++i)
1480     {
1481       bfd_vma eat_member = bfd_get_32 (abfd,
1482                                        data + edt.eat_addr + (i * 4) - adj);
1483       if (eat_member == 0)
1484         continue;
1485
1486       if (eat_member - adj <= datasize)
1487         {
1488           /* This rva is to a name (forwarding function) in our section.  */
1489           /* Should locate a function descriptor.  */
1490           fprintf (file,
1491                    "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1492                    (long) i,
1493                    (long) (i + edt.base),
1494                    (unsigned long) eat_member,
1495                    _("Forwarder RVA"),
1496                    data + eat_member - adj);
1497         }
1498       else
1499         {
1500           /* Should locate a function descriptor in the reldata section.  */
1501           fprintf (file,
1502                    "\t[%4ld] +base[%4ld] %04lx %s\n",
1503                    (long) i,
1504                    (long) (i + edt.base),
1505                    (unsigned long) eat_member,
1506                    _("Export RVA"));
1507         }
1508     }
1509
1510   /* The Export Name Pointer Table is paired with the Export Ordinal Table.  */
1511   /* Dump them in parallel for clarity.  */
1512   fprintf (file,
1513            _("\n[Ordinal/Name Pointer] Table\n"));
1514
1515   for (i = 0; i < edt.num_names; ++i)
1516     {
1517       bfd_vma name_ptr = bfd_get_32 (abfd,
1518                                     data +
1519                                     edt.npt_addr
1520                                     + (i*4) - adj);
1521
1522       char *name = (char *) data + name_ptr - adj;
1523
1524       bfd_vma ord = bfd_get_16 (abfd,
1525                                     data +
1526                                     edt.ot_addr
1527                                     + (i*2) - adj);
1528       fprintf (file,
1529               "\t[%4ld] %s\n", (long) ord, name);
1530     }
1531
1532   free (data);
1533
1534   return TRUE;
1535 }
1536
1537 /* This really is architecture dependent.  On IA-64, a .pdata entry
1538    consists of three dwords containing relative virtual addresses that
1539    specify the start and end address of the code range the entry
1540    covers and the address of the corresponding unwind info data.  */
1541
1542 static bfd_boolean
1543 pe_print_pdata (abfd, vfile)
1544      bfd *abfd;
1545      PTR vfile;
1546 {
1547 #ifdef COFF_WITH_pep
1548 # define PDATA_ROW_SIZE (3*8)
1549 #else
1550 # define PDATA_ROW_SIZE (5*4)
1551 #endif
1552   FILE *file = (FILE *) vfile;
1553   bfd_byte *data = 0;
1554   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1555   bfd_size_type datasize = 0;
1556   bfd_size_type i;
1557   bfd_size_type start, stop;
1558   int onaline = PDATA_ROW_SIZE;
1559
1560   if (section == NULL
1561       || coff_section_data (abfd, section) == NULL
1562       || pei_section_data (abfd, section) == NULL)
1563     return TRUE;
1564
1565   stop = pei_section_data (abfd, section)->virt_size;
1566   if ((stop % onaline) != 0)
1567     fprintf (file,
1568              _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1569              (long) stop, onaline);
1570
1571   fprintf (file,
1572            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1573 #ifdef COFF_WITH_pep
1574   fprintf (file,
1575            _(" vma:\t\t\tBegin Address    End Address      Unwind Info\n"));
1576 #else
1577   fprintf (file, _("\
1578  vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n\
1579      \t\tAddress  Address  Handler  Data     Address    Mask\n"));
1580 #endif
1581
1582   datasize = bfd_section_size (abfd, section);
1583   if (datasize == 0)
1584     return TRUE;
1585
1586   data = (bfd_byte *) bfd_malloc (datasize);
1587   if (data == NULL && datasize != 0)
1588     return FALSE;
1589
1590   bfd_get_section_contents (abfd, section, (PTR) data, (bfd_vma) 0,
1591                             datasize);
1592
1593   start = 0;
1594
1595   for (i = start; i < stop; i += onaline)
1596     {
1597       bfd_vma begin_addr;
1598       bfd_vma end_addr;
1599       bfd_vma eh_handler;
1600       bfd_vma eh_data;
1601       bfd_vma prolog_end_addr;
1602       int em_data;
1603
1604       if (i + PDATA_ROW_SIZE > stop)
1605         break;
1606
1607       begin_addr      = GET_PDATA_ENTRY (abfd, data + i     );
1608       end_addr        = GET_PDATA_ENTRY (abfd, data + i +  4);
1609       eh_handler      = GET_PDATA_ENTRY (abfd, data + i +  8);
1610       eh_data         = GET_PDATA_ENTRY (abfd, data + i + 12);
1611       prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1612
1613       if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1614           && eh_data == 0 && prolog_end_addr == 0)
1615         /* We are probably into the padding of the section now.  */
1616         break;
1617
1618       em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1619       eh_handler &= ~(bfd_vma) 0x3;
1620       prolog_end_addr &= ~(bfd_vma) 0x3;
1621
1622       fputc (' ', file);
1623       fprintf_vma (file, i + section->vma); fputc ('\t', file);
1624       fprintf_vma (file, begin_addr); fputc (' ', file);
1625       fprintf_vma (file, end_addr); fputc (' ', file);
1626       fprintf_vma (file, eh_handler);
1627 #ifndef COFF_WITH_pep
1628       fputc (' ', file);
1629       fprintf_vma (file, eh_data); fputc (' ', file);
1630       fprintf_vma (file, prolog_end_addr);
1631       fprintf (file, "   %x", em_data);
1632 #endif
1633
1634 #ifdef POWERPC_LE_PE
1635       if (eh_handler == 0 && eh_data != 0)
1636         {
1637           /* Special bits here, although the meaning may be a little
1638              mysterious. The only one I know for sure is 0x03.  */
1639           /* Code Significance                           */
1640           /* 0x00 None                                   */
1641           /* 0x01 Register Save Millicode                */
1642           /* 0x02 Register Restore Millicode             */
1643           /* 0x03 Glue Code Sequence                     */
1644           switch (eh_data)
1645             {
1646             case 0x01:
1647               fprintf (file, _(" Register save millicode"));
1648               break;
1649             case 0x02:
1650               fprintf (file, _(" Register restore millicode"));
1651               break;
1652             case 0x03:
1653               fprintf (file, _(" Glue code sequence"));
1654               break;
1655             default:
1656               break;
1657             }
1658         }
1659 #endif
1660       fprintf (file, "\n");
1661     }
1662
1663   free (data);
1664
1665   return TRUE;
1666 }
1667
1668 #define IMAGE_REL_BASED_HIGHADJ 4
1669 static const char * const tbl[] =
1670   {
1671     "ABSOLUTE",
1672     "HIGH",
1673     "LOW",
1674     "HIGHLOW",
1675     "HIGHADJ",
1676     "MIPS_JMPADDR",
1677     "SECTION",
1678     "REL32",
1679     "RESERVED1",
1680     "MIPS_JMPADDR16",
1681     "DIR64",
1682     "HIGH3ADJ"
1683     "UNKNOWN",   /* MUST be last */
1684   };
1685
1686 static bfd_boolean
1687 pe_print_reloc (abfd, vfile)
1688      bfd *abfd;
1689      PTR vfile;
1690 {
1691   FILE *file = (FILE *) vfile;
1692   bfd_byte *data = 0;
1693   asection *section = bfd_get_section_by_name (abfd, ".reloc");
1694   bfd_size_type datasize;
1695   bfd_size_type i;
1696   bfd_size_type start, stop;
1697
1698   if (section == NULL)
1699     return TRUE;
1700
1701   if (bfd_section_size (abfd, section) == 0)
1702     return TRUE;
1703
1704   fprintf (file,
1705            _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1706
1707   datasize = bfd_section_size (abfd, section);
1708   data = (bfd_byte *) bfd_malloc (datasize);
1709   if (data == NULL && datasize != 0)
1710     return FALSE;
1711
1712   bfd_get_section_contents (abfd, section, (PTR) data, (bfd_vma) 0,
1713                             datasize);
1714
1715   start = 0;
1716
1717   stop = bfd_section_size (abfd, section);
1718
1719   for (i = start; i < stop;)
1720     {
1721       int j;
1722       bfd_vma virtual_address;
1723       long number, size;
1724
1725       /* The .reloc section is a sequence of blocks, with a header consisting
1726          of two 32 bit quantities, followed by a number of 16 bit entries.  */
1727       virtual_address = bfd_get_32 (abfd, data+i);
1728       size = bfd_get_32 (abfd, data+i+4);
1729       number = (size - 8) / 2;
1730
1731       if (size == 0)
1732         break;
1733
1734       fprintf (file,
1735                _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1736                (unsigned long) virtual_address, size, size, number);
1737
1738       for (j = 0; j < number; ++j)
1739         {
1740           unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1741           unsigned int t = (e & 0xF000) >> 12;
1742           int off = e & 0x0FFF;
1743
1744           if (t >= sizeof (tbl) / sizeof (tbl[0]))
1745             t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1746
1747           fprintf (file,
1748                    _("\treloc %4d offset %4x [%4lx] %s"),
1749                    j, off, (long) (off + virtual_address), tbl[t]);
1750
1751           /* HIGHADJ takes an argument, - the next record *is* the
1752              low 16 bits of addend.  */
1753           if (t == IMAGE_REL_BASED_HIGHADJ)
1754             {
1755               fprintf (file, " (%4x)",
1756                        ((unsigned int)
1757                         bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1758               j++;
1759             }
1760
1761           fprintf (file, "\n");
1762         }
1763
1764       i += size;
1765     }
1766
1767   free (data);
1768
1769   return TRUE;
1770 }
1771
1772 /* Print out the program headers.  */
1773
1774 bfd_boolean
1775 _bfd_XX_print_private_bfd_data_common (abfd, vfile)
1776      bfd *abfd;
1777      PTR vfile;
1778 {
1779   FILE *file = (FILE *) vfile;
1780   int j;
1781   pe_data_type *pe = pe_data (abfd);
1782   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
1783   const char *subsystem_name = NULL;
1784
1785   /* The MS dumpbin program reportedly ands with 0xff0f before
1786      printing the characteristics field.  Not sure why.  No reason to
1787      emulate it here.  */
1788   fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
1789 #undef PF
1790 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
1791   PF (F_RELFLG, "relocations stripped");
1792   PF (F_EXEC, "executable");
1793   PF (F_LNNO, "line numbers stripped");
1794   PF (F_LSYMS, "symbols stripped");
1795   PF (0x80, "little endian");
1796   PF (F_AR32WR, "32 bit words");
1797   PF (0x200, "debugging information removed");
1798   PF (0x1000, "system file");
1799   PF (F_DLL, "DLL");
1800   PF (0x8000, "big endian");
1801 #undef PF
1802
1803   /* ctime implies '\n'.  */
1804   {
1805     time_t t = pe->coff.timestamp;
1806     fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
1807   }
1808   fprintf (file, "\nImageBase\t\t");
1809   fprintf_vma (file, i->ImageBase);
1810   fprintf (file, "\nSectionAlignment\t");
1811   fprintf_vma (file, i->SectionAlignment);
1812   fprintf (file, "\nFileAlignment\t\t");
1813   fprintf_vma (file, i->FileAlignment);
1814   fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1815   fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1816   fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
1817   fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
1818   fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1819   fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1820   fprintf (file, "Win32Version\t\t%08lx\n", i->Reserved1);
1821   fprintf (file, "SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1822   fprintf (file, "SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1823   fprintf (file, "CheckSum\t\t%08lx\n", i->CheckSum);
1824
1825   switch (i->Subsystem)
1826     {
1827     case IMAGE_SUBSYSTEM_UNKNOWN:
1828       subsystem_name = "unspecified";
1829       break;
1830     case IMAGE_SUBSYSTEM_NATIVE:
1831       subsystem_name = "NT native";
1832       break;
1833     case IMAGE_SUBSYSTEM_WINDOWS_GUI:
1834       subsystem_name = "Windows GUI";
1835       break;
1836     case IMAGE_SUBSYSTEM_WINDOWS_CUI:
1837       subsystem_name = "Windows CUI";
1838       break;
1839     case IMAGE_SUBSYSTEM_POSIX_CUI:
1840       subsystem_name = "POSIX CUI";
1841       break;
1842     case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
1843       subsystem_name = "Wince CUI";
1844       break;
1845     case IMAGE_SUBSYSTEM_EFI_APPLICATION:
1846       subsystem_name = "EFI application";
1847       break;
1848     case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
1849       subsystem_name = "EFI boot service driver";
1850       break;
1851     case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
1852       subsystem_name = "EFI runtime driver";
1853       break;
1854     }
1855
1856   fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
1857   if (subsystem_name)
1858     fprintf (file, "\t(%s)", subsystem_name);
1859   fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
1860   fprintf (file, "SizeOfStackReserve\t");
1861   fprintf_vma (file, i->SizeOfStackReserve);
1862   fprintf (file, "\nSizeOfStackCommit\t");
1863   fprintf_vma (file, i->SizeOfStackCommit);
1864   fprintf (file, "\nSizeOfHeapReserve\t");
1865   fprintf_vma (file, i->SizeOfHeapReserve);
1866   fprintf (file, "\nSizeOfHeapCommit\t");
1867   fprintf_vma (file, i->SizeOfHeapCommit);
1868   fprintf (file, "\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
1869   fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1870
1871   fprintf (file, "\nThe Data Directory\n");
1872   for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1873     {
1874       fprintf (file, "Entry %1x ", j);
1875       fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1876       fprintf (file, " %08lx ", i->DataDirectory[j].Size);
1877       fprintf (file, "%s\n", dir_names[j]);
1878     }
1879
1880   pe_print_idata (abfd, vfile);
1881   pe_print_edata (abfd, vfile);
1882   pe_print_pdata (abfd, vfile);
1883   pe_print_reloc (abfd, vfile);
1884
1885   return TRUE;
1886 }
1887
1888 /* Copy any private info we understand from the input bfd
1889    to the output bfd.  */
1890
1891 bfd_boolean
1892 _bfd_XX_bfd_copy_private_bfd_data_common (ibfd, obfd)
1893      bfd *ibfd, *obfd;
1894 {
1895   /* One day we may try to grok other private data.  */
1896   if (ibfd->xvec->flavour != bfd_target_coff_flavour
1897       || obfd->xvec->flavour != bfd_target_coff_flavour)
1898     return TRUE;
1899
1900   pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr;
1901   pe_data (obfd)->dll = pe_data (ibfd)->dll;
1902
1903   /* For strip: if we removed .reloc, we'll make a real mess of things
1904      if we don't remove this entry as well.  */
1905   if (! pe_data (obfd)->has_reloc_section)
1906     {
1907       pe_data (obfd)->pe_opthdr.DataDirectory[5].VirtualAddress = 0;
1908       pe_data (obfd)->pe_opthdr.DataDirectory[5].Size = 0;
1909     }
1910   return TRUE;
1911 }
1912
1913 /* Copy private section data.  */
1914
1915 bfd_boolean
1916 _bfd_XX_bfd_copy_private_section_data (ibfd, isec, obfd, osec)
1917      bfd *ibfd;
1918      asection *isec;
1919      bfd *obfd;
1920      asection *osec;
1921 {
1922   if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
1923       || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
1924     return TRUE;
1925
1926   if (coff_section_data (ibfd, isec) != NULL
1927       && pei_section_data (ibfd, isec) != NULL)
1928     {
1929       if (coff_section_data (obfd, osec) == NULL)
1930         {
1931           bfd_size_type amt = sizeof (struct coff_section_tdata);
1932           osec->used_by_bfd = (PTR) bfd_zalloc (obfd, amt);
1933           if (osec->used_by_bfd == NULL)
1934             return FALSE;
1935         }
1936
1937       if (pei_section_data (obfd, osec) == NULL)
1938         {
1939           bfd_size_type amt = sizeof (struct pei_section_tdata);
1940           coff_section_data (obfd, osec)->tdata = (PTR) bfd_zalloc (obfd, amt);
1941           if (coff_section_data (obfd, osec)->tdata == NULL)
1942             return FALSE;
1943         }
1944
1945       pei_section_data (obfd, osec)->virt_size =
1946         pei_section_data (ibfd, isec)->virt_size;
1947       pei_section_data (obfd, osec)->pe_flags =
1948         pei_section_data (ibfd, isec)->pe_flags;
1949     }
1950
1951   return TRUE;
1952 }
1953
1954 void
1955 _bfd_XX_get_symbol_info (abfd, symbol, ret)
1956      bfd *abfd;
1957      asymbol *symbol;
1958      symbol_info *ret;
1959 {
1960   coff_get_symbol_info (abfd, symbol, ret);
1961 #if 0 /* This code no longer appears to be necessary.
1962          ImageBase has already been added in by coff_swap_scnhdr_in.  */
1963   if (pe_data (abfd) != NULL
1964       && ((symbol->flags & BSF_DEBUGGING) == 0
1965           || (symbol->flags & BSF_DEBUGGING_RELOC) != 0)
1966       && ! bfd_is_abs_section (symbol->section))
1967     ret->value += pe_data (abfd)->pe_opthdr.ImageBase;
1968 #endif
1969 }
1970
1971 /* Handle the .idata section and other things that need symbol table
1972    access.  */
1973
1974 bfd_boolean
1975 _bfd_XXi_final_link_postscript (abfd, pfinfo)
1976      bfd *abfd;
1977      struct coff_final_link_info *pfinfo;
1978 {
1979   struct coff_link_hash_entry *h1;
1980   struct bfd_link_info *info = pfinfo->info;
1981
1982   /* There are a few fields that need to be filled in now while we
1983      have symbol table access.
1984
1985      The .idata subsections aren't directly available as sections, but
1986      they are in the symbol table, so get them from there.  */
1987
1988   /* The import directory.  This is the address of .idata$2, with size
1989      of .idata$2 + .idata$3.  */
1990   h1 = coff_link_hash_lookup (coff_hash_table (info),
1991                               ".idata$2", FALSE, FALSE, TRUE);
1992   if (h1 != NULL)
1993     {
1994       pe_data (abfd)->pe_opthdr.DataDirectory[1].VirtualAddress =
1995         (h1->root.u.def.value
1996          + h1->root.u.def.section->output_section->vma
1997          + h1->root.u.def.section->output_offset);
1998       h1 = coff_link_hash_lookup (coff_hash_table (info),
1999                                   ".idata$4", FALSE, FALSE, TRUE);
2000       pe_data (abfd)->pe_opthdr.DataDirectory[1].Size =
2001         ((h1->root.u.def.value
2002           + h1->root.u.def.section->output_section->vma
2003           + h1->root.u.def.section->output_offset)
2004          - pe_data (abfd)->pe_opthdr.DataDirectory[1].VirtualAddress);
2005
2006       /* The import address table.  This is the size/address of
2007          .idata$5.  */
2008       h1 = coff_link_hash_lookup (coff_hash_table (info),
2009                                   ".idata$5", FALSE, FALSE, TRUE);
2010       pe_data (abfd)->pe_opthdr.DataDirectory[12].VirtualAddress =
2011         (h1->root.u.def.value
2012          + h1->root.u.def.section->output_section->vma
2013          + h1->root.u.def.section->output_offset);
2014       h1 = coff_link_hash_lookup (coff_hash_table (info),
2015                                   ".idata$6", FALSE, FALSE, TRUE);
2016       pe_data (abfd)->pe_opthdr.DataDirectory[12].Size =
2017         ((h1->root.u.def.value
2018           + h1->root.u.def.section->output_section->vma
2019           + h1->root.u.def.section->output_offset)
2020          - pe_data (abfd)->pe_opthdr.DataDirectory[12].VirtualAddress);
2021     }
2022
2023   /* If we couldn't find idata$2, we either have an excessively
2024      trivial program or are in DEEP trouble; we have to assume trivial
2025      program....  */
2026   return TRUE;
2027 }