bfd/peicode.h

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