bfd/peicode.h

   1 /* Support for the generic parts of most COFF variants, for BFD.
   2    Copyright 1995 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                         [email protected]
  24 */
  25
  26
  27
  28 #define coff_bfd_print_private_bfd_data pe_print_private_bfd_data
  29 #define coff_mkobject pe_mkobject
  30 #define coff_mkobject_hook pe_mkobject_hook
  31
  32
  33 #ifndef GET_FCN_LNNOPTR
  34 #define GET_FCN_LNNOPTR(abfd, ext)  bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
  35 #endif
  36
  37 #ifndef GET_FCN_ENDNDX
  38 #define GET_FCN_ENDNDX(abfd, ext)  bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
  39 #endif
  40
  41 #ifndef PUT_FCN_LNNOPTR
  42 #define PUT_FCN_LNNOPTR(abfd, in, ext)  bfd_h_put_32(abfd,  in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
  43 #endif
  44 #ifndef PUT_FCN_ENDNDX
  45 #define PUT_FCN_ENDNDX(abfd, in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
  46 #endif
  47 #ifndef GET_LNSZ_LNNO
  48 #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
  49 #endif
  50 #ifndef GET_LNSZ_SIZE
  51 #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
  52 #endif
  53 #ifndef PUT_LNSZ_LNNO
  54 #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
  55 #endif
  56 #ifndef PUT_LNSZ_SIZE
  57 #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
  58 #endif
  59 #ifndef GET_SCN_SCNLEN
  60 #define GET_SCN_SCNLEN(abfd,  ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
  61 #endif
  62 #ifndef GET_SCN_NRELOC
  63 #define GET_SCN_NRELOC(abfd,  ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
  64 #endif
  65 #ifndef GET_SCN_NLINNO
  66 #define GET_SCN_NLINNO(abfd, ext)  bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
  67 #endif
  68 #ifndef PUT_SCN_SCNLEN
  69 #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
  70 #endif
  71 #ifndef PUT_SCN_NRELOC
  72 #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
  73 #endif
  74 #ifndef PUT_SCN_NLINNO
  75 #define PUT_SCN_NLINNO(abfd,in, ext)  bfd_h_put_16(abfd,in, (bfd_byte  *) ext->x_scn.x_nlinno)
  76 #endif
  77 #ifndef GET_LINENO_LNNO
  78 #define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno));
  79 #endif
  80 #ifndef PUT_LINENO_LNNO
  81 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val,  (bfd_byte *) (ext->l_lnno));
  82 #endif
  83
  84 /* The f_symptr field in the filehdr is sometimes 64 bits.  */
  85 #ifndef GET_FILEHDR_SYMPTR
  86 #define GET_FILEHDR_SYMPTR bfd_h_get_32
  87 #endif
  88 #ifndef PUT_FILEHDR_SYMPTR
  89 #define PUT_FILEHDR_SYMPTR bfd_h_put_32
  90 #endif
  91
  92 /* Some fields in the aouthdr are sometimes 64 bits.  */
  93 #ifndef GET_AOUTHDR_TSIZE
  94 #define GET_AOUTHDR_TSIZE bfd_h_get_32
  95 #endif
  96 #ifndef PUT_AOUTHDR_TSIZE
  97 #define PUT_AOUTHDR_TSIZE bfd_h_put_32
  98 #endif
  99 #ifndef GET_AOUTHDR_DSIZE
 100 #define GET_AOUTHDR_DSIZE bfd_h_get_32
 101 #endif
 102 #ifndef PUT_AOUTHDR_DSIZE
 103 #define PUT_AOUTHDR_DSIZE bfd_h_put_32
 104 #endif
 105 #ifndef GET_AOUTHDR_BSIZE
 106 #define GET_AOUTHDR_BSIZE bfd_h_get_32
 107 #endif
 108 #ifndef PUT_AOUTHDR_BSIZE
 109 #define PUT_AOUTHDR_BSIZE bfd_h_put_32
 110 #endif
 111 #ifndef GET_AOUTHDR_ENTRY
 112 #define GET_AOUTHDR_ENTRY bfd_h_get_32
 113 #endif
 114 #ifndef PUT_AOUTHDR_ENTRY
 115 #define PUT_AOUTHDR_ENTRY bfd_h_put_32
 116 #endif
 117 #ifndef GET_AOUTHDR_TEXT_START
 118 #define GET_AOUTHDR_TEXT_START bfd_h_get_32
 119 #endif
 120 #ifndef PUT_AOUTHDR_TEXT_START
 121 #define PUT_AOUTHDR_TEXT_START bfd_h_put_32
 122 #endif
 123 #ifndef GET_AOUTHDR_DATA_START
 124 #define GET_AOUTHDR_DATA_START bfd_h_get_32
 125 #endif
 126 #ifndef PUT_AOUTHDR_DATA_START
 127 #define PUT_AOUTHDR_DATA_START bfd_h_put_32
 128 #endif
 129
 130 /* Some fields in the scnhdr are sometimes 64 bits.  */
 131 #ifndef GET_SCNHDR_PADDR
 132 #define GET_SCNHDR_PADDR bfd_h_get_32
 133 #endif
 134 #ifndef PUT_SCNHDR_PADDR
 135 #define PUT_SCNHDR_PADDR bfd_h_put_32
 136 #endif
 137 #ifndef GET_SCNHDR_VADDR
 138 #define GET_SCNHDR_VADDR bfd_h_get_32
 139 #endif
 140 #ifndef PUT_SCNHDR_VADDR
 141 #define PUT_SCNHDR_VADDR bfd_h_put_32
 142 #endif
 143 #ifndef GET_SCNHDR_SIZE
 144 #define GET_SCNHDR_SIZE bfd_h_get_32
 145 #endif
 146 #ifndef PUT_SCNHDR_SIZE
 147 #define PUT_SCNHDR_SIZE bfd_h_put_32
 148 #endif
 149 #ifndef GET_SCNHDR_SCNPTR
 150 #define GET_SCNHDR_SCNPTR bfd_h_get_32
 151 #endif
 152 #ifndef PUT_SCNHDR_SCNPTR
 153 #define PUT_SCNHDR_SCNPTR bfd_h_put_32
 154 #endif
 155 #ifndef GET_SCNHDR_RELPTR
 156 #define GET_SCNHDR_RELPTR bfd_h_get_32
 157 #endif
 158 #ifndef PUT_SCNHDR_RELPTR
 159 #define PUT_SCNHDR_RELPTR bfd_h_put_32
 160 #endif
 161 #ifndef GET_SCNHDR_LNNOPTR
 162 #define GET_SCNHDR_LNNOPTR bfd_h_get_32
 163 #endif
 164 #ifndef PUT_SCNHDR_LNNOPTR
 165 #define PUT_SCNHDR_LNNOPTR bfd_h_put_32
 166 #endif
 167
 168
 169
 170 /**********************************************************************/
 171
 172 static void
 173 coff_swap_reloc_in (abfd, src, dst)
 174      bfd *abfd;
 175      PTR src;
 176      PTR dst;
 177 {
 178   RELOC *reloc_src = (RELOC *) src;
 179   struct internal_reloc *reloc_dst = (struct internal_reloc *) dst;
 180
 181   reloc_dst->r_vaddr = bfd_h_get_32(abfd, (bfd_byte *)reloc_src->r_vaddr);
 182   reloc_dst->r_symndx = bfd_h_get_signed_32(abfd, (bfd_byte *) reloc_src->r_symndx);
 183
 184   reloc_dst->r_type = bfd_h_get_16(abfd, (bfd_byte *) reloc_src->r_type);
 185
 186 #ifdef SWAP_IN_RELOC_OFFSET
 187   reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET(abfd,
 188                                              (bfd_byte *) reloc_src->r_offset);
 189 #endif
 190
 191 }
 192
 193
 194 static unsigned int
 195 coff_swap_reloc_out (abfd, src, dst)
 196      bfd       *abfd;
 197      PTR        src;
 198      PTR        dst;
 199 {
 200   struct internal_reloc *reloc_src = (struct internal_reloc *)src;
 201   struct external_reloc *reloc_dst = (struct external_reloc *)dst;
 202   bfd_h_put_32(abfd, reloc_src->r_vaddr, (bfd_byte *) reloc_dst->r_vaddr);
 203   bfd_h_put_32(abfd, reloc_src->r_symndx, (bfd_byte *) reloc_dst->r_symndx);
 204
 205   bfd_h_put_16(abfd, reloc_src->r_type, (bfd_byte *)
 206                reloc_dst->r_type);
 207
 208 #ifdef SWAP_OUT_RELOC_OFFSET
 209   SWAP_OUT_RELOC_OFFSET(abfd,
 210                         reloc_src->r_offset,
 211                         (bfd_byte *) reloc_dst->r_offset);
 212 #endif
 213 #ifdef SWAP_OUT_RELOC_EXTRA
 214   SWAP_OUT_RELOC_EXTRA(abfd,reloc_src, reloc_dst);
 215 #endif
 216   return sizeof(struct external_reloc);
 217 }
 218
 219
 220 static void
 221 coff_swap_filehdr_in (abfd, src, dst)
 222      bfd            *abfd;
 223      PTR             src;
 224      PTR             dst;
 225 {
 226   FILHDR *filehdr_src = (FILHDR *) src;
 227   struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst;
 228   filehdr_dst->f_magic = bfd_h_get_16(abfd, (bfd_byte *) filehdr_src->f_magic);
 229   filehdr_dst->f_nscns = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_nscns);
 230   filehdr_dst->f_timdat = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_timdat);
 231   filehdr_dst->f_symptr =
 232     bfd_h_get_32 (abfd, (bfd_byte *) filehdr_src->f_symptr);
 233   filehdr_dst->f_nsyms = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_nsyms);
 234   filehdr_dst->f_opthdr = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_opthdr);
 235   filehdr_dst->f_flags = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_flags);
 236 }
 237
 238 static  unsigned int
 239 coff_swap_filehdr_out (abfd, in, out)
 240      bfd       *abfd;
 241      PTR        in;
 242      PTR        out;
 243 {
 244   struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in;
 245   FILHDR *filehdr_out = (FILHDR *)out;
 246
 247   if (bfd_get_section_by_name (abfd, ".reloc"))
 248     filehdr_in->f_flags &= ~F_RELFLG;
 249
 250   if (pe_data (abfd)->dll)
 251     filehdr_in->f_flags |= F_DLL;
 252
 253   filehdr_in->pe.e_magic    = DOSMAGIC;
 254   filehdr_in->pe.e_cblp     = 0x90;
 255   filehdr_in->pe.e_cp       = 0x3;
 256   filehdr_in->pe.e_crlc     = 0x0;
 257   filehdr_in->pe.e_cparhdr  = 0x4;
 258   filehdr_in->pe.e_minalloc = 0x0;
 259   filehdr_in->pe.e_maxalloc = 0xffff;
 260   filehdr_in->pe.e_ss       = 0x0;
 261   filehdr_in->pe.e_sp       = 0xb8;
 262   filehdr_in->pe.e_csum     = 0x0;
 263   filehdr_in->pe.e_ip       = 0x0;
 264   filehdr_in->pe.e_cs       = 0x0;
 265   filehdr_in->pe.e_lfarlc   = 0x40;
 266   filehdr_in->pe.e_ovno     = 0x0;
 267   {
 268     int idx;
 269     for (idx=0; idx < 4; idx++)
 270       filehdr_in->pe.e_res[idx] = 0x0;
 271   }
 272   filehdr_in->pe.e_oemid   = 0x0;
 273   filehdr_in->pe.e_oeminfo = 0x0;
 274   {
 275     int idx;
 276     for (idx=0; idx < 10; idx++)
 277       filehdr_in->pe.e_res2[idx] = 0x0;
 278   }
 279   filehdr_in->pe.e_lfanew = 0x80;
 280
 281   /* this next collection of data are mostly just characters.  It appears
 282      to be constant within the headers put on NT exes */
 283   filehdr_in->pe.dos_message[0]  = 0x0eba1f0e;
 284   filehdr_in->pe.dos_message[1]  = 0xcd09b400;
 285   filehdr_in->pe.dos_message[2]  = 0x4c01b821;
 286   filehdr_in->pe.dos_message[3]  = 0x685421cd;
 287   filehdr_in->pe.dos_message[4]  = 0x70207369;
 288   filehdr_in->pe.dos_message[5]  = 0x72676f72;
 289   filehdr_in->pe.dos_message[6]  = 0x63206d61;
 290   filehdr_in->pe.dos_message[7]  = 0x6f6e6e61;
 291   filehdr_in->pe.dos_message[8]  = 0x65622074;
 292   filehdr_in->pe.dos_message[9]  = 0x6e757220;
 293   filehdr_in->pe.dos_message[10] = 0x206e6920;
 294   filehdr_in->pe.dos_message[11] = 0x20534f44;
 295   filehdr_in->pe.dos_message[12] = 0x65646f6d;
 296   filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
 297   filehdr_in->pe.dos_message[14] = 0x24;
 298   filehdr_in->pe.dos_message[15] = 0x0;
 299   filehdr_in->pe.nt_signature = NT_SIGNATURE;
 300
 301
 302
 303   bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
 304   bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
 305
 306   bfd_h_put_32(abfd, time (0), (bfd_byte *) filehdr_out->f_timdat);
 307   PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
 308                       (bfd_byte *) filehdr_out->f_symptr);
 309   bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
 310   bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
 311   bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
 312
 313
 314   /* put in extra dos header stuff.  This data remains essentially
 315      constant, it just has to be tacked on to the beginning of all exes
 316      for NT */
 317   bfd_h_put_16(abfd, filehdr_in->pe.e_magic, (bfd_byte *) filehdr_out->e_magic);
 318   bfd_h_put_16(abfd, filehdr_in->pe.e_cblp, (bfd_byte *) filehdr_out->e_cblp);
 319   bfd_h_put_16(abfd, filehdr_in->pe.e_cp, (bfd_byte *) filehdr_out->e_cp);
 320   bfd_h_put_16(abfd, filehdr_in->pe.e_crlc, (bfd_byte *) filehdr_out->e_crlc);
 321   bfd_h_put_16(abfd, filehdr_in->pe.e_cparhdr,
 322                (bfd_byte *) filehdr_out->e_cparhdr);
 323   bfd_h_put_16(abfd, filehdr_in->pe.e_minalloc,
 324                (bfd_byte *) filehdr_out->e_minalloc);
 325   bfd_h_put_16(abfd, filehdr_in->pe.e_maxalloc,
 326                (bfd_byte *) filehdr_out->e_maxalloc);
 327   bfd_h_put_16(abfd, filehdr_in->pe.e_ss, (bfd_byte *) filehdr_out->e_ss);
 328   bfd_h_put_16(abfd, filehdr_in->pe.e_sp, (bfd_byte *) filehdr_out->e_sp);
 329   bfd_h_put_16(abfd, filehdr_in->pe.e_csum, (bfd_byte *) filehdr_out->e_csum);
 330   bfd_h_put_16(abfd, filehdr_in->pe.e_ip, (bfd_byte *) filehdr_out->e_ip);
 331   bfd_h_put_16(abfd, filehdr_in->pe.e_cs, (bfd_byte *) filehdr_out->e_cs);
 332   bfd_h_put_16(abfd, filehdr_in->pe.e_lfarlc, (bfd_byte *) filehdr_out->e_lfarlc);
 333   bfd_h_put_16(abfd, filehdr_in->pe.e_ovno, (bfd_byte *) filehdr_out->e_ovno);
 334   {
 335     int idx;
 336     for (idx=0; idx < 4; idx++)
 337       bfd_h_put_16(abfd, filehdr_in->pe.e_res[idx],
 338                    (bfd_byte *) filehdr_out->e_res[idx]);
 339   }
 340   bfd_h_put_16(abfd, filehdr_in->pe.e_oemid, (bfd_byte *) filehdr_out->e_oemid);
 341   bfd_h_put_16(abfd, filehdr_in->pe.e_oeminfo,
 342                (bfd_byte *) filehdr_out->e_oeminfo);
 343   {
 344     int idx;
 345     for (idx=0; idx < 10; idx++)
 346       bfd_h_put_16(abfd, filehdr_in->pe.e_res2[idx],
 347                    (bfd_byte *) filehdr_out->e_res2[idx]);
 348   }
 349   bfd_h_put_32(abfd, filehdr_in->pe.e_lfanew, (bfd_byte *) filehdr_out->e_lfanew);
 350
 351   {
 352     int idx;
 353     for (idx=0; idx < 16; idx++)
 354       bfd_h_put_32(abfd, filehdr_in->pe.dos_message[idx],
 355                    (bfd_byte *) filehdr_out->dos_message[idx]);
 356   }
 357
 358   /* also put in the NT signature */
 359   bfd_h_put_32(abfd, filehdr_in->pe.nt_signature,
 360                (bfd_byte *) filehdr_out->nt_signature);
 361
 362
 363
 364
 365   return sizeof(FILHDR);
 366 }
 367
 368
 369
 370 static void
 371 coff_swap_sym_in (abfd, ext1, in1)
 372      bfd            *abfd;
 373      PTR ext1;
 374      PTR in1;
 375 {
 376   SYMENT *ext = (SYMENT *)ext1;
 377   struct internal_syment      *in = (struct internal_syment *)in1;
 378
 379   if( ext->e.e_name[0] == 0) {
 380     in->_n._n_n._n_zeroes = 0;
 381     in->_n._n_n._n_offset = bfd_h_get_32(abfd, (bfd_byte *) ext->e.e.e_offset);
 382   }
 383   else {
 384 #if SYMNMLEN != E_SYMNMLEN
 385     -> Error, we need to cope with truncating or extending SYMNMLEN!;
 386 #else
 387     memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN);
 388 #endif
 389   }
 390   in->n_value = bfd_h_get_32(abfd, (bfd_byte *) ext->e_value);
 391   in->n_scnum = bfd_h_get_16(abfd, (bfd_byte *) ext->e_scnum);
 392   if (sizeof(ext->e_type) == 2){
 393     in->n_type = bfd_h_get_16(abfd, (bfd_byte *) ext->e_type);
 394   }
 395   else {
 396     in->n_type = bfd_h_get_32(abfd, (bfd_byte *) ext->e_type);
 397   }
 398   in->n_sclass = bfd_h_get_8(abfd, ext->e_sclass);
 399   in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux);
 400
 401   /* The section symbols for the .idata$ sections have class 68, which MS
 402      documentation indicates is a section symbol.  The problem is that the
 403      value field in the symbol is simply a copy of the .idata section's flags
 404      rather than something useful.  When these symbols are encountered, change
 405      the value to 0 and the section number to 1 so that they will be handled
 406      somewhat correctly in the bfd code. */
 407   if (in->n_sclass == 0x68) {
 408     in->n_value = 0x0;
 409     in->n_scnum = 1;
 410     /* I have tried setting the class to 3 and using the following to set
 411        the section number.  This will put the address of the pointer to the
 412        string kernel32.dll at addresses 0 and 0x10 off start of idata section
 413        which is not correct */
 414     /*    if (strcmp (in->_n._n_name, ".idata$4") == 0) */
 415     /*      in->n_scnum = 3; */
 416     /*    else */
 417     /*      in->n_scnum = 2; */
 418   }
 419 }
 420
 421 static unsigned int
 422 coff_swap_sym_out (abfd, inp, extp)
 423      bfd       *abfd;
 424      PTR        inp;
 425      PTR        extp;
 426 {
 427   struct internal_syment *in = (struct internal_syment *)inp;
 428   SYMENT *ext =(SYMENT *)extp;
 429   if(in->_n._n_name[0] == 0) {
 430     bfd_h_put_32(abfd, 0, (bfd_byte *) ext->e.e.e_zeroes);
 431     bfd_h_put_32(abfd, in->_n._n_n._n_offset, (bfd_byte *)  ext->e.e.e_offset);
 432   }
 433   else {
 434 #if SYMNMLEN != E_SYMNMLEN
 435     -> Error, we need to cope with truncating or extending SYMNMLEN!;
 436 #else
 437     memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
 438 #endif
 439   }
 440   bfd_h_put_32(abfd,  in->n_value , (bfd_byte *) ext->e_value);
 441   bfd_h_put_16(abfd,  in->n_scnum , (bfd_byte *) ext->e_scnum);
 442   if (sizeof(ext->e_type) == 2)
 443     {
 444       bfd_h_put_16(abfd,  in->n_type , (bfd_byte *) ext->e_type);
 445     }
 446   else
 447     {
 448       bfd_h_put_32(abfd,  in->n_type , (bfd_byte *) ext->e_type);
 449     }
 450   bfd_h_put_8(abfd,  in->n_sclass , ext->e_sclass);
 451   bfd_h_put_8(abfd,  in->n_numaux , ext->e_numaux);
 452   return sizeof(SYMENT);
 453 }
 454
 455 static void
 456 coff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
 457      bfd            *abfd;
 458      PTR              ext1;
 459      int             type;
 460      int             class;
 461      int              indx;
 462      int              numaux;
 463      PTR              in1;
 464 {
 465   AUXENT    *ext = (AUXENT *)ext1;
 466   union internal_auxent *in = (union internal_auxent *)in1;
 467
 468   switch (class) {
 469   case C_FILE:
 470     if (ext->x_file.x_fname[0] == 0) {
 471       in->x_file.x_n.x_zeroes = 0;
 472       in->x_file.x_n.x_offset =
 473         bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
 474     } else {
 475 #if FILNMLEN != E_FILNMLEN
 476       -> Error, we need to cope with truncating or extending FILNMLEN!;
 477 #else
 478       memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
 479 #endif
 480     }
 481     return;
 482
 483
 484   case C_STAT:
 485 #ifdef C_LEAFSTAT
 486   case C_LEAFSTAT:
 487 #endif
 488   case C_HIDDEN:
 489     if (type == T_NULL) {
 490       in->x_scn.x_scnlen = GET_SCN_SCNLEN(abfd, ext);
 491       in->x_scn.x_nreloc = GET_SCN_NRELOC(abfd, ext);
 492       in->x_scn.x_nlinno = GET_SCN_NLINNO(abfd, ext);
 493       return;
 494     }
 495     break;
 496   }
 497
 498   in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx);
 499 #ifndef NO_TVNDX
 500   in->x_sym.x_tvndx = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_tvndx);
 501 #endif
 502
 503   if (class == C_BLOCK || ISFCN (type) || ISTAG (class))
 504     {
 505       in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
 506       in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
 507     }
 508   else
 509     {
 510 #if DIMNUM != E_DIMNUM
 511  #error we need to cope with truncating or extending DIMNUM
 512 #endif
 513       in->x_sym.x_fcnary.x_ary.x_dimen[0] =
 514         bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 515       in->x_sym.x_fcnary.x_ary.x_dimen[1] =
 516         bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 517       in->x_sym.x_fcnary.x_ary.x_dimen[2] =
 518         bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 519       in->x_sym.x_fcnary.x_ary.x_dimen[3] =
 520         bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 521     }
 522
 523   if (ISFCN(type)) {
 524     in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
 525   }
 526   else {
 527     in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO(abfd, ext);
 528     in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE(abfd, ext);
 529   }
 530 }
 531
 532 static unsigned int
 533 coff_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
 534      bfd   *abfd;
 535      PTR        inp;
 536      int   type;
 537      int   class;
 538      int   indx;
 539      int   numaux;
 540      PTR        extp;
 541 {
 542   union internal_auxent *in = (union internal_auxent *)inp;
 543   AUXENT *ext = (AUXENT *)extp;
 544
 545   memset((PTR)ext, 0, AUXESZ);
 546   switch (class) {
 547   case C_FILE:
 548     if (in->x_file.x_fname[0] == 0) {
 549       bfd_h_put_32(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
 550       bfd_h_put_32(abfd,
 551               in->x_file.x_n.x_offset,
 552               (bfd_byte *) ext->x_file.x_n.x_offset);
 553     }
 554     else {
 555 #if FILNMLEN != E_FILNMLEN
 556       -> Error, we need to cope with truncating or extending FILNMLEN!;
 557 #else
 558       memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
 559 #endif
 560     }
 561     return sizeof (AUXENT);
 562
 563
 564   case C_STAT:
 565 #ifdef C_LEAFSTAT
 566   case C_LEAFSTAT:
 567 #endif
 568   case C_HIDDEN:
 569     if (type == T_NULL) {
 570       PUT_SCN_SCNLEN(abfd, in->x_scn.x_scnlen, ext);
 571       PUT_SCN_NRELOC(abfd, in->x_scn.x_nreloc, ext);
 572       PUT_SCN_NLINNO(abfd, in->x_scn.x_nlinno, ext);
 573       return sizeof (AUXENT);
 574     }
 575     break;
 576   }
 577
 578   bfd_h_put_32(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
 579 #ifndef NO_TVNDX
 580   bfd_h_put_16(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);
 581 #endif
 582
 583   if (class == C_BLOCK || ISFCN (type) || ISTAG (class))
 584     {
 585       PUT_FCN_LNNOPTR(abfd,  in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
 586       PUT_FCN_ENDNDX(abfd,  in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
 587     }
 588   else
 589     {
 590 #if DIMNUM != E_DIMNUM
 591  #error we need to cope with truncating or extending DIMNUM
 592 #endif
 593       bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
 594                     (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 595       bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
 596                     (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 597       bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
 598                     (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 599       bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
 600                     (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 601     }
 602
 603   if (ISFCN (type))
 604     bfd_h_put_32 (abfd, in->x_sym.x_misc.x_fsize,
 605              (bfd_byte *)  ext->x_sym.x_misc.x_fsize);
 606   else
 607     {
 608       PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
 609       PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
 610     }
 611
 612   return sizeof(AUXENT);
 613 }
 614
 615
 616 static void
 617 coff_swap_lineno_in (abfd, ext1, in1)
 618      bfd            *abfd;
 619      PTR ext1;
 620      PTR in1;
 621 {
 622   LINENO *ext = (LINENO *)ext1;
 623   struct internal_lineno      *in = (struct internal_lineno *)in1;
 624
 625   in->l_addr.l_symndx = bfd_h_get_32(abfd, (bfd_byte *) ext->l_addr.l_symndx);
 626   in->l_lnno = GET_LINENO_LNNO(abfd, ext);
 627 }
 628
 629 static unsigned int
 630 coff_swap_lineno_out (abfd, inp, outp)
 631      bfd       *abfd;
 632      PTR        inp;
 633      PTR        outp;
 634 {
 635   struct internal_lineno *in = (struct internal_lineno *)inp;
 636   struct external_lineno *ext = (struct external_lineno *)outp;
 637   bfd_h_put_32(abfd, in->l_addr.l_symndx, (bfd_byte *)
 638           ext->l_addr.l_symndx);
 639
 640   PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
 641   return sizeof(struct external_lineno);
 642 }
 643
 644
 645
 646 static void
 647 coff_swap_aouthdr_in (abfd, aouthdr_ext1, aouthdr_int1)
 648      bfd            *abfd;
 649      PTR aouthdr_ext1;
 650      PTR aouthdr_int1;
 651 {
 652   struct internal_extra_pe_aouthdr *a;
 653   PEAOUTHDR *src = (PEAOUTHDR *)(aouthdr_ext1);
 654   AOUTHDR        *aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
 655   struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
 656
 657   aouthdr_int->magic = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->magic);
 658   aouthdr_int->vstamp = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->vstamp);
 659   aouthdr_int->tsize =
 660     GET_AOUTHDR_TSIZE (abfd, (bfd_byte *) aouthdr_ext->tsize);
 661   aouthdr_int->dsize =
 662     GET_AOUTHDR_DSIZE (abfd, (bfd_byte *) aouthdr_ext->dsize);
 663   aouthdr_int->bsize =
 664     GET_AOUTHDR_BSIZE (abfd, (bfd_byte *) aouthdr_ext->bsize);
 665   aouthdr_int->entry =
 666     GET_AOUTHDR_ENTRY (abfd, (bfd_byte *) aouthdr_ext->entry);
 667   aouthdr_int->text_start =
 668     GET_AOUTHDR_TEXT_START (abfd, (bfd_byte *) aouthdr_ext->text_start);
 669   aouthdr_int->data_start =
 670     GET_AOUTHDR_DATA_START (abfd, (bfd_byte *) aouthdr_ext->data_start);
 671
 672   a = &aouthdr_int->pe;
 673   a->ImageBase = bfd_h_get_32 (abfd, src->ImageBase);
 674   a->SectionAlignment = bfd_h_get_32 (abfd, src->SectionAlignment);
 675   a->FileAlignment = bfd_h_get_32 (abfd, src->FileAlignment);
 676   a->MajorOperatingSystemVersion =
 677     bfd_h_get_16 (abfd, src->MajorOperatingSystemVersion);
 678   a->MinorOperatingSystemVersion =
 679     bfd_h_get_16 (abfd, src->MinorOperatingSystemVersion);
 680   a->MajorImageVersion = bfd_h_get_16 (abfd, src->MajorImageVersion);
 681   a->MinorImageVersion = bfd_h_get_16 (abfd, src->MinorImageVersion);
 682   a->MajorSubsystemVersion = bfd_h_get_16 (abfd, src->MajorSubsystemVersion);
 683   a->MinorSubsystemVersion = bfd_h_get_16 (abfd, src->MinorSubsystemVersion);
 684   a->Reserved1 = bfd_h_get_32 (abfd, src->Reserved1);
 685   a->SizeOfImage = bfd_h_get_32 (abfd, src->SizeOfImage);
 686   a->SizeOfHeaders = bfd_h_get_32 (abfd, src->SizeOfHeaders);
 687   a->CheckSum = bfd_h_get_32 (abfd, src->CheckSum);
 688   a->Subsystem = bfd_h_get_16 (abfd, src->Subsystem);
 689   a->DllCharacteristics = bfd_h_get_16 (abfd, src->DllCharacteristics);
 690   a->SizeOfStackReserve = bfd_h_get_32 (abfd, src->SizeOfStackReserve);
 691   a->SizeOfStackCommit = bfd_h_get_32 (abfd, src->SizeOfStackCommit);
 692   a->SizeOfHeapReserve = bfd_h_get_32 (abfd, src->SizeOfHeapReserve);
 693   a->SizeOfHeapCommit = bfd_h_get_32 (abfd, src->SizeOfHeapCommit);
 694   a->LoaderFlags = bfd_h_get_32 (abfd, src->LoaderFlags);
 695   a->NumberOfRvaAndSizes = bfd_h_get_32 (abfd, src->NumberOfRvaAndSizes);
 696
 697   {
 698     int idx;
 699     for (idx=0; idx < 16; idx++)
 700       {
 701         a->DataDirectory[idx].VirtualAddress =
 702           bfd_h_get_32 (abfd, src->DataDirectory[idx][0]);
 703         a->DataDirectory[idx].Size =
 704           bfd_h_get_32 (abfd, src->DataDirectory[idx][1]);
 705       }
 706   }
 707 }
 708
 709
 710 static void add_data_entry (abfd, aout, idx, name, base)
 711      bfd *abfd;
 712      struct internal_extra_pe_aouthdr *aout;
 713      int idx;
 714      char *name;
 715      bfd_vma base;
 716 {
 717   asection *sec = bfd_get_section_by_name (abfd, name);
 718
 719   /* add import directory information if it exists */
 720   if (sec != NULL)
 721     {
 722       aout->DataDirectory[idx].VirtualAddress = sec->lma - base;
 723       aout->DataDirectory[idx].Size = sec->_raw_size;
 724       sec->flags |= SEC_DATA;
 725     }
 726 }
 727
 728
 729 static unsigned int
 730 coff_swap_aouthdr_out (abfd, in, out)
 731      bfd       *abfd;
 732      PTR        in;
 733      PTR        out;
 734 {
 735   struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *)in;
 736   struct internal_extra_pe_aouthdr *extra = &pe_data (abfd)->pe_opthdr;
 737   PEAOUTHDR *aouthdr_out = (PEAOUTHDR *)out;
 738
 739   bfd_vma sa = extra->SectionAlignment;
 740   bfd_vma fa = extra->FileAlignment;
 741   bfd_vma ib = extra->ImageBase ;
 742
 743   if (aouthdr_in->tsize)
 744     aouthdr_in->text_start -= ib;
 745   if (aouthdr_in->dsize)
 746     aouthdr_in->data_start -= ib;
 747   if (aouthdr_in->entry)
 748     aouthdr_in->entry -= ib;
 749
 750 #define FA(x)  (((x) + fa -1 ) & (- fa))
 751 #define SA(x)  (((x) + sa -1 ) & (- sa))
 752
 753   /* We like to have the sizes aligned */
 754
 755   aouthdr_in->bsize = FA (aouthdr_in->bsize);
 756
 757
 758   extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
 759
 760   /* first null out all data directory entries .. */
 761   memset (extra->DataDirectory, sizeof (extra->DataDirectory), 0);
 762
 763   add_data_entry (abfd, extra, 0, ".edata", ib);
 764   add_data_entry (abfd, extra, 1, ".idata", ib);
 765   add_data_entry (abfd, extra, 2, ".rsrc" ,ib);
 766   add_data_entry (abfd, extra, 5, ".reloc", ib);
 767   {
 768     asection *sec;
 769     bfd_vma dsize= 0;
 770     bfd_vma isize = SA(abfd->sections->filepos);
 771     bfd_vma tsize= 0;
 772     for (sec = abfd->sections; sec; sec = sec->next)
 773       {
 774         int rounded = FA(sec->_raw_size);
 775         if (sec->flags & SEC_DATA)
 776           dsize += rounded;
 777         if (sec->flags & SEC_CODE)
 778           tsize += rounded;
 779         isize += SA(rounded);
 780       }
 781
 782     aouthdr_in->dsize = dsize;
 783     aouthdr_in->tsize = tsize;
 784     extra->SizeOfImage = isize;
 785   }
 786
 787   extra->SizeOfHeaders = abfd->sections->filepos;
 788   bfd_h_put_16(abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->standard.magic);
 789   bfd_h_put_16(abfd, aouthdr_in->vstamp, (bfd_byte *) aouthdr_out->standard.vstamp);
 790   PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->standard.tsize);
 791   PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->standard.dsize);
 792   PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->standard.bsize);
 793   PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->standard.entry);
 794   PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
 795                           (bfd_byte *) aouthdr_out->standard.text_start);
 796   PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
 797                           (bfd_byte *) aouthdr_out->standard.data_start);
 798
 799
 800   bfd_h_put_32 (abfd, extra->ImageBase,
 801                 (bfd_byte *) aouthdr_out->ImageBase);
 802   bfd_h_put_32 (abfd, extra->SectionAlignment,
 803                 (bfd_byte *) aouthdr_out->SectionAlignment);
 804   bfd_h_put_32 (abfd, extra->FileAlignment,
 805                 (bfd_byte *) aouthdr_out->FileAlignment);
 806   bfd_h_put_16 (abfd, extra->MajorOperatingSystemVersion,
 807                 (bfd_byte *) aouthdr_out->MajorOperatingSystemVersion);
 808   bfd_h_put_16 (abfd, extra->MinorOperatingSystemVersion,
 809                 (bfd_byte *) aouthdr_out->MinorOperatingSystemVersion);
 810   bfd_h_put_16 (abfd, extra->MajorImageVersion,
 811                 (bfd_byte *) aouthdr_out->MajorImageVersion);
 812   bfd_h_put_16 (abfd, extra->MinorImageVersion,
 813                 (bfd_byte *) aouthdr_out->MinorImageVersion);
 814   bfd_h_put_16 (abfd, extra->MajorSubsystemVersion,
 815                 (bfd_byte *) aouthdr_out->MajorSubsystemVersion);
 816   bfd_h_put_16 (abfd, extra->MinorSubsystemVersion,
 817                 (bfd_byte *) aouthdr_out->MinorSubsystemVersion);
 818   bfd_h_put_32 (abfd, extra->Reserved1,
 819                 (bfd_byte *) aouthdr_out->Reserved1);
 820   bfd_h_put_32 (abfd, extra->SizeOfImage,
 821                 (bfd_byte *) aouthdr_out->SizeOfImage);
 822   bfd_h_put_32 (abfd, extra->SizeOfHeaders,
 823                 (bfd_byte *) aouthdr_out->SizeOfHeaders);
 824   bfd_h_put_32 (abfd, extra->CheckSum,
 825                 (bfd_byte *) aouthdr_out->CheckSum);
 826   bfd_h_put_16 (abfd, extra->Subsystem,
 827                 (bfd_byte *) aouthdr_out->Subsystem);
 828   bfd_h_put_16 (abfd, extra->DllCharacteristics,
 829                 (bfd_byte *) aouthdr_out->DllCharacteristics);
 830   bfd_h_put_32 (abfd, extra->SizeOfStackReserve,
 831                 (bfd_byte *) aouthdr_out->SizeOfStackReserve);
 832   bfd_h_put_32 (abfd, extra->SizeOfStackCommit,
 833                 (bfd_byte *) aouthdr_out->SizeOfStackCommit);
 834   bfd_h_put_32 (abfd, extra->SizeOfHeapReserve,
 835                 (bfd_byte *) aouthdr_out->SizeOfHeapReserve);
 836   bfd_h_put_32 (abfd, extra->SizeOfHeapCommit,
 837                 (bfd_byte *) aouthdr_out->SizeOfHeapCommit);
 838   bfd_h_put_32 (abfd, extra->LoaderFlags,
 839                 (bfd_byte *) aouthdr_out->LoaderFlags);
 840   bfd_h_put_32 (abfd, extra->NumberOfRvaAndSizes,
 841                 (bfd_byte *) aouthdr_out->NumberOfRvaAndSizes);
 842   {
 843     int idx;
 844     for (idx=0; idx < 16; idx++)
 845       {
 846         bfd_h_put_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
 847                       (bfd_byte *) aouthdr_out->DataDirectory[idx][0]);
 848         bfd_h_put_32 (abfd, extra->DataDirectory[idx].Size,
 849                       (bfd_byte *) aouthdr_out->DataDirectory[idx][1]);
 850       }
 851   }
 852
 853
 854   return sizeof(AOUTHDR);
 855 }
 856
 857 static void
 858     coff_swap_scnhdr_in (abfd, ext, in)
 859       bfd            *abfd;
 860   PTR        ext;
 861   PTR        in;
 862 {
 863   SCNHDR *scnhdr_ext = (SCNHDR *) ext;
 864   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 865
 866   memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof(scnhdr_int->s_name));
 867   scnhdr_int->s_vaddr =
 868     GET_SCNHDR_VADDR (abfd, (bfd_byte *) scnhdr_ext->s_vaddr);
 869   scnhdr_int->s_paddr =
 870     GET_SCNHDR_PADDR (abfd, (bfd_byte *) scnhdr_ext->s_paddr);
 871   scnhdr_int->s_size =
 872     GET_SCNHDR_SIZE (abfd, (bfd_byte *) scnhdr_ext->s_size);
 873
 874   scnhdr_int->s_scnptr =
 875     GET_SCNHDR_SCNPTR (abfd, (bfd_byte *) scnhdr_ext->s_scnptr);
 876   scnhdr_int->s_relptr =
 877     GET_SCNHDR_RELPTR (abfd, (bfd_byte *) scnhdr_ext->s_relptr);
 878   scnhdr_int->s_lnnoptr =
 879     GET_SCNHDR_LNNOPTR (abfd, (bfd_byte *) scnhdr_ext->s_lnnoptr);
 880   scnhdr_int->s_flags = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_flags);
 881
 882   scnhdr_int->s_nreloc = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
 883   scnhdr_int->s_nlnno = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
 884
 885   if (scnhdr_int->s_vaddr != 0)
 886     {
 887       scnhdr_int->s_vaddr += pe_data (abfd)->pe_opthdr.ImageBase;
 888     }
 889 }
 890
 891 static unsigned int
 892  coff_swap_scnhdr_out (abfd, in, out)
 893 bfd       *abfd;
 894 PTR     in;
 895 PTR     out;
 896 {
 897   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *)in;
 898   SCNHDR *scnhdr_ext = (SCNHDR *)out;
 899   unsigned int ret = sizeof (SCNHDR);
 900
 901   memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name));
 902
 903
 904   PUT_SCNHDR_VADDR (abfd,
 905                     (scnhdr_int->s_vaddr
 906                      - pe_data(abfd)->pe_opthdr.ImageBase),
 907                     (bfd_byte *) scnhdr_ext->s_vaddr);
 908
 909   /* NT wants the physical address data to be the size (s_size data) of
 910      the section */
 911   PUT_SCNHDR_PADDR (abfd, scnhdr_int->s_size,
 912                     (bfd_byte *) scnhdr_ext->s_paddr);
 913   /* NT wants the size data to be rounded up to the next NT_FILE_ALIGNMENT
 914      value except for the BSS section, its s_size should be 0 */
 915   if (strcmp (scnhdr_int->s_name, _BSS) == 0)
 916     PUT_SCNHDR_SIZE (abfd, 0, (bfd_byte *) scnhdr_ext->s_size);
 917   else
 918     {
 919       bfd_vma rounded_size;
 920       rounded_size = ((scnhdr_int->s_size + NT_FILE_ALIGNMENT - 1) /
 921                       NT_FILE_ALIGNMENT) *
 922                         NT_FILE_ALIGNMENT;
 923       PUT_SCNHDR_SIZE (abfd, rounded_size, (bfd_byte *) scnhdr_ext->s_size);
 924     }
 925
 926   PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
 927                      (bfd_byte *) scnhdr_ext->s_scnptr);
 928   PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
 929                      (bfd_byte *) scnhdr_ext->s_relptr);
 930   PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
 931                       (bfd_byte *) scnhdr_ext->s_lnnoptr);
 932
 933   /* Extra flags must be set when dealing with NT.  All sections should also
 934      have the IMAGE_SCN_MEM_READ (0x40000000) flag set.  In addition, the
 935      .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
 936      sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
 937      (this is especially important when dealing with the .idata section since
 938      the addresses for routines from .dlls must be overwritten).  If .reloc
 939      section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
 940      (0x02000000).  Also, the resource data should also be read and
 941      writable.  */
 942   {
 943     int flags = scnhdr_int->s_flags;
 944     if (strcmp (scnhdr_int->s_name, ".data")  == 0 ||
 945         strcmp (scnhdr_int->s_name, ".CRT")   == 0 ||
 946         strcmp (scnhdr_int->s_name, ".rsrc")  == 0 ||
 947         strcmp (scnhdr_int->s_name, ".bss")   == 0)
 948       flags |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
 949     else if (strcmp (scnhdr_int->s_name, ".text") == 0)
 950       flags |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE;
 951     else if (strcmp (scnhdr_int->s_name, ".reloc") == 0)
 952       flags = SEC_DATA| IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE;
 953     else if (strcmp (scnhdr_int->s_name, ".idata") == 0)
 954       flags = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | SEC_DATA;
 955     else if (strcmp (scnhdr_int->s_name, ".rdata") == 0
 956              || strcmp (scnhdr_int->s_name, ".edata") == 0)
 957       flags =  IMAGE_SCN_MEM_READ | SEC_DATA;
 958
 959     bfd_h_put_32(abfd, flags, (bfd_byte *) scnhdr_ext->s_flags);
 960   }
 961
 962   if (scnhdr_int->s_nlnno <= 0xffff)
 963     bfd_h_put_16(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
 964   else
 965     {
 966       (*_bfd_error_handler) ("%s: line number overflow: 0x%lx > 0xffff",
 967                              bfd_get_filename (abfd),
 968                              scnhdr_int->s_nlnno);
 969       bfd_set_error (bfd_error_file_truncated);
 970       bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nlnno);
 971       ret = 0;
 972     }
 973   if (scnhdr_int->s_nreloc <= 0xffff)
 974     bfd_h_put_16(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
 975   else
 976     {
 977       (*_bfd_error_handler) ("%s: reloc overflow: 0x%lx > 0xffff",
 978                              bfd_get_filename (abfd),
 979                              scnhdr_int->s_nreloc);
 980       bfd_set_error (bfd_error_file_truncated);
 981       bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc);
 982       ret = 0;
 983     }
 984   return ret;
 985 }
 986 /**********************************************************************/
 987 static boolean
 988 pe_print_private_bfd_data (abfd, vfile)
 989      bfd*abfd;
 990      void *vfile;
 991 {
 992   FILE *file = vfile;
 993   int j;
 994   pe_data_type *pe = pe_data (abfd);
 995   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
 996   fprintf (file,"ImageBase\t\t%08x\n", i->ImageBase);
 997   fprintf (file,"SectionAlignment\t%08x\n", i->SectionAlignment);
 998   fprintf (file,"FileAlignment\t\t%08x\n", i->FileAlignment);
 999   fprintf (file,"MajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1000   fprintf (file,"MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1001   fprintf (file,"MajorImageVersion\t%d\n", i->MajorImageVersion);
1002   fprintf (file,"MinorImageVersion\t%d\n", i->MinorImageVersion);
1003   fprintf (file,"MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1004   fprintf (file,"MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1005   fprintf (file,"Reserved1\t\t%08x\n", i->Reserved1);
1006   fprintf (file,"SizeOfImage\t\t%08x\n", i->SizeOfImage);
1007   fprintf (file,"SizeOfHeaders\t\t%08x\n", i->SizeOfHeaders);
1008   fprintf (file,"CheckSum\t\t%08x\n", i->CheckSum);
1009   fprintf (file,"Subsystem\t\t%08x\n", i->Subsystem);
1010   fprintf (file,"DllCharacteristics\t%08x\n", i->DllCharacteristics);
1011   fprintf (file,"SizeOfStackReserve\t%08x\n", i->SizeOfStackReserve);
1012   fprintf (file,"SizeOfStackCommit\t%08x\n", i->SizeOfStackCommit);
1013   fprintf (file,"SizeOfHeapReserve\t%08x\n", i->SizeOfHeapReserve);
1014   fprintf (file,"SizeOfHeapCommit\t%08x\n", i->SizeOfHeapCommit);
1015   fprintf (file,"LoaderFlags\t\t%08x\n", i->LoaderFlags);
1016   fprintf (file,"NumberOfRvaAndSizes\t%08x\n", i->NumberOfRvaAndSizes);
1017
1018   for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1019     {
1020       fprintf(file, "Entry %2d %08x %08x\n",
1021               j,
1022               i->DataDirectory[j].VirtualAddress,
1023               i->DataDirectory[j].Size);
1024     }
1025 }
1026
1027 static boolean
1028 pe_mkobject (abfd)
1029      bfd * abfd;
1030 {
1031   pe_data_type *pe;
1032
1033   abfd->tdata.pe_obj_data =
1034     (struct pe_tdata *) bfd_zalloc (abfd, sizeof (pe_data_type));
1035   if (abfd->tdata.pe_obj_data == 0)
1036     {
1037       bfd_set_error (bfd_error_no_memory);
1038       return false;
1039     }
1040   pe =pe_data (abfd);
1041   pe->coff.pe = 1;
1042   return true;
1043 }
1044
1045 /* Create the COFF backend specific information.  */
1046 static PTR
1047 pe_mkobject_hook (abfd, filehdr, aouthdr)
1048      bfd * abfd;
1049      PTR filehdr;
1050      PTR aouthdr;
1051 {
1052   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1053   pe_data_type *pe;
1054
1055   if (pe_mkobject (abfd) == false)
1056     return NULL;
1057
1058   pe = pe_data (abfd);
1059
1060   pe->coff.sym_filepos = internal_f->f_symptr;
1061
1062   /* These members communicate important constants about the symbol
1063      table to GDB's symbol-reading code.  These `constants'
1064      unfortunately vary among coff implementations...  */
1065   pe->coff.local_n_btmask = N_BTMASK;
1066   pe->coff.local_n_btshft = N_BTSHFT;
1067   pe->coff.local_n_tmask = N_TMASK;
1068   pe->coff.local_n_tshift = N_TSHIFT;
1069   pe->coff.local_symesz = SYMESZ;
1070   pe->coff.local_auxesz = AUXESZ;
1071   pe->coff.local_linesz = LINESZ;
1072
1073   obj_raw_syment_count (abfd) =
1074     obj_conv_table_size (abfd) =
1075       internal_f->f_nsyms;
1076
1077   pe->pe_opthdr = ((struct internal_aouthdr *)aouthdr)->pe;
1078   return (PTR) pe;
1079 }
1080
1081
1082
1083