bfd/peigen.c

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