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