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