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