projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
* coff-mips.c: Use MIPS_AOUT_{OZ}MAGIC rather than {OZ}MAGIC.
[binutils-gdb.git] / bfd / coff-mips.c
1 /* BFD back-end for MIPS Extended-Coff files.
2 Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
3 Original version by Per Bothner.
4 Full support added by Ian Lance Taylor, ian@cygnus.com.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21
22 #include "bfd.h"
23 #include "sysdep.h"
24 #include "libbfd.h"
25 #include "seclet.h"
26 #include "aout/ar.h"
27 #include "aout/ranlib.h"
28
29 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
30 some other stuff which we don't want and which conflicts with stuff
31 we do want. */
32 #include "libaout.h"
33 #include "aout/aout64.h"
34 #undef N_ABS
35 #undef exec_hdr
36 #undef obj_sym_filepos
37
38 #include "coff/mips.h"
39 #include "coff/internal.h"
40 #include "coff/sym.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff-ext.h"
43 #include "libcoff.h"
44 #include "libecoff.h"
45
46 /* Each canonical asymbol really looks like this. */
47
48 typedef struct ecoff_symbol_struct
49 {
50 /* The actual symbol which the rest of BFD works with */
51 asymbol symbol;
52
53 /* The fdr for this symbol. */
54 FDR *fdr;
55
56 /* true if this is a local symbol rather than an external one. */
57 boolean local;
58
59 /* A pointer to the unswapped hidden information for this symbol */
60 union
61 {
62 struct sym_ext *lnative;
63 struct ext_ext *enative;
64 }
65 native;
66 } ecoff_symbol_type;
67
68 /* We take the address of the first element of a asymbol to ensure that the
69 macro is only ever applied to an asymbol. */
70 #define ecoffsymbol(asymbol) ((ecoff_symbol_type *) (&((asymbol)->the_bfd)))
71
72 /* The page boundary used to align sections in the executable file. */
73 #define ROUND_SIZE 0x1000
74
75 /* The linker needs a section to hold small common variables while
76 linking. There is no convenient way to create it when the linker
77 needs it, so we always create one for each BFD. We then avoid
78 writing it out. */
79 #define SCOMMON ".scommon"
80
81 /* MIPS ECOFF has COFF sections, but the debugging information is
82 stored in a completely different format. This files uses the some
83 of the swapping routines from coffswap.h, and some of the generic
84 COFF routines in coffgen.c, but, unlike the real COFF targets, does
85 not use coffcode.h itself. */
86 \f
87 /* Prototypes for static functions. */
88
89 static boolean ecoff_bad_format_hook PARAMS ((bfd *abfd, PTR filehdr));
90 static asection *ecoff_make_section_hook PARAMS ((bfd *abfd, char *name));
91 static boolean ecoff_new_section_hook PARAMS ((bfd *abfd, asection *section));
92 static boolean ecoff_mkobject PARAMS ((bfd *abfd));
93 static PTR ecoff_mkobject_hook PARAMS ((bfd *abfd, PTR filehdr, PTR aouthdr));
94 static boolean ecoff_set_arch_mach_hook PARAMS ((bfd *abfd, PTR filehdr));
95 static long ecoff_sec_to_styp_flags PARAMS ((CONST char *name,
96 flagword flags));
97 static flagword ecoff_styp_to_sec_flags PARAMS ((bfd *abfd, PTR hdr));
98 static asymbol *ecoff_make_empty_symbol PARAMS ((bfd *abfd));
99 static void ecoff_set_symbol_info PARAMS ((bfd *abfd, SYMR *ecoff_sym,
100 asymbol *asym, int ext,
101 asymbol **indirect_ptr_ptr));
102 static boolean ecoff_slurp_symbol_table PARAMS ((bfd *abfd));
103 static unsigned int ecoff_get_symtab_upper_bound PARAMS ((bfd *abfd));
104 static unsigned int ecoff_get_symtab PARAMS ((bfd *abfd,
105 asymbol **alocation));
106 static void ecoff_emit_aggregate PARAMS ((bfd *abfd, char *string,
107 RNDXR *rndx, long isym,
108 CONST char *which));
109 static char *ecoff_type_to_string PARAMS ((bfd *abfd, union aux_ext *aux_ptr,
110 int indx, int bigendian));
111 static void ecoff_print_symbol PARAMS ((bfd *abfd, PTR filep,
112 asymbol *symbol,
113 bfd_print_symbol_type how));
114 static void ecoff_get_symbol_info PARAMS ((bfd *abfd,
115 asymbol *symbol,
116 symbol_info *ret));
117 static void ecoff_swap_reloc_in PARAMS ((bfd *abfd, RELOC *ext,
118 struct internal_reloc *intern));
119 static unsigned int ecoff_swap_reloc_out PARAMS ((bfd *abfd, PTR src,
120 PTR dst));
121 static bfd_reloc_status_type ecoff_generic_reloc PARAMS ((bfd *abfd,
122 arelent *reloc,
123 asymbol *symbol,
124 PTR data,
125 asection *section,
126 bfd *output_bfd));
127 static bfd_reloc_status_type ecoff_refhi_reloc PARAMS ((bfd *abfd,
128 arelent *reloc,
129 asymbol *symbol,
130 PTR data,
131 asection *section,
132 bfd *output_bfd));
133 static bfd_reloc_status_type ecoff_reflo_reloc PARAMS ((bfd *abfd,
134 arelent *reloc,
135 asymbol *symbol,
136 PTR data,
137 asection *section,
138 bfd *output_bfd));
139 static bfd_reloc_status_type ecoff_gprel_reloc PARAMS ((bfd *abfd,
140 arelent *reloc,
141 asymbol *symbol,
142 PTR data,
143 asection *section,
144 bfd *output_bfd));
145 static boolean ecoff_slurp_reloc_table PARAMS ((bfd *abfd, asection *section,
146 asymbol **symbols));
147 static unsigned int ecoff_canonicalize_reloc PARAMS ((bfd *abfd,
148 asection *section,
149 arelent **relptr,
150 asymbol **symbols));
151 static CONST struct reloc_howto_struct *ecoff_bfd_reloc_type_lookup
152 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
153 static boolean ecoff_find_nearest_line PARAMS ((bfd *abfd,
154 asection *section,
155 asymbol **symbols,
156 bfd_vma offset,
157 CONST char **filename_ptr,
158 CONST char **fnname_ptr,
159 unsigned int *retline_ptr));
160 static void ecoff_clear_output_flags PARAMS ((bfd *abfd));
161 static boolean ecoff_rel PARAMS ((bfd *output_bfd, bfd_seclet_type *seclet,
162 asection *output_section, PTR data,
163 boolean relocateable));
164 static boolean ecoff_dump_seclet PARAMS ((bfd *abfd, bfd_seclet_type *seclet,
165 asection *section, PTR data,
166 boolean relocateable));
167 static long ecoff_add_string PARAMS ((bfd *output_bfd, FDR *fdr,
168 CONST char *string, boolean external));
169 static boolean ecoff_get_debug PARAMS ((bfd *output_bfd,
170 bfd_seclet_type *seclet,
171 asection *section,
172 boolean relocateable));
173 static boolean ecoff_bfd_seclet_link PARAMS ((bfd *abfd, PTR data,
174 boolean relocateable));
175 static boolean ecoff_set_arch_mach PARAMS ((bfd *abfd,
176 enum bfd_architecture arch,
177 unsigned long machine));
178 static int ecoff_sizeof_headers PARAMS ((bfd *abfd, boolean reloc));
179 static void ecoff_compute_section_file_positions PARAMS ((bfd *abfd));
180 static boolean ecoff_set_section_contents PARAMS ((bfd *abfd,
181 asection *section,
182 PTR location,
183 file_ptr offset,
184 bfd_size_type count));
185 static boolean ecoff_write_object_contents PARAMS ((bfd *abfd));
186 static unsigned int ecoff_armap_hash PARAMS ((CONST char *s,
187 unsigned int *rehash,
188 unsigned int size,
189 unsigned int hlog));
190 static boolean ecoff_slurp_armap PARAMS ((bfd *abfd));
191 static boolean ecoff_write_armap PARAMS ((bfd *abfd, unsigned int elength,
192 struct orl *map,
193 unsigned int orl_count,
194 int stridx));
195 static bfd_target *ecoff_archive_p PARAMS ((bfd *abfd));
196 \f
197 /* Get the generic COFF swapping routines, except for the reloc,
198 symbol, and lineno ones. Give them ecoff names. */
199 #define MIPSECOFF
200 #define NO_COFF_RELOCS
201 #define NO_COFF_SYMBOLS
202 #define NO_COFF_LINENOS
203 #define coff_swap_filehdr_in ecoff_swap_filehdr_in
204 #define coff_swap_filehdr_out ecoff_swap_filehdr_out
205 #define coff_swap_aouthdr_in ecoff_swap_aouthdr_in
206 #define coff_swap_aouthdr_out ecoff_swap_aouthdr_out
207 #define coff_swap_scnhdr_in ecoff_swap_scnhdr_in
208 #define coff_swap_scnhdr_out ecoff_swap_scnhdr_out
209 #include "coffswap.h"
210 \f
211 /* How to process the various relocs types. */
212
213 static reloc_howto_type ecoff_howto_table[] =
214 {
215 /* Reloc type 0 is ignored. The reloc reading code ensures that
216 this is a reference to the .abs section, which will cause
217 bfd_perform_relocation to do nothing. */
218 HOWTO (ECOFF_R_IGNORE, /* type */
219 0, /* rightshift */
220 0, /* size (0 = byte, 1 = short, 2 = long) */
221 8, /* bitsize (obsolete) */
222 false, /* pc_relative */
223 0, /* bitpos */
224 false, /* absolute (obsolete) */
225 false, /* complain_on_overflow */
226 0, /* special_function */
227 "IGNORE", /* name */
228 false, /* partial_inplace */
229 0, /* src_mask */
230 0, /* dst_mask */
231 false), /* pcrel_offset */
232
233 /* A 16 bit reference to a symbol, normally from a data section. */
234 HOWTO (ECOFF_R_REFHALF, /* type */
235 0, /* rightshift */
236 1, /* size (0 = byte, 1 = short, 2 = long) */
237 16, /* bitsize (obsolete) */
238 false, /* pc_relative */
239 0, /* bitpos */
240 false, /* absolute (obsolete) */
241 true, /* complain_on_overflow */
242 ecoff_generic_reloc, /* special_function */
243 "REFHALF", /* name */
244 true, /* partial_inplace */
245 0xffff, /* src_mask */
246 0xffff, /* dst_mask */
247 false), /* pcrel_offset */
248
249 /* A 32 bit reference to a symbol, normally from a data section. */
250 HOWTO (ECOFF_R_REFWORD, /* type */
251 0, /* rightshift */
252 2, /* size (0 = byte, 1 = short, 2 = long) */
253 32, /* bitsize (obsolete) */
254 false, /* pc_relative */
255 0, /* bitpos */
256 false, /* absolute (obsolete) */
257 true, /* complain_on_overflow */
258 ecoff_generic_reloc, /* special_function */
259 "REFWORD", /* name */
260 true, /* partial_inplace */
261 0xffffffff, /* src_mask */
262 0xffffffff, /* dst_mask */
263 false), /* pcrel_offset */
264
265 /* A 26 bit absolute jump address. */
266 HOWTO (ECOFF_R_JMPADDR, /* type */
267 2, /* rightshift */
268 2, /* size (0 = byte, 1 = short, 2 = long) */
269 32, /* bitsize (obsolete) */
270 false, /* pc_relative */
271 0, /* bitpos */
272 false, /* absolute (obsolete) */
273 true, /* complain_on_overflow */
274 ecoff_generic_reloc, /* special_function */
275 "JMPADDR", /* name */
276 true, /* partial_inplace */
277 0x3ffffff, /* src_mask */
278 0x3ffffff, /* dst_mask */
279 false), /* pcrel_offset */
280
281 /* The high 16 bits of a symbol value. Handled by the function
282 ecoff_refhi_reloc. */
283 HOWTO (ECOFF_R_REFHI, /* type */
284 16, /* rightshift */
285 2, /* size (0 = byte, 1 = short, 2 = long) */
286 32, /* bitsize (obsolete) */
287 false, /* pc_relative */
288 0, /* bitpos */
289 false, /* absolute (obsolete) */
290 true, /* complain_on_overflow */
291 ecoff_refhi_reloc, /* special_function */
292 "REFHI", /* name */
293 true, /* partial_inplace */
294 0xffff, /* src_mask */
295 0xffff, /* dst_mask */
296 false), /* pcrel_offset */
297
298 /* The low 16 bits of a symbol value. */
299 HOWTO (ECOFF_R_REFLO, /* type */
300 0, /* rightshift */
301 2, /* size (0 = byte, 1 = short, 2 = long) */
302 32, /* bitsize (obsolete) */
303 false, /* pc_relative */
304 0, /* bitpos */
305 false, /* absolute (obsolete) */
306 true, /* complain_on_overflow */
307 ecoff_reflo_reloc, /* special_function */
308 "REFLO", /* name */
309 true, /* partial_inplace */
310 0xffff, /* src_mask */
311 0xffff, /* dst_mask */
312 false), /* pcrel_offset */
313
314 /* A reference to an offset from the gp register. Handled by the
315 function ecoff_gprel_reloc. */
316 HOWTO (ECOFF_R_GPREL, /* type */
317 0, /* rightshift */
318 2, /* size (0 = byte, 1 = short, 2 = long) */
319 32, /* bitsize (obsolete) */
320 false, /* pc_relative */
321 0, /* bitpos */
322 false, /* absolute (obsolete) */
323 true, /* complain_on_overflow */
324 ecoff_gprel_reloc, /* special_function */
325 "GPREL", /* name */
326 true, /* partial_inplace */
327 0xffff, /* src_mask */
328 0xffff, /* dst_mask */
329 false), /* pcrel_offset */
330
331 /* A reference to a literal using an offset from the gp register.
332 Handled by the function ecoff_gprel_reloc. */
333 HOWTO (ECOFF_R_LITERAL, /* type */
334 0, /* rightshift */
335 2, /* size (0 = byte, 1 = short, 2 = long) */
336 32, /* bitsize (obsolete) */
337 false, /* pc_relative */
338 0, /* bitpos */
339 false, /* absolute (obsolete) */
340 true, /* complain_on_overflow */
341 ecoff_gprel_reloc, /* special_function */
342 "LITERAL", /* name */
343 true, /* partial_inplace */
344 0xffff, /* src_mask */
345 0xffff, /* dst_mask */
346 false) /* pcrel_offset */
347 };
348
349 #define ECOFF_HOWTO_COUNT \
350 (sizeof ecoff_howto_table / sizeof ecoff_howto_table[0])
351 \f
352 /* This stuff is somewhat copied from coffcode.h. */
353
354 static asection bfd_debug_section = { "*DEBUG*" };
355
356 /* See whether the magic number matches. */
357
358 static boolean
359 ecoff_bad_format_hook (abfd, filehdr)
360 bfd *abfd;
361 PTR filehdr;
362 {
363 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
364
365 if (ECOFFBADMAG (*internal_f))
366 return false;
367
368 return true;
369 }
370
371 /* This is a hook needed by SCO COFF, but we have nothing to do. */
372
373 static asection *
374 ecoff_make_section_hook (abfd, name)
375 bfd *abfd;
376 char *name;
377 {
378 return (asection *) NULL;
379 }
380
381 /* Initialize a new section. */
382
383 static boolean
384 ecoff_new_section_hook (abfd, section)
385 bfd *abfd;
386 asection *section;
387 {
388 section->alignment_power = abfd->xvec->align_power_min;
389
390 if (strcmp (section->name, _TEXT) == 0)
391 section->flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
392 else if (strcmp (section->name, _DATA) == 0
393 || strcmp (section->name, _SDATA) == 0)
394 section->flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
395 else if (strcmp (section->name, _RDATA) == 0
396 || strcmp (section->name, _LIT8) == 0
397 || strcmp (section->name, _LIT4) == 0)
398 section->flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
399 else if (strcmp (section->name, _BSS) == 0
400 || strcmp (section->name, _SBSS) == 0)
401 section->flags |= SEC_ALLOC;
402
403 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
404 uncertain about .init on some systems and I don't know how shared
405 libraries work. */
406
407 return true;
408 }
409
410 /* Set the alignment of a section; we have nothing to do. */
411
412 #define ecoff_set_alignment_hook \
413 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
414
415 /* Create an ECOFF object. */
416
417 static boolean
418 ecoff_mkobject (abfd)
419 bfd *abfd;
420 {
421 abfd->tdata.ecoff_obj_data = ((struct ecoff_tdata *)
422 bfd_zalloc (abfd, sizeof (ecoff_data_type)));
423 if (abfd->tdata.ecoff_obj_data == NULL)
424 {
425 bfd_error = no_memory;
426 return false;
427 }
428
429 /* Always create a .scommon section for every BFD. This is a hack so
430 that the linker has something to attach scSCommon symbols to. */
431 bfd_make_section (abfd, SCOMMON);
432
433 return true;
434 }
435
436 /* Create the ECOFF backend specific information. */
437
438 static PTR
439 ecoff_mkobject_hook (abfd, filehdr, aouthdr)
440 bfd *abfd;
441 PTR filehdr;
442 PTR aouthdr;
443 {
444 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
445 struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr;
446 ecoff_data_type *ecoff;
447
448 if (ecoff_mkobject (abfd) == false)
449 return NULL;
450
451 ecoff = ecoff_data (abfd);
452 ecoff->gp_size = 8;
453 ecoff->sym_filepos = internal_f->f_symptr;
454
455 if (internal_a != (struct internal_aouthdr *) NULL)
456 {
457 int i;
458
459 ecoff->text_start = internal_a->text_start;
460 ecoff->text_end = internal_a->text_start + internal_a->tsize;
461 ecoff->gp = internal_a->gp_value;
462 ecoff->gprmask = internal_a->gprmask;
463 for (i = 0; i < 4; i++)
464 ecoff->cprmask[i] = internal_a->cprmask[i];
465 if (internal_a->magic == MIPS_AOUT_ZMAGIC)
466 abfd->flags |= D_PAGED;
467 }
468
469 return (PTR) ecoff;
470 }
471
472 /* Determine the machine architecture and type. */
473
474 static boolean
475 ecoff_set_arch_mach_hook (abfd, filehdr)
476 bfd *abfd;
477 PTR filehdr;
478 {
479 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
480 enum bfd_architecture arch;
481
482 switch (internal_f->f_magic)
483 {
484 case MIPS_MAGIC_1:
485 case MIPS_MAGIC_LITTLE:
486 case MIPS_MAGIC_BIG:
487 arch = bfd_arch_mips;
488 break;
489
490 default:
491 arch = bfd_arch_obscure;
492 break;
493 }
494
495 bfd_default_set_arch_mach (abfd, arch, (unsigned long) 0);
496
497 return true;
498 }
499
500 /* Get the section s_flags to use for a section. */
501
502 static long
503 ecoff_sec_to_styp_flags (name, flags)
504 CONST char *name;
505 flagword flags;
506 {
507 long styp;
508
509 styp = 0;
510
511 if (strcmp (name, _TEXT) == 0)
512 styp = STYP_TEXT;
513 else if (strcmp (name, _DATA) == 0)
514 styp = STYP_DATA;
515 else if (strcmp (name, _SDATA) == 0)
516 styp = STYP_SDATA;
517 else if (strcmp (name, _RDATA) == 0)
518 styp = STYP_RDATA;
519 else if (strcmp (name, _LIT8) == 0)
520 styp = STYP_LIT8;
521 else if (strcmp (name, _LIT4) == 0)
522 styp = STYP_LIT4;
523 else if (strcmp (name, _BSS) == 0)
524 styp = STYP_BSS;
525 else if (strcmp (name, _SBSS) == 0)
526 styp = STYP_SBSS;
527 else if (strcmp (name, _INIT) == 0)
528 styp = STYP_MIPS_INIT;
529 else if (flags & SEC_CODE)
530 styp = STYP_TEXT;
531 else if (flags & SEC_DATA)
532 styp = STYP_DATA;
533 else if (flags & SEC_READONLY)
534 styp = STYP_RDATA;
535 else if (flags & SEC_LOAD)
536 styp = STYP_REG;
537 else
538 styp = STYP_BSS;
539
540 if (flags & SEC_NEVER_LOAD)
541 styp |= STYP_NOLOAD;
542
543 return styp;
544 }
545
546 /* Get the BFD flags to use for a section. */
547
548 static flagword
549 ecoff_styp_to_sec_flags (abfd, hdr)
550 bfd *abfd;
551 PTR hdr;
552 {
553 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
554 long styp_flags = internal_s->s_flags;
555 flagword sec_flags=0;
556
557 if (styp_flags & STYP_NOLOAD)
558 sec_flags |= SEC_NEVER_LOAD;
559
560 /* For 386 COFF, at least, an unloadable text or data section is
561 actually a shared library section. */
562 if ((styp_flags & STYP_TEXT)
563 || (styp_flags & STYP_MIPS_INIT))
564 {
565 if (sec_flags & SEC_NEVER_LOAD)
566 sec_flags |= SEC_CODE | SEC_SHARED_LIBRARY;
567 else
568 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
569 }
570 else if ((styp_flags & STYP_DATA)
571 || (styp_flags & STYP_RDATA)
572 || (styp_flags & STYP_SDATA))
573 {
574 if (sec_flags & SEC_NEVER_LOAD)
575 sec_flags |= SEC_DATA | SEC_SHARED_LIBRARY;
576 else
577 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
578 if (styp_flags & STYP_RDATA)
579 sec_flags |= SEC_READONLY;
580 }
581 else if ((styp_flags & STYP_BSS)
582 || (styp_flags & STYP_SBSS))
583 {
584 sec_flags |= SEC_ALLOC;
585 }
586 else if (styp_flags & STYP_INFO)
587 {
588 sec_flags |= SEC_NEVER_LOAD;
589 }
590 else if ((styp_flags & STYP_LIT8)
591 || (styp_flags & STYP_LIT4))
592 {
593 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
594 }
595 else
596 {
597 sec_flags |= SEC_ALLOC | SEC_LOAD;
598 }
599
600 return sec_flags;
601 }
602 \f
603 /* Read in and swap the important symbolic information for an ECOFF
604 object file. FIXME: This is called by gdb. If there is ever
605 another ECOFF target, it should be moved into some sort of target
606 specific structure. */
607
608 boolean
609 ecoff_slurp_symbolic_info (abfd)
610 bfd *abfd;
611 {
612 struct hdr_ext external_symhdr;
613 HDRR *internal_symhdr;
614 bfd_size_type raw_base;
615 bfd_size_type raw_size;
616 PTR raw;
617 struct fdr_ext *fraw_src;
618 struct fdr_ext *fraw_end;
619 struct fdr *fdr_ptr;
620
621 /* Check whether we've already gotten it, and whether there's any to
622 get. */
623 if (ecoff_data (abfd)->raw_syments != (PTR) NULL)
624 return true;
625 if (ecoff_data (abfd)->sym_filepos == 0)
626 {
627 bfd_get_symcount (abfd) = 0;
628 return true;
629 }
630
631 /* At this point bfd_get_symcount (abfd) holds the number of symbols
632 as read from the file header, but on ECOFF this is always the
633 size of the symbolic information header. It would be cleaner to
634 handle this when we first read the file in coffgen.c. */
635 if (bfd_get_symcount (abfd) != sizeof (external_symhdr))
636 {
637 bfd_error = bad_value;
638 return false;
639 }
640
641 /* Read the symbolic information header. */
642 if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) == -1
643 || (bfd_read ((PTR) &external_symhdr, sizeof (external_symhdr), 1, abfd)
644 != sizeof (external_symhdr)))
645 {
646 bfd_error = system_call_error;
647 return false;
648 }
649 internal_symhdr = &ecoff_data (abfd)->symbolic_header;
650 ecoff_swap_hdr_in (abfd, &external_symhdr, internal_symhdr);
651
652 if (internal_symhdr->magic != magicSym)
653 {
654 bfd_error = bad_value;
655 return false;
656 }
657
658 /* Now we can get the correct number of symbols. */
659 bfd_get_symcount (abfd) = (internal_symhdr->isymMax
660 + internal_symhdr->iextMax);
661
662 /* Read all the symbolic information at once. */
663 raw_base = ecoff_data (abfd)->sym_filepos + sizeof (struct hdr_ext);
664
665 if (internal_symhdr->cbExtOffset != 0)
666 raw_size = (internal_symhdr->cbExtOffset
667 - raw_base
668 + internal_symhdr->iextMax * sizeof (struct ext_ext));
669 else
670 {
671 long cbline, issmax, issextmax;
672
673 cbline = (internal_symhdr->cbLine + 3) &~ 3;
674 issmax = (internal_symhdr->issMax + 3) &~ 3;
675 issextmax = (internal_symhdr->issExtMax + 3) &~ 3;
676 raw_size = (cbline * sizeof (unsigned char)
677 + internal_symhdr->idnMax * sizeof (struct dnr_ext)
678 + internal_symhdr->ipdMax * sizeof (struct pdr_ext)
679 + internal_symhdr->isymMax * sizeof (struct sym_ext)
680 + internal_symhdr->ioptMax * sizeof (struct opt_ext)
681 + internal_symhdr->iauxMax * sizeof (union aux_ext)
682 + issmax * sizeof (char)
683 + issextmax * sizeof (char)
684 + internal_symhdr->ifdMax * sizeof (struct fdr_ext)
685 + internal_symhdr->crfd * sizeof (struct rfd_ext)
686 + internal_symhdr->iextMax * sizeof (struct ext_ext));
687 }
688
689 if (raw_size == 0)
690 {
691 ecoff_data (abfd)->sym_filepos = 0;
692 return true;
693 }
694 raw = (PTR) bfd_alloc (abfd, raw_size);
695 if (raw == NULL)
696 {
697 bfd_error = no_memory;
698 return false;
699 }
700 if (bfd_read (raw, raw_size, 1, abfd) != raw_size)
701 {
702 bfd_error = system_call_error;
703 bfd_release (abfd, raw);
704 return false;
705 }
706
707 ecoff_data (abfd)->raw_size = raw_size;
708 ecoff_data (abfd)->raw_syments = raw;
709
710 /* Get pointers for the numeric offsets in the HDRR structure. */
711 #define FIX(off1, off2, type) \
712 if (internal_symhdr->off1 == 0) \
713 ecoff_data (abfd)->off2 = (type *) NULL; \
714 else \
715 ecoff_data (abfd)->off2 = (type *) ((char *) raw \
716 + internal_symhdr->off1 \
717 - raw_base)
718 FIX (cbLineOffset, line, unsigned char);
719 FIX (cbDnOffset, external_dnr, struct dnr_ext);
720 FIX (cbPdOffset, external_pdr, struct pdr_ext);
721 FIX (cbSymOffset, external_sym, struct sym_ext);
722 FIX (cbOptOffset, external_opt, struct opt_ext);
723 FIX (cbAuxOffset, external_aux, union aux_ext);
724 FIX (cbSsOffset, ss, char);
725 FIX (cbSsExtOffset, ssext, char);
726 FIX (cbFdOffset, external_fdr, struct fdr_ext);
727 FIX (cbRfdOffset, external_rfd, struct rfd_ext);
728 FIX (cbExtOffset, external_ext, struct ext_ext);
729 #undef FIX
730
731 /* I don't want to always swap all the data, because it will just
732 waste time and most programs will never look at it. The only
733 time the linker needs most of the debugging information swapped
734 is when linking big-endian and little-endian MIPS object files
735 together, which is not a common occurrence.
736
737 We need to look at the fdr to deal with a lot of information in
738 the symbols, so we swap them here. */
739 ecoff_data (abfd)->fdr = (struct fdr *) bfd_alloc (abfd,
740 (internal_symhdr->ifdMax *
741 sizeof (struct fdr)));
742 if (ecoff_data (abfd)->fdr == NULL)
743 {
744 bfd_error = no_memory;
745 return false;
746 }
747 fdr_ptr = ecoff_data (abfd)->fdr;
748 fraw_src = ecoff_data (abfd)->external_fdr;
749 fraw_end = fraw_src + internal_symhdr->ifdMax;
750 for (; fraw_src < fraw_end; fraw_src++, fdr_ptr++)
751 ecoff_swap_fdr_in (abfd, fraw_src, fdr_ptr);
752
753 return true;
754 }
755 \f
756 /* ECOFF symbol table routines. The ECOFF symbol table is described
757 in gcc/mips-tfile.c. */
758
759 /* ECOFF uses two common sections. One is the usual one, and the
760 other is for small objects. All the small objects are kept
761 together, and then referenced via the gp pointer, which yields
762 faster assembler code. This is what we use for the small common
763 section. */
764 static asection ecoff_scom_section;
765 static asymbol ecoff_scom_symbol;
766 static asymbol *ecoff_scom_symbol_ptr;
767
768 /* Create an empty symbol. */
769
770 static asymbol *
771 ecoff_make_empty_symbol (abfd)
772 bfd *abfd;
773 {
774 ecoff_symbol_type *new;
775
776 new = (ecoff_symbol_type *) bfd_alloc (abfd, sizeof (ecoff_symbol_type));
777 if (new == (ecoff_symbol_type *) NULL)
778 {
779 bfd_error = no_memory;
780 return (asymbol *) NULL;
781 }
782 memset (new, 0, sizeof *new);
783 new->symbol.section = (asection *) NULL;
784 new->fdr = (FDR *) NULL;
785 new->local = false;
786 new->native.lnative = (struct sym_ext *) NULL;
787 new->symbol.the_bfd = abfd;
788 return &new->symbol;
789 }
790
791 /* Set the BFD flags and section for an ECOFF symbol. */
792
793 static void
794 ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr)
795 bfd *abfd;
796 SYMR *ecoff_sym;
797 asymbol *asym;
798 int ext;
799 asymbol **indirect_ptr_ptr;
800 {
801 asym->the_bfd = abfd;
802 asym->value = ecoff_sym->value;
803 asym->section = &bfd_debug_section;
804 asym->udata = NULL;
805
806 /* An indirect symbol requires two consecutive stabs symbols. */
807 if (*indirect_ptr_ptr != (asymbol *) NULL)
808 {
809 BFD_ASSERT (MIPS_IS_STAB (ecoff_sym));
810
811 /* @@ Stuffing pointers into integers is a no-no.
812 We can usually get away with it if the integer is
813 large enough though. */
814 if (sizeof (asym) > sizeof (bfd_vma))
815 abort ();
816 (*indirect_ptr_ptr)->value = (bfd_vma) asym;
817
818 asym->flags = BSF_DEBUGGING;
819 asym->section = &bfd_und_section;
820 *indirect_ptr_ptr = NULL;
821 return;
822 }
823
824 if (MIPS_IS_STAB (ecoff_sym)
825 && (MIPS_UNMARK_STAB (ecoff_sym->index) | N_EXT) == (N_INDR | N_EXT))
826 {
827 asym->flags = BSF_DEBUGGING | BSF_INDIRECT;
828 asym->section = &bfd_ind_section;
829 /* Pass this symbol on to the next call to this function. */
830 *indirect_ptr_ptr = asym;
831 return;
832 }
833
834 /* Most symbol types are just for debugging. */
835 switch (ecoff_sym->st)
836 {
837 case stGlobal:
838 case stStatic:
839 case stLabel:
840 case stProc:
841 case stStaticProc:
842 break;
843 case stNil:
844 if (MIPS_IS_STAB (ecoff_sym))
845 {
846 asym->flags = BSF_DEBUGGING;
847 return;
848 }
849 break;
850 default:
851 asym->flags = BSF_DEBUGGING;
852 return;
853 }
854
855 if (ext)
856 asym->flags = BSF_EXPORT | BSF_GLOBAL;
857 else
858 asym->flags = BSF_LOCAL;
859 switch (ecoff_sym->sc)
860 {
861 case scNil:
862 /* Used for compiler generated labels. Leave them in the
863 debugging section, and mark them as local. If BSF_DEBUGGING
864 is set, then nm does not display them for some reason. If no
865 flags are set then the linker whines about them. */
866 asym->flags = BSF_LOCAL;
867 break;
868 case scText:
869 asym->section = bfd_make_section_old_way (abfd, ".text");
870 asym->value -= asym->section->vma;
871 break;
872 case scData:
873 asym->section = bfd_make_section_old_way (abfd, ".data");
874 asym->value -= asym->section->vma;
875 break;
876 case scBss:
877 if (ext)
878 {
879 asym->section = &bfd_com_section;
880 asym->flags = 0;
881 }
882 else
883 {
884 asym->section = bfd_make_section_old_way (abfd, ".bss");
885 asym->value -= asym->section->vma;
886 }
887 break;
888 case scRegister:
889 asym->flags = BSF_DEBUGGING;
890 break;
891 case scAbs:
892 asym->section = &bfd_abs_section;
893 break;
894 case scUndefined:
895 asym->section = &bfd_und_section;
896 asym->flags = 0;
897 asym->value = 0;
898 break;
899 case scCdbLocal:
900 case scBits:
901 case scCdbSystem:
902 case scRegImage:
903 case scInfo:
904 case scUserStruct:
905 asym->flags = BSF_DEBUGGING;
906 break;
907 case scSData:
908 asym->section = bfd_make_section_old_way (abfd, ".sdata");
909 asym->value -= asym->section->vma;
910 break;
911 case scSBss:
912 asym->section = bfd_make_section_old_way (abfd, ".sbss");
913 if (! ext)
914 asym->value -= asym->section->vma;
915 break;
916 case scRData:
917 asym->section = bfd_make_section_old_way (abfd, ".rdata");
918 asym->value -= asym->section->vma;
919 break;
920 case scVar:
921 asym->flags = BSF_DEBUGGING;
922 break;
923 case scCommon:
924 if (asym->value > ecoff_data (abfd)->gp_size)
925 {
926 asym->section = &bfd_com_section;
927 asym->flags = 0;
928 break;
929 }
930 /* Fall through. */
931 case scSCommon:
932 if (ecoff_scom_section.name == NULL)
933 {
934 /* Initialize the small common section. */
935 ecoff_scom_section.name = SCOMMON;
936 ecoff_scom_section.flags = SEC_IS_COMMON;
937 ecoff_scom_section.output_section = &ecoff_scom_section;
938 ecoff_scom_section.symbol = &ecoff_scom_symbol;
939 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
940 ecoff_scom_symbol.name = SCOMMON;
941 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
942 ecoff_scom_symbol.section = &ecoff_scom_section;
943 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
944 }
945 asym->section = &ecoff_scom_section;
946 asym->flags = 0;
947 break;
948 case scVarRegister:
949 case scVariant:
950 asym->flags = BSF_DEBUGGING;
951 break;
952 case scSUndefined:
953 asym->section = &bfd_und_section;
954 asym->flags = 0;
955 asym->value = 0;
956 break;
957 case scInit:
958 asym->section = bfd_make_section_old_way (abfd, ".init");
959 asym->value -= asym->section->vma;
960 break;
961 case scBasedVar:
962 case scXData:
963 case scPData:
964 asym->flags = BSF_DEBUGGING;
965 break;
966 case scFini:
967 asym->section = bfd_make_section_old_way (abfd, ".fini");
968 asym->value -= asym->section->vma;
969 break;
970 default:
971 break;
972 }
973
974 /* Look for special constructors symbols and make relocation entries
975 in a special construction section. These are produced by the
976 -fgnu-linker argument to g++. */
977 if (MIPS_IS_STAB (ecoff_sym))
978 {
979 switch (MIPS_UNMARK_STAB (ecoff_sym->index))
980 {
981 default:
982 break;
983
984 case N_SETA:
985 case N_SETT:
986 case N_SETD:
987 case N_SETB:
988 {
989 const char *name;
990 asection *section;
991 arelent_chain *reloc_chain;
992
993 /* Get a section with the same name as the symbol (usually
994 __CTOR_LIST__ or __DTOR_LIST__). FIXME: gcc uses the
995 name ___CTOR_LIST (three underscores). We need
996 __CTOR_LIST (two underscores), since ECOFF doesn't use
997 a leading underscore. This should be handled by gcc,
998 but instead we do it here. Actually, this should all
999 be done differently anyhow. */
1000 name = bfd_asymbol_name (asym);
1001 if (name[0] == '_' && name[1] == '_' && name[2] == '_')
1002 {
1003 ++name;
1004 asym->name = name;
1005 }
1006 section = bfd_get_section_by_name (abfd, name);
1007 if (section == (asection *) NULL)
1008 {
1009 char *copy;
1010
1011 copy = (char *) bfd_alloc (abfd, strlen (name) + 1);
1012 strcpy (copy, name);
1013 section = bfd_make_section (abfd, copy);
1014 }
1015
1016 /* Build a reloc pointing to this constructor. */
1017 reloc_chain = (arelent_chain *) bfd_alloc (abfd,
1018 sizeof (arelent_chain));
1019 reloc_chain->relent.sym_ptr_ptr =
1020 bfd_get_section (asym)->symbol_ptr_ptr;
1021 reloc_chain->relent.address = section->_raw_size;
1022 reloc_chain->relent.addend = asym->value;
1023
1024 /* FIXME: Assumes 32 bit __CTOR_LIST__ entries. */
1025 reloc_chain->relent.howto = ecoff_howto_table + ECOFF_R_REFWORD;
1026
1027 /* Set up the constructor section to hold the reloc. */
1028 section->flags = SEC_CONSTRUCTOR;
1029 ++section->reloc_count;
1030
1031 /* Constructor sections must be rounded to a four byte
1032 boundary (FIXME: assuming 32 bit entries). These are
1033 not real sections--they are handled specially by the
1034 linker--so the ECOFF 16 byte alignment restriction does
1035 not apply. */
1036 section->alignment_power = 2;
1037
1038 reloc_chain->next = section->constructor_chain;
1039 section->constructor_chain = reloc_chain;
1040
1041 /* FIXME: Assumes 32 bit __CTOR_LIST__ entries. */
1042 section->_raw_size += 4;
1043
1044 /* Mark the symbol as a constructor. */
1045 asym->flags |= BSF_CONSTRUCTOR;
1046 }
1047 break;
1048 }
1049 }
1050 }
1051
1052 /* Read an ECOFF symbol table. */
1053
1054 static boolean
1055 ecoff_slurp_symbol_table (abfd)
1056 bfd *abfd;
1057 {
1058 bfd_size_type internal_size;
1059 ecoff_symbol_type *internal;
1060 ecoff_symbol_type *internal_ptr;
1061 asymbol *indirect_ptr;
1062 struct ext_ext *eraw_src;
1063 struct ext_ext *eraw_end;
1064 FDR *fdr_ptr;
1065 FDR *fdr_end;
1066
1067 /* If we've already read in the symbol table, do nothing. */
1068 if (ecoff_data (abfd)->canonical_symbols != NULL)
1069 return true;
1070
1071 /* Get the symbolic information. */
1072 if (ecoff_slurp_symbolic_info (abfd) == false)
1073 return false;
1074 if (bfd_get_symcount (abfd) == 0)
1075 return true;
1076
1077 internal_size = bfd_get_symcount (abfd) * sizeof (ecoff_symbol_type);
1078 internal = (ecoff_symbol_type *) bfd_alloc (abfd, internal_size);
1079 if (internal == NULL)
1080 {
1081 bfd_error = no_memory;
1082 return false;
1083 }
1084
1085 internal_ptr = internal;
1086 indirect_ptr = NULL;
1087 eraw_src = ecoff_data (abfd)->external_ext;
1088 eraw_end = eraw_src + ecoff_data (abfd)->symbolic_header.iextMax;
1089 for (; eraw_src < eraw_end; eraw_src++, internal_ptr++)
1090 {
1091 EXTR internal_esym;
1092
1093 ecoff_swap_ext_in (abfd, eraw_src, &internal_esym);
1094 internal_ptr->symbol.name = (ecoff_data (abfd)->ssext
1095 + internal_esym.asym.iss);
1096 ecoff_set_symbol_info (abfd, &internal_esym.asym,
1097 &internal_ptr->symbol, 1, &indirect_ptr);
1098 internal_ptr->fdr = ecoff_data (abfd)->fdr + internal_esym.ifd;
1099 internal_ptr->local = false;
1100 internal_ptr->native.enative = eraw_src;
1101 }
1102 BFD_ASSERT (indirect_ptr == (asymbol *) NULL);
1103
1104 /* The local symbols must be accessed via the fdr's, because the
1105 string and aux indices are relative to the fdr information. */
1106 fdr_ptr = ecoff_data (abfd)->fdr;
1107 fdr_end = fdr_ptr + ecoff_data (abfd)->symbolic_header.ifdMax;
1108 for (; fdr_ptr < fdr_end; fdr_ptr++)
1109 {
1110 struct sym_ext *lraw_src;
1111 struct sym_ext *lraw_end;
1112
1113 lraw_src = ecoff_data (abfd)->external_sym + fdr_ptr->isymBase;
1114 lraw_end = lraw_src + fdr_ptr->csym;
1115 for (; lraw_src < lraw_end; lraw_src++, internal_ptr++)
1116 {
1117 SYMR internal_sym;
1118
1119 ecoff_swap_sym_in (abfd, lraw_src, &internal_sym);
1120 internal_ptr->symbol.name = (ecoff_data (abfd)->ss
1121 + fdr_ptr->issBase
1122 + internal_sym.iss);
1123 ecoff_set_symbol_info (abfd, &internal_sym,
1124 &internal_ptr->symbol, 0, &indirect_ptr);
1125 internal_ptr->fdr = fdr_ptr;
1126 internal_ptr->local = true;
1127 internal_ptr->native.lnative = lraw_src;
1128 }
1129 }
1130 BFD_ASSERT (indirect_ptr == (asymbol *) NULL);
1131
1132 ecoff_data (abfd)->canonical_symbols = internal;
1133
1134 return true;
1135 }
1136
1137 static unsigned int
1138 ecoff_get_symtab_upper_bound (abfd)
1139 bfd *abfd;
1140 {
1141 if (ecoff_slurp_symbolic_info (abfd) == false
1142 || bfd_get_symcount (abfd) == 0)
1143 return 0;
1144
1145 return (bfd_get_symcount (abfd) + 1) * (sizeof (ecoff_symbol_type *));
1146 }
1147
1148 static unsigned int
1149 ecoff_get_symtab (abfd, alocation)
1150 bfd *abfd;
1151 asymbol **alocation;
1152 {
1153 unsigned int counter = 0;
1154 ecoff_symbol_type *symbase;
1155 ecoff_symbol_type **location = (ecoff_symbol_type **) alocation;
1156
1157 if (ecoff_slurp_symbol_table (abfd) == false
1158 || bfd_get_symcount (abfd) == 0)
1159 return 0;
1160
1161 symbase = ecoff_data (abfd)->canonical_symbols;
1162 while (counter < bfd_get_symcount (abfd))
1163 {
1164 *(location++) = symbase++;
1165 counter++;
1166 }
1167 *location++ = (ecoff_symbol_type *) NULL;
1168 return bfd_get_symcount (abfd);
1169 }
1170
1171 /* Turn ECOFF type information into a printable string.
1172 ecoff_emit_aggregate and ecoff_type_to_string are from
1173 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1174
1175 /* Write aggregate information to a string. */
1176
1177 static void
1178 ecoff_emit_aggregate (abfd, string, rndx, isym, which)
1179 bfd *abfd;
1180 char *string;
1181 RNDXR *rndx;
1182 long isym;
1183 CONST char *which;
1184 {
1185 int ifd = rndx->rfd;
1186 int indx = rndx->index;
1187 int sym_base, ss_base;
1188 CONST char *name;
1189
1190 if (ifd == 0xfff)
1191 ifd = isym;
1192
1193 sym_base = ecoff_data (abfd)->fdr[ifd].isymBase;
1194 ss_base = ecoff_data (abfd)->fdr[ifd].issBase;
1195
1196 if (indx == indexNil)
1197 name = "/* no name */";
1198 else
1199 {
1200 SYMR sym;
1201
1202 indx += sym_base;
1203 ecoff_swap_sym_in (abfd,
1204 ecoff_data (abfd)->external_sym + indx,
1205 &sym);
1206 name = ecoff_data (abfd)->ss + ss_base + sym.iss;
1207 }
1208
1209 sprintf (string,
1210 "%s %s { ifd = %d, index = %d }",
1211 which, name, ifd,
1212 indx + ecoff_data (abfd)->symbolic_header.iextMax);
1213 }
1214
1215 /* Convert the type information to string format. */
1216
1217 static char *
1218 ecoff_type_to_string (abfd, aux_ptr, indx, bigendian)
1219 bfd *abfd;
1220 union aux_ext *aux_ptr;
1221 int indx;
1222 int bigendian;
1223 {
1224 AUXU u;
1225 struct qual {
1226 unsigned int type;
1227 int low_bound;
1228 int high_bound;
1229 int stride;
1230 } qualifiers[7];
1231
1232 unsigned int basic_type;
1233 int i;
1234 static char buffer1[1024];
1235 static char buffer2[1024];
1236 char *p1 = buffer1;
1237 char *p2 = buffer2;
1238 RNDXR rndx;
1239
1240 for (i = 0; i < 7; i++)
1241 {
1242 qualifiers[i].low_bound = 0;
1243 qualifiers[i].high_bound = 0;
1244 qualifiers[i].stride = 0;
1245 }
1246
1247 if (AUX_GET_ISYM (bigendian, &aux_ptr[indx]) == -1)
1248 return "-1 (no type)";
1249 ecoff_swap_tir_in (bigendian, &aux_ptr[indx++].a_ti, &u.ti);
1250
1251 basic_type = u.ti.bt;
1252 qualifiers[0].type = u.ti.tq0;
1253 qualifiers[1].type = u.ti.tq1;
1254 qualifiers[2].type = u.ti.tq2;
1255 qualifiers[3].type = u.ti.tq3;
1256 qualifiers[4].type = u.ti.tq4;
1257 qualifiers[5].type = u.ti.tq5;
1258 qualifiers[6].type = tqNil;
1259
1260 /*
1261 * Go get the basic type.
1262 */
1263 switch (basic_type)
1264 {
1265 case btNil: /* undefined */
1266 strcpy (p1, "nil");
1267 break;
1268
1269 case btAdr: /* address - integer same size as pointer */
1270 strcpy (p1, "address");
1271 break;
1272
1273 case btChar: /* character */
1274 strcpy (p1, "char");
1275 break;
1276
1277 case btUChar: /* unsigned character */
1278 strcpy (p1, "unsigned char");
1279 break;
1280
1281 case btShort: /* short */
1282 strcpy (p1, "short");
1283 break;
1284
1285 case btUShort: /* unsigned short */
1286 strcpy (p1, "unsigned short");
1287 break;
1288
1289 case btInt: /* int */
1290 strcpy (p1, "int");
1291 break;
1292
1293 case btUInt: /* unsigned int */
1294 strcpy (p1, "unsigned int");
1295 break;
1296
1297 case btLong: /* long */
1298 strcpy (p1, "long");
1299 break;
1300
1301 case btULong: /* unsigned long */
1302 strcpy (p1, "unsigned long");
1303 break;
1304
1305 case btFloat: /* float (real) */
1306 strcpy (p1, "float");
1307 break;
1308
1309 case btDouble: /* Double (real) */
1310 strcpy (p1, "double");
1311 break;
1312
1313 /* Structures add 1-2 aux words:
1314 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1315 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1316
1317 case btStruct: /* Structure (Record) */
1318 ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1319 ecoff_emit_aggregate (abfd, p1, &rndx,
1320 AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1321 "struct");
1322 indx++; /* skip aux words */
1323 break;
1324
1325 /* Unions add 1-2 aux words:
1326 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1327 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1328
1329 case btUnion: /* Union */
1330 ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1331 ecoff_emit_aggregate (abfd, p1, &rndx,
1332 AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1333 "union");
1334 indx++; /* skip aux words */
1335 break;
1336
1337 /* Enumerations add 1-2 aux words:
1338 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1339 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1340
1341 case btEnum: /* Enumeration */
1342 ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1343 ecoff_emit_aggregate (abfd, p1, &rndx,
1344 AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1345 "enum");
1346 indx++; /* skip aux words */
1347 break;
1348
1349 case btTypedef: /* defined via a typedef, isymRef points */
1350 strcpy (p1, "typedef");
1351 break;
1352
1353 case btRange: /* subrange of int */
1354 strcpy (p1, "subrange");
1355 break;
1356
1357 case btSet: /* pascal sets */
1358 strcpy (p1, "set");
1359 break;
1360
1361 case btComplex: /* fortran complex */
1362 strcpy (p1, "complex");
1363 break;
1364
1365 case btDComplex: /* fortran double complex */
1366 strcpy (p1, "double complex");
1367 break;
1368
1369 case btIndirect: /* forward or unnamed typedef */
1370 strcpy (p1, "forward/unamed typedef");
1371 break;
1372
1373 case btFixedDec: /* Fixed Decimal */
1374 strcpy (p1, "fixed decimal");
1375 break;
1376
1377 case btFloatDec: /* Float Decimal */
1378 strcpy (p1, "float decimal");
1379 break;
1380
1381 case btString: /* Varying Length Character String */
1382 strcpy (p1, "string");
1383 break;
1384
1385 case btBit: /* Aligned Bit String */
1386 strcpy (p1, "bit");
1387 break;
1388
1389 case btPicture: /* Picture */
1390 strcpy (p1, "picture");
1391 break;
1392
1393 case btVoid: /* Void */
1394 strcpy (p1, "void");
1395 break;
1396
1397 default:
1398 sprintf (p1, "Unknown basic type %d", (int) basic_type);
1399 break;
1400 }
1401
1402 p1 += strlen (buffer1);
1403
1404 /*
1405 * If this is a bitfield, get the bitsize.
1406 */
1407 if (u.ti.fBitfield)
1408 {
1409 int bitsize;
1410
1411 bitsize = AUX_GET_WIDTH (bigendian, &aux_ptr[indx++]);
1412 sprintf (p1, " : %d", bitsize);
1413 p1 += strlen (buffer1);
1414 }
1415
1416
1417 /*
1418 * Deal with any qualifiers.
1419 */
1420 if (qualifiers[0].type != tqNil)
1421 {
1422 /*
1423 * Snarf up any array bounds in the correct order. Arrays
1424 * store 5 successive words in the aux. table:
1425 * word 0 RNDXR to type of the bounds (ie, int)
1426 * word 1 Current file descriptor index
1427 * word 2 low bound
1428 * word 3 high bound (or -1 if [])
1429 * word 4 stride size in bits
1430 */
1431 for (i = 0; i < 7; i++)
1432 {
1433 if (qualifiers[i].type == tqArray)
1434 {
1435 qualifiers[i].low_bound =
1436 AUX_GET_DNLOW (bigendian, &aux_ptr[indx+2]);
1437 qualifiers[i].high_bound =
1438 AUX_GET_DNHIGH (bigendian, &aux_ptr[indx+3]);
1439 qualifiers[i].stride =
1440 AUX_GET_WIDTH (bigendian, &aux_ptr[indx+4]);
1441 indx += 5;
1442 }
1443 }
1444
1445 /*
1446 * Now print out the qualifiers.
1447 */
1448 for (i = 0; i < 6; i++)
1449 {
1450 switch (qualifiers[i].type)
1451 {
1452 case tqNil:
1453 case tqMax:
1454 break;
1455
1456 case tqPtr:
1457 strcpy (p2, "ptr to ");
1458 p2 += sizeof ("ptr to ")-1;
1459 break;
1460
1461 case tqVol:
1462 strcpy (p2, "volatile ");
1463 p2 += sizeof ("volatile ")-1;
1464 break;
1465
1466 case tqFar:
1467 strcpy (p2, "far ");
1468 p2 += sizeof ("far ")-1;
1469 break;
1470
1471 case tqProc:
1472 strcpy (p2, "func. ret. ");
1473 p2 += sizeof ("func. ret. ");
1474 break;
1475
1476 case tqArray:
1477 {
1478 int first_array = i;
1479 int j;
1480
1481 /* Print array bounds reversed (ie, in the order the C
1482 programmer writes them). C is such a fun language.... */
1483
1484 while (i < 5 && qualifiers[i+1].type == tqArray)
1485 i++;
1486
1487 for (j = i; j >= first_array; j--)
1488 {
1489 strcpy (p2, "array [");
1490 p2 += sizeof ("array [")-1;
1491 if (qualifiers[j].low_bound != 0)
1492 sprintf (p2,
1493 "%ld:%ld {%ld bits}",
1494 (long) qualifiers[j].low_bound,
1495 (long) qualifiers[j].high_bound,
1496 (long) qualifiers[j].stride);
1497
1498 else if (qualifiers[j].high_bound != -1)
1499 sprintf (p2,
1500 "%ld {%ld bits}",
1501 (long) (qualifiers[j].high_bound + 1),
1502 (long) (qualifiers[j].stride));
1503
1504 else
1505 sprintf (p2, " {%ld bits}", (long) (qualifiers[j].stride));
1506
1507 p2 += strlen (p2);
1508 strcpy (p2, "] of ");
1509 p2 += sizeof ("] of ")-1;
1510 }
1511 }
1512 break;
1513 }
1514 }
1515 }
1516
1517 strcpy (p2, buffer1);
1518 return buffer2;
1519 }
1520
1521 /* Return information about ECOFF symbol SYMBOL in RET. */
1522
1523 static void
1524 ecoff_get_symbol_info (abfd, symbol, ret)
1525 bfd *abfd; /* Ignored. */
1526 asymbol *symbol;
1527 symbol_info *ret;
1528 {
1529 bfd_symbol_info (symbol, ret);
1530 }
1531
1532 /* Print information about an ECOFF symbol. */
1533
1534 static void
1535 ecoff_print_symbol (abfd, filep, symbol, how)
1536 bfd *abfd;
1537 PTR filep;
1538 asymbol *symbol;
1539 bfd_print_symbol_type how;
1540 {
1541 FILE *file = (FILE *)filep;
1542
1543 switch (how)
1544 {
1545 case bfd_print_symbol_name:
1546 fprintf (file, "%s", symbol->name);
1547 break;
1548 case bfd_print_symbol_more:
1549 if (ecoffsymbol (symbol)->local)
1550 {
1551 SYMR ecoff_sym;
1552
1553 ecoff_swap_sym_in (abfd, ecoffsymbol (symbol)->native.lnative,
1554 &ecoff_sym);
1555 fprintf (file, "ecoff local %lx %x %x",
1556 (unsigned long) ecoff_sym.value,
1557 (unsigned) ecoff_sym.st, (unsigned) ecoff_sym.sc);
1558 }
1559 else
1560 {
1561 EXTR ecoff_ext;
1562
1563 ecoff_swap_ext_in (abfd, ecoffsymbol (symbol)->native.enative,
1564 &ecoff_ext);
1565 fprintf (file, "ecoff extern %lx %x %x",
1566 (unsigned long) ecoff_ext.asym.value,
1567 (unsigned) ecoff_ext.asym.st,
1568 (unsigned) ecoff_ext.asym.sc);
1569 }
1570 break;
1571 case bfd_print_symbol_all:
1572 /* Print out the symbols in a reasonable way */
1573 {
1574 char type;
1575 int pos;
1576 EXTR ecoff_ext;
1577 char jmptbl;
1578 char cobol_main;
1579 char weakext;
1580
1581 if (ecoffsymbol (symbol)->local)
1582 {
1583 ecoff_swap_sym_in (abfd, ecoffsymbol (symbol)->native.lnative,
1584 &ecoff_ext.asym);
1585 type = 'l';
1586 pos = (ecoffsymbol (symbol)->native.lnative
1587 - ecoff_data (abfd)->external_sym
1588 + ecoff_data (abfd)->symbolic_header.iextMax);
1589 jmptbl = ' ';
1590 cobol_main = ' ';
1591 weakext = ' ';
1592 }
1593 else
1594 {
1595 ecoff_swap_ext_in (abfd, ecoffsymbol (symbol)->native.enative,
1596 &ecoff_ext);
1597 type = 'e';
1598 pos = (ecoffsymbol (symbol)->native.enative
1599 - ecoff_data (abfd)->external_ext);
1600 jmptbl = ecoff_ext.jmptbl ? 'j' : ' ';
1601 cobol_main = ecoff_ext.cobol_main ? 'c' : ' ';
1602 weakext = ecoff_ext.weakext ? 'w' : ' ';
1603 }
1604
1605 fprintf (file, "[%3d] %c %lx st %x sc %x indx %x %c%c%c %s",
1606 pos, type, (unsigned long) ecoff_ext.asym.value,
1607 (unsigned) ecoff_ext.asym.st,
1608 (unsigned) ecoff_ext.asym.sc,
1609 (unsigned) ecoff_ext.asym.index,
1610 jmptbl, cobol_main, weakext,
1611 symbol->name);
1612
1613 if (ecoffsymbol (symbol)->fdr != NULL
1614 && ecoff_ext.asym.index != indexNil)
1615 {
1616 unsigned indx;
1617 int bigendian;
1618 long sym_base;
1619 union aux_ext *aux_base;
1620
1621 indx = ecoff_ext.asym.index;
1622
1623 /* sym_base is used to map the fdr relative indices which
1624 appear in the file to the position number which we are
1625 using. */
1626 sym_base = ecoffsymbol (symbol)->fdr->isymBase;
1627 if (ecoffsymbol (symbol)->local)
1628 sym_base += ecoff_data (abfd)->symbolic_header.iextMax;
1629
1630 /* aux_base is the start of the aux entries for this file;
1631 asym.index is an offset from this. */
1632 aux_base = (ecoff_data (abfd)->external_aux
1633 + ecoffsymbol (symbol)->fdr->iauxBase);
1634
1635 /* The aux entries are stored in host byte order; the
1636 order is indicated by a bit in the fdr. */
1637 bigendian = ecoffsymbol (symbol)->fdr->fBigendian;
1638
1639 /* This switch is basically from gcc/mips-tdump.c */
1640 switch (ecoff_ext.asym.st)
1641 {
1642 case stNil:
1643 case stLabel:
1644 break;
1645
1646 case stFile:
1647 case stBlock:
1648 printf ("\n End+1 symbol: %ld", indx + sym_base);
1649 break;
1650
1651 case stEnd:
1652 if (ecoff_ext.asym.sc == scText
1653 || ecoff_ext.asym.sc == scInfo)
1654 printf ("\n First symbol: %ld", indx + sym_base);
1655 else
1656 printf ("\n First symbol: %ld",
1657 (long) (AUX_GET_ISYM (bigendian,
1658 &aux_base[ecoff_ext.asym.index])
1659 + sym_base));
1660 break;
1661
1662 case stProc:
1663 case stStaticProc:
1664 if (MIPS_IS_STAB (&ecoff_ext.asym))
1665 ;
1666 else if (ecoffsymbol (symbol)->local)
1667 printf ("\n End+1 symbol: %-7ld Type: %s",
1668 (long) (AUX_GET_ISYM (bigendian,
1669 &aux_base[ecoff_ext.asym.index])
1670 + sym_base),
1671 ecoff_type_to_string (abfd, aux_base, indx + 1,
1672 bigendian));
1673 else
1674 printf ("\n Local symbol: %d",
1675 (indx
1676 + sym_base
1677 + ecoff_data (abfd)->symbolic_header.iextMax));
1678 break;
1679
1680 default:
1681 if (!MIPS_IS_STAB (&ecoff_ext.asym))
1682 printf ("\n Type: %s",
1683 ecoff_type_to_string (abfd, aux_base, indx,
1684 bigendian));
1685 break;
1686 }
1687 }
1688 }
1689 break;
1690 }
1691 }
1692 \f
1693 /* Reloc handling. MIPS ECOFF relocs are packed into 8 bytes in
1694 external form. They use a bit which indicates whether the symbol
1695 is external. */
1696
1697 /* Swap a reloc in. */
1698
1699 static void
1700 ecoff_swap_reloc_in (abfd, ext, intern)
1701 bfd *abfd;
1702 RELOC *ext;
1703 struct internal_reloc *intern;
1704 {
1705 intern->r_vaddr = bfd_h_get_32 (abfd, (bfd_byte *) ext->r_vaddr);
1706 if (abfd->xvec->header_byteorder_big_p != false)
1707 {
1708 intern->r_symndx = (((int) ext->r_bits[0]
1709 << RELOC_BITS0_SYMNDX_SH_LEFT_BIG)
1710 | ((int) ext->r_bits[1]
1711 << RELOC_BITS1_SYMNDX_SH_LEFT_BIG)
1712 | ((int) ext->r_bits[2]
1713 << RELOC_BITS2_SYMNDX_SH_LEFT_BIG));
1714 intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_BIG)
1715 >> RELOC_BITS3_TYPE_SH_BIG);
1716 intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_BIG) != 0;
1717 }
1718 else
1719 {
1720 intern->r_symndx = (((int) ext->r_bits[0]
1721 << RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE)
1722 | ((int) ext->r_bits[1]
1723 << RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE)
1724 | ((int) ext->r_bits[2]
1725 << RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE));
1726 intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)
1727 >> RELOC_BITS3_TYPE_SH_LITTLE);
1728 intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) != 0;
1729 }
1730 }
1731
1732 /* Swap a reloc out. */
1733
1734 static unsigned int
1735 ecoff_swap_reloc_out (abfd, src, dst)
1736 bfd *abfd;
1737 PTR src;
1738 PTR dst;
1739 {
1740 struct internal_reloc *intern = (struct internal_reloc *) src;
1741 RELOC *ext = (RELOC *) dst;
1742
1743 bfd_h_put_32 (abfd, intern->r_vaddr, (bfd_byte *) ext->r_vaddr);
1744 if (abfd->xvec->header_byteorder_big_p != false)
1745 {
1746 ext->r_bits[0] = intern->r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_BIG;
1747 ext->r_bits[1] = intern->r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_BIG;
1748 ext->r_bits[2] = intern->r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_BIG;
1749 ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_BIG)
1750 & RELOC_BITS3_TYPE_BIG)
1751 | (intern->r_extern ? RELOC_BITS3_EXTERN_BIG : 0));
1752 }
1753 else
1754 {
1755 ext->r_bits[0] = intern->r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE;
1756 ext->r_bits[1] = intern->r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE;
1757 ext->r_bits[2] = intern->r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE;
1758 ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_LITTLE)
1759 & RELOC_BITS3_TYPE_LITTLE)
1760 | (intern->r_extern ? RELOC_BITS3_EXTERN_LITTLE : 0));
1761 }
1762
1763 return RELSZ;
1764 }
1765
1766 /* ECOFF relocs are either against external symbols, or against
1767 sections. If we are producing relocateable output, and the reloc
1768 is against an external symbol, and nothing has given us any
1769 additional addend, the resulting reloc will also be against the
1770 same symbol. In such a case, we don't want to change anything
1771 about the way the reloc is handled, since it will all be done at
1772 final link time. Rather than put special case code into
1773 bfd_perform_relocation, all the reloc types use this howto
1774 function. It just short circuits the reloc if producing
1775 relocateable output against an external symbol. */
1776
1777 static bfd_reloc_status_type
1778 ecoff_generic_reloc (abfd,
1779 reloc_entry,
1780 symbol,
1781 data,
1782 input_section,
1783 output_bfd)
1784 bfd *abfd;
1785 arelent *reloc_entry;
1786 asymbol *symbol;
1787 PTR data;
1788 asection *input_section;
1789 bfd *output_bfd;
1790 {
1791 if (output_bfd != (bfd *) NULL
1792 && (symbol->flags & BSF_SECTION_SYM) == 0
1793 && reloc_entry->addend == 0)
1794 {
1795 reloc_entry->address += input_section->output_offset;
1796 return bfd_reloc_ok;
1797 }
1798
1799 return bfd_reloc_continue;
1800 }
1801
1802 /* Do a REFHI relocation. This has to be done in combination with a
1803 REFLO reloc, because there is a carry from the REFLO to the REFHI.
1804 Here we just save the information we need; we do the actual
1805 relocation when we see the REFLO. ECOFF requires that the REFLO
1806 immediately follow the REFHI, so this ought to work. */
1807
1808 static bfd_byte *ecoff_refhi_addr;
1809 static bfd_vma ecoff_refhi_addend;
1810
1811 static bfd_reloc_status_type
1812 ecoff_refhi_reloc (abfd,
1813 reloc_entry,
1814 symbol,
1815 data,
1816 input_section,
1817 output_bfd)
1818 bfd *abfd;
1819 arelent *reloc_entry;
1820 asymbol *symbol;
1821 PTR data;
1822 asection *input_section;
1823 bfd *output_bfd;
1824 {
1825 bfd_reloc_status_type ret;
1826 bfd_vma relocation;
1827
1828 /* If we're relocating, and this an external symbol, we don't want
1829 to change anything. */
1830 if (output_bfd != (bfd *) NULL
1831 && (symbol->flags & BSF_SECTION_SYM) == 0
1832 && reloc_entry->addend == 0)
1833 {
1834 reloc_entry->address += input_section->output_offset;
1835 return bfd_reloc_ok;
1836 }
1837
1838 ret = bfd_reloc_ok;
1839 if (symbol->section == &bfd_und_section
1840 && output_bfd == (bfd *) NULL)
1841 ret = bfd_reloc_undefined;
1842
1843 if (bfd_is_com_section (symbol->section))
1844 relocation = 0;
1845 else
1846 relocation = symbol->value;
1847
1848 relocation += symbol->section->output_section->vma;
1849 relocation += symbol->section->output_offset;
1850 relocation += reloc_entry->addend;
1851
1852 if (reloc_entry->address > input_section->_cooked_size)
1853 return bfd_reloc_outofrange;
1854
1855 /* Save the information, and let REFLO do the actual relocation. */
1856 ecoff_refhi_addr = (bfd_byte *) data + reloc_entry->address;
1857 ecoff_refhi_addend = relocation;
1858
1859 if (output_bfd != (bfd *) NULL)
1860 reloc_entry->address += input_section->output_offset;
1861
1862 return ret;
1863 }
1864
1865 /* Do a REFLO relocation. This is a straightforward 16 bit inplace
1866 relocation; this function exists in order to do the REFHI
1867 relocation described above. */
1868
1869 static bfd_reloc_status_type
1870 ecoff_reflo_reloc (abfd,
1871 reloc_entry,
1872 symbol,
1873 data,
1874 input_section,
1875 output_bfd)
1876 bfd *abfd;
1877 arelent *reloc_entry;
1878 asymbol *symbol;
1879 PTR data;
1880 asection *input_section;
1881 bfd *output_bfd;
1882 {
1883 if (ecoff_refhi_addr != (bfd_byte *) NULL)
1884 {
1885 unsigned long insn;
1886 unsigned long val;
1887 unsigned long vallo;
1888
1889 /* Do the REFHI relocation. Note that we actually don't need to
1890 know anything about the REFLO itself, except where to find
1891 the low 16 bits of the addend needed by the REFHI. */
1892 insn = bfd_get_32 (abfd, ecoff_refhi_addr);
1893 vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
1894 & 0xffff);
1895 val = ((insn & 0xffff) << 16) + vallo;
1896 val += ecoff_refhi_addend;
1897
1898 /* The low order 16 bits are always treated as a signed value.
1899 Therefore, a negative value in the low order bits requires an
1900 adjustment in the high order bits. We need to make this
1901 adjustment in two ways: once for the bits we took from the
1902 data, and once for the bits we are putting back in to the
1903 data. */
1904 if ((vallo & 0x8000) != 0)
1905 val -= 0x10000;
1906 if ((val & 0x8000) != 0)
1907 val += 0x10000;
1908
1909 insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);
1910 bfd_put_32 (abfd, insn, ecoff_refhi_addr);
1911
1912 ecoff_refhi_addr = (bfd_byte *) NULL;
1913 }
1914
1915 /* Now do the REFLO reloc in the usual way. */
1916 return ecoff_generic_reloc (abfd, reloc_entry, symbol, data,
1917 input_section, output_bfd);
1918 }
1919
1920 /* Do a GPREL relocation. This is a 16 bit value which must become
1921 the offset from the gp register. */
1922
1923 static bfd_reloc_status_type
1924 ecoff_gprel_reloc (abfd,
1925 reloc_entry,
1926 symbol,
1927 data,
1928 input_section,
1929 output_bfd)
1930 bfd *abfd;
1931 arelent *reloc_entry;
1932 asymbol *symbol;
1933 PTR data;
1934 asection *input_section;
1935 bfd *output_bfd;
1936 {
1937 boolean relocateable;
1938 bfd_vma relocation;
1939 unsigned long val;
1940 unsigned long insn;
1941
1942 /* If we're relocating, and this is an external symbol with no
1943 addend, we don't want to change anything. We will only have an
1944 addend if this is a newly created reloc, not read from an ECOFF
1945 file. */
1946 if (output_bfd != (bfd *) NULL
1947 && (symbol->flags & BSF_SECTION_SYM) == 0
1948 && reloc_entry->addend == 0)
1949 {
1950 reloc_entry->address += input_section->output_offset;
1951 return bfd_reloc_ok;
1952 }
1953
1954 if (output_bfd != (bfd *) NULL)
1955 relocateable = true;
1956 else
1957 {
1958 relocateable = false;
1959 output_bfd = symbol->section->output_section->owner;
1960 }
1961
1962 if (symbol->section == &bfd_und_section
1963 && relocateable == false)
1964 return bfd_reloc_undefined;
1965
1966 /* We have to figure out the gp value, so that we can adjust the
1967 symbol value correctly. We look up the symbol _gp in the output
1968 BFD. If we can't find it, we're stuck. We cache it in the ECOFF
1969 target data. We don't need to adjust the symbol value for an
1970 external symbol if we are producing relocateable output. */
1971 if (ecoff_data (output_bfd)->gp == 0
1972 && (relocateable == false
1973 || (symbol->flags & BSF_SECTION_SYM) != 0))
1974 {
1975 if (relocateable != false)
1976 {
1977 /* Make up a value. */
1978 ecoff_data (output_bfd)->gp =
1979 symbol->section->output_section->vma + 0x4000;
1980 }
1981 else
1982 {
1983 unsigned int count;
1984 asymbol **sym;
1985 unsigned int i;
1986
1987 count = bfd_get_symcount (output_bfd);
1988 sym = bfd_get_outsymbols (output_bfd);
1989
1990 /* We should do something more friendly here, but we don't
1991 have a good reloc status to return. */
1992 if (sym == (asymbol **) NULL)
1993 abort ();
1994
1995 for (i = 0; i < count; i++, sym++)
1996 {
1997 register CONST char *name;
1998
1999 name = bfd_asymbol_name (*sym);
2000 if (*name == '_' && strcmp (name, "_gp") == 0)
2001 {
2002 ecoff_data (output_bfd)->gp = bfd_asymbol_value (*sym);
2003 break;
2004 }
2005 }
2006
2007 /* We should do something more friendly here, but we don't have
2008 a good reloc status to return. */
2009 if (i >= count)
2010 abort ();
2011 }
2012 }
2013
2014 if (bfd_is_com_section (symbol->section))
2015 relocation = 0;
2016 else
2017 relocation = symbol->value;
2018
2019 relocation += symbol->section->output_section->vma;
2020 relocation += symbol->section->output_offset;
2021
2022 if (reloc_entry->address > input_section->_cooked_size)
2023 return bfd_reloc_outofrange;
2024
2025 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
2026
2027 /* Set val to the offset into the section or symbol. */
2028 val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
2029 if (val & 0x8000)
2030 val -= 0x10000;
2031
2032 /* Adjust val for the final section location and GP value. If we
2033 are producing relocateable output, we don't want to do this for
2034 an external symbol. */
2035 if (relocateable == false
2036 || (symbol->flags & BSF_SECTION_SYM) != 0)
2037 val += relocation - ecoff_data (output_bfd)->gp;
2038
2039 insn = (insn &~ 0xffff) | (val & 0xffff);
2040 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
2041
2042 if (relocateable != false)
2043 reloc_entry->address += input_section->output_offset;
2044
2045 /* Make sure it fit in 16 bits. */
2046 if (val >= 0x8000 && val < 0xffff8000)
2047 return bfd_reloc_outofrange;
2048
2049 return bfd_reloc_ok;
2050 }
2051
2052 /* Read in the relocs for a section. */
2053
2054 static boolean
2055 ecoff_slurp_reloc_table (abfd, section, symbols)
2056 bfd *abfd;
2057 asection *section;
2058 asymbol **symbols;
2059 {
2060 RELOC *external_relocs;
2061 arelent *internal_relocs;
2062 arelent *rptr;
2063 unsigned int i;
2064
2065 if (section->relocation != (arelent *) NULL
2066 || section->reloc_count == 0
2067 || (section->flags & SEC_CONSTRUCTOR) != 0)
2068 return true;
2069
2070 if (ecoff_slurp_symbol_table (abfd) == false)
2071 return false;
2072
2073 internal_relocs = (arelent *) bfd_alloc (abfd,
2074 (sizeof (arelent)
2075 * section->reloc_count));
2076 external_relocs = (RELOC *) bfd_alloc (abfd, RELSZ * section->reloc_count);
2077 if (internal_relocs == (arelent *) NULL
2078 || external_relocs == (RELOC *) NULL)
2079 {
2080 bfd_error = no_memory;
2081 return false;
2082 }
2083 if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0)
2084 return false;
2085 if (bfd_read (external_relocs, 1, RELSZ * section->reloc_count, abfd)
2086 != RELSZ * section->reloc_count)
2087 {
2088 bfd_error = system_call_error;
2089 return false;
2090 }
2091
2092 for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++)
2093 {
2094 struct internal_reloc intern;
2095
2096 ecoff_swap_reloc_in (abfd, external_relocs + i, &intern);
2097
2098 if (intern.r_type > ECOFF_R_LITERAL)
2099 abort ();
2100
2101 if (intern.r_extern)
2102 {
2103 /* r_symndx is an index into the external symbols. */
2104 BFD_ASSERT (intern.r_symndx >= 0
2105 && (intern.r_symndx
2106 < ecoff_data (abfd)->symbolic_header.iextMax));
2107 rptr->sym_ptr_ptr = symbols + intern.r_symndx;
2108 rptr->addend = 0;
2109 }
2110 else
2111 {
2112 CONST char *sec_name;
2113 asection *sec;
2114
2115 /* r_symndx is a section key. */
2116 switch (intern.r_symndx)
2117 {
2118 case RELOC_SECTION_TEXT: sec_name = ".text"; break;
2119 case RELOC_SECTION_RDATA: sec_name = ".rdata"; break;
2120 case RELOC_SECTION_DATA: sec_name = ".data"; break;
2121 case RELOC_SECTION_SDATA: sec_name = ".sdata"; break;
2122 case RELOC_SECTION_SBSS: sec_name = ".sbss"; break;
2123 case RELOC_SECTION_BSS: sec_name = ".bss"; break;
2124 case RELOC_SECTION_INIT: sec_name = ".init"; break;
2125 case RELOC_SECTION_LIT8: sec_name = ".lit8"; break;
2126 case RELOC_SECTION_LIT4: sec_name = ".lit4"; break;
2127 default: abort ();
2128 }
2129
2130 sec = bfd_get_section_by_name (abfd, sec_name);
2131 if (sec == (asection *) NULL)
2132 abort ();
2133 rptr->sym_ptr_ptr = sec->symbol_ptr_ptr;
2134
2135 rptr->addend = - bfd_get_section_vma (abfd, sec);
2136 if (intern.r_type == ECOFF_R_GPREL
2137 || intern.r_type == ECOFF_R_LITERAL)
2138 rptr->addend += ecoff_data (abfd)->gp;
2139 }
2140
2141 rptr->address = intern.r_vaddr - bfd_get_section_vma (abfd, section);
2142 rptr->howto = &ecoff_howto_table[intern.r_type];
2143
2144 /* If the type is ECOFF_R_IGNORE, make sure this is a reference
2145 to the absolute section so that the reloc is ignored. */
2146 if (intern.r_type == ECOFF_R_IGNORE)
2147 rptr->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
2148 }
2149
2150 bfd_release (abfd, external_relocs);
2151
2152 section->relocation = internal_relocs;
2153
2154 return true;
2155 }
2156
2157 /* Get a canonical list of relocs. */
2158
2159 static unsigned int
2160 ecoff_canonicalize_reloc (abfd, section, relptr, symbols)
2161 bfd *abfd;
2162 asection *section;
2163 arelent **relptr;
2164 asymbol **symbols;
2165 {
2166 unsigned int count;
2167
2168 if (section->flags & SEC_CONSTRUCTOR)
2169 {
2170 arelent_chain *chain;
2171
2172 /* This section has relocs made up by us, not the file, so take
2173 them out of their chain and place them into the data area
2174 provided. */
2175 for (count = 0, chain = section->constructor_chain;
2176 count < section->reloc_count;
2177 count++, chain = chain->next)
2178 *relptr++ = &chain->relent;
2179 }
2180 else
2181 {
2182 arelent *tblptr;
2183
2184 if (ecoff_slurp_reloc_table (abfd, section, symbols) == false)
2185 return 0;
2186
2187 tblptr = section->relocation;
2188 if (tblptr == (arelent *) NULL)
2189 return 0;
2190
2191 for (count = 0; count < section->reloc_count; count++)
2192 *relptr++ = tblptr++;
2193 }
2194
2195 *relptr = (arelent *) NULL;
2196
2197 return section->reloc_count;
2198 }
2199
2200 /* Get the howto structure for a generic reloc type. */
2201
2202 static CONST struct reloc_howto_struct *
2203 ecoff_bfd_reloc_type_lookup (abfd, code)
2204 bfd *abfd;
2205 bfd_reloc_code_real_type code;
2206 {
2207 int ecoff_type;
2208
2209 switch (code)
2210 {
2211 case BFD_RELOC_16:
2212 ecoff_type = ECOFF_R_REFHALF;
2213 break;
2214 case BFD_RELOC_32:
2215 ecoff_type = ECOFF_R_REFWORD;
2216 break;
2217 case BFD_RELOC_MIPS_JMP:
2218 ecoff_type = ECOFF_R_JMPADDR;
2219 break;
2220 case BFD_RELOC_HI16_S:
2221 ecoff_type = ECOFF_R_REFHI;
2222 break;
2223 case BFD_RELOC_LO16:
2224 ecoff_type = ECOFF_R_REFLO;
2225 break;
2226 case BFD_RELOC_MIPS_GPREL:
2227 ecoff_type = ECOFF_R_GPREL;
2228 break;
2229 default:
2230 return (CONST struct reloc_howto_struct *) NULL;
2231 }
2232
2233 return &ecoff_howto_table[ecoff_type];
2234 }
2235 \f
2236 /* Provided a BFD, a section and an offset into the section, calculate
2237 and return the name of the source file and the line nearest to the
2238 wanted location. */
2239
2240 static boolean
2241 ecoff_find_nearest_line (abfd,
2242 section,
2243 ignore_symbols,
2244 offset,
2245 filename_ptr,
2246 functionname_ptr,
2247 retline_ptr)
2248 bfd *abfd;
2249 asection *section;
2250 asymbol **ignore_symbols;
2251 bfd_vma offset;
2252 CONST char **filename_ptr;
2253 CONST char **functionname_ptr;
2254 unsigned int *retline_ptr;
2255 {
2256 FDR *fdr_ptr;
2257 FDR *fdr_start;
2258 FDR *fdr_end;
2259 FDR *fdr_hold;
2260 struct pdr_ext *pdr_ptr;
2261 struct pdr_ext *pdr_end;
2262 PDR pdr;
2263 unsigned char *line_ptr;
2264 unsigned char *line_end;
2265 int lineno;
2266
2267 /* If we're not in the .text section, we don't have any line
2268 numbers. */
2269 if (strcmp (section->name, _TEXT) != 0
2270 || offset < ecoff_data (abfd)->text_start
2271 || offset >= ecoff_data (abfd)->text_end)
2272 return false;
2273
2274 /* Make sure we have the FDR's. */
2275 if (ecoff_slurp_symbolic_info (abfd) == false
2276 || bfd_get_symcount (abfd) == 0)
2277 return false;
2278
2279 /* Each file descriptor (FDR) has a memory address. Here we track
2280 down which FDR we want. The FDR's are stored in increasing
2281 memory order. If speed is ever important, this can become a
2282 binary search. We must ignore FDR's with no PDR entries; they
2283 will have the adr of the FDR before or after them. */
2284 fdr_start = ecoff_data (abfd)->fdr;
2285 fdr_end = fdr_start + ecoff_data (abfd)->symbolic_header.ifdMax;
2286 fdr_hold = (FDR *) NULL;
2287 for (fdr_ptr = fdr_start; fdr_ptr < fdr_end; fdr_ptr++)
2288 {
2289 if (fdr_ptr->cpd == 0)
2290 continue;
2291 if (offset < fdr_ptr->adr)
2292 break;
2293 fdr_hold = fdr_ptr;
2294 }
2295 if (fdr_hold == (FDR *) NULL)
2296 return false;
2297 fdr_ptr = fdr_hold;
2298
2299 /* Each FDR has a list of procedure descriptors (PDR). PDR's also
2300 have an address, which is relative to the FDR address, and are
2301 also stored in increasing memory order. */
2302 offset -= fdr_ptr->adr;
2303 pdr_ptr = ecoff_data (abfd)->external_pdr + fdr_ptr->ipdFirst;
2304 pdr_end = pdr_ptr + fdr_ptr->cpd;
2305 ecoff_swap_pdr_in (abfd, pdr_ptr, &pdr);
2306
2307 /* The address of the first PDR is an offset which applies to the
2308 addresses of all the PDR's. */
2309 offset += pdr.adr;
2310
2311 for (pdr_ptr++; pdr_ptr < pdr_end; pdr_ptr++)
2312 {
2313 ecoff_swap_pdr_in (abfd, pdr_ptr, &pdr);
2314 if (offset < pdr.adr)
2315 break;
2316 }
2317
2318 /* Now we can look for the actual line number. The line numbers are
2319 stored in a very funky format, which I won't try to describe.
2320 Note that right here pdr_ptr and pdr hold the PDR *after* the one
2321 we want; we need this to compute line_end. */
2322 line_end = ecoff_data (abfd)->line;
2323 if (pdr_ptr == pdr_end)
2324 line_end += fdr_ptr->cbLineOffset + fdr_ptr->cbLine;
2325 else
2326 line_end += fdr_ptr->cbLineOffset + pdr.cbLineOffset;
2327
2328 /* Now change pdr and pdr_ptr to the one we want. */
2329 pdr_ptr--;
2330 ecoff_swap_pdr_in (abfd, pdr_ptr, &pdr);
2331
2332 offset -= pdr.adr;
2333 lineno = pdr.lnLow;
2334 line_ptr = (ecoff_data (abfd)->line
2335 + fdr_ptr->cbLineOffset
2336 + pdr.cbLineOffset);
2337 while (line_ptr < line_end)
2338 {
2339 int delta;
2340 int count;
2341
2342 delta = *line_ptr >> 4;
2343 if (delta >= 0x8)
2344 delta -= 0x10;
2345 count = (*line_ptr & 0xf) + 1;
2346 ++line_ptr;
2347 if (delta == -8)
2348 {
2349 delta = (((line_ptr[0]) & 0xff) << 8) + ((line_ptr[1]) & 0xff);
2350 if (delta >= 0x8000)
2351 delta -= 0x10000;
2352 line_ptr += 2;
2353 }
2354 lineno += delta;
2355 if (offset < count * 4)
2356 break;
2357 offset -= count * 4;
2358 }
2359
2360 /* If fdr_ptr->rss is -1, then this file does not have full symbols,
2361 at least according to gdb/mipsread.c. */
2362 if (fdr_ptr->rss == -1)
2363 {
2364 *filename_ptr = NULL;
2365 if (pdr.isym == -1)
2366 *functionname_ptr = NULL;
2367 else
2368 {
2369 EXTR proc_ext;
2370
2371 ecoff_swap_ext_in (abfd,
2372 (ecoff_data (abfd)->external_ext
2373 + pdr.isym),
2374 &proc_ext);
2375 *functionname_ptr = ecoff_data (abfd)->ssext + proc_ext.asym.iss;
2376 }
2377 }
2378 else
2379 {
2380 SYMR proc_sym;
2381
2382 *filename_ptr = ecoff_data (abfd)->ss + fdr_ptr->issBase + fdr_ptr->rss;
2383 ecoff_swap_sym_in (abfd,
2384 (ecoff_data (abfd)->external_sym
2385 + fdr_ptr->isymBase
2386 + pdr.isym),
2387 &proc_sym);
2388 *functionname_ptr = (ecoff_data (abfd)->ss
2389 + fdr_ptr->issBase
2390 + proc_sym.iss);
2391 }
2392 if (lineno == ilineNil)
2393 lineno = 0;
2394 *retline_ptr = lineno;
2395 return true;
2396 }
2397 \f
2398 /* We can't use the generic linking routines for ECOFF, because we
2399 have to handle all the debugging information. The generic link
2400 routine just works out the section contents and attaches a list of
2401 symbols.
2402
2403 We link by looping over all the seclets. We make two passes. On
2404 the first we set the actual section contents and determine the size
2405 of the debugging information. On the second we accumulate the
2406 debugging information and write it out.
2407
2408 This currently always accumulates the debugging information, which
2409 is incorrect, because it ignores the -s and -S options of the
2410 linker. The linker needs to be modified to give us that
2411 information in a more useful format (currently it just provides a
2412 list of symbols which should appear in the output file). */
2413
2414 /* Clear the output_has_begun flag for all the input BFD's. We use it
2415 to avoid linking in the debugging information for a BFD more than
2416 once. */
2417
2418 static void
2419 ecoff_clear_output_flags (abfd)
2420 bfd *abfd;
2421 {
2422 register asection *o;
2423 register bfd_seclet_type *p;
2424
2425 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
2426 for (p = o->seclets_head;
2427 p != (bfd_seclet_type *) NULL;
2428 p = p->next)
2429 if (p->type == bfd_indirect_seclet)
2430 p->u.indirect.section->owner->output_has_begun = false;
2431 }
2432
2433 /* Handle an indirect seclet on the first pass. Set the contents of
2434 the output section, and accumulate the debugging information if
2435 any. */
2436
2437 static boolean
2438 ecoff_rel (output_bfd, seclet, output_section, data, relocateable)
2439 bfd *output_bfd;
2440 bfd_seclet_type *seclet;
2441 asection *output_section;
2442 PTR data;
2443 boolean relocateable;
2444 {
2445 bfd *input_bfd;
2446 HDRR *output_symhdr;
2447 HDRR *input_symhdr;
2448
2449 if ((output_section->flags & SEC_HAS_CONTENTS)
2450 && !(output_section->flags & SEC_NEVER_LOAD)
2451 && (output_section->flags & SEC_LOAD)
2452 && seclet->size)
2453 {
2454 data = (PTR) bfd_get_relocated_section_contents (output_bfd,
2455 seclet,
2456 data,
2457 relocateable);
2458 if (bfd_set_section_contents (output_bfd,
2459 output_section,
2460 data,
2461 seclet->offset,
2462 seclet->size)
2463 == false)
2464 {
2465 abort();
2466 }
2467 }
2468
2469 input_bfd = seclet->u.indirect.section->owner;
2470
2471 /* We want to figure out how much space will be required to
2472 incorporate all the debugging information from input_bfd. We use
2473 the output_has_begun field to avoid adding it in more than once.
2474 The actual incorporation is done in the second pass, in
2475 ecoff_get_debug. The code has to parallel that code in its
2476 manipulations of output_symhdr. */
2477
2478 if (input_bfd->output_has_begun)
2479 return true;
2480 input_bfd->output_has_begun = true;
2481
2482 output_symhdr = &ecoff_data (output_bfd)->symbolic_header;
2483
2484 if (input_bfd->xvec->flavour != bfd_target_ecoff_flavour)
2485 {
2486 asymbol **symbols;
2487 asymbol **sym_ptr;
2488 asymbol **sym_end;
2489
2490 /* We just accumulate local symbols from a non-ECOFF BFD. The
2491 external symbols are handled separately. */
2492
2493 symbols = (asymbol **) bfd_alloc (output_bfd,
2494 get_symtab_upper_bound (input_bfd));
2495 if (symbols == (asymbol **) NULL)
2496 {
2497 bfd_error = no_memory;
2498 return false;
2499 }
2500 sym_end = symbols + bfd_canonicalize_symtab (input_bfd, symbols);
2501
2502 for (sym_ptr = symbols; sym_ptr < sym_end; sym_ptr++)
2503 {
2504 size_t len;
2505
2506 len = strlen ((*sym_ptr)->name);
2507 if (((*sym_ptr)->flags & BSF_EXPORT) == 0)
2508 {
2509 ++output_symhdr->isymMax;
2510 output_symhdr->issMax += len + 1;
2511 }
2512 }
2513
2514 bfd_release (output_bfd, (PTR) symbols);
2515
2516 ++output_symhdr->ifdMax;
2517
2518 return true;
2519 }
2520
2521 /* We simply add in the information from another ECOFF BFD. First
2522 we make sure we have the symbolic information. */
2523 if (ecoff_slurp_symbol_table (input_bfd) == false)
2524 return false;
2525 if (bfd_get_symcount (input_bfd) == 0)
2526 return true;
2527
2528 input_symhdr = &ecoff_data (input_bfd)->symbolic_header;
2529
2530 /* Figure out how much information we are going to be putting in.
2531 The external symbols are handled separately. */
2532 output_symhdr->ilineMax += input_symhdr->ilineMax;
2533 output_symhdr->cbLine += input_symhdr->cbLine;
2534 output_symhdr->idnMax += input_symhdr->idnMax;
2535 output_symhdr->ipdMax += input_symhdr->ipdMax;
2536 output_symhdr->isymMax += input_symhdr->isymMax;
2537 output_symhdr->ioptMax += input_symhdr->ioptMax;
2538 output_symhdr->iauxMax += input_symhdr->iauxMax;
2539 output_symhdr->issMax += input_symhdr->issMax;
2540 output_symhdr->ifdMax += input_symhdr->ifdMax;
2541
2542 /* The RFD's are special, since we create them if needed. */
2543 if (input_symhdr->crfd > 0)
2544 output_symhdr->crfd += input_symhdr->crfd;
2545 else
2546 output_symhdr->crfd += input_symhdr->ifdMax;
2547
2548 return true;
2549 }
2550
2551 /* Handle an arbitrary seclet on the first pass. */
2552
2553 static boolean
2554 ecoff_dump_seclet (abfd, seclet, section, data, relocateable)
2555 bfd *abfd;
2556 bfd_seclet_type *seclet;
2557 asection *section;
2558 PTR data;
2559 boolean relocateable;
2560 {
2561 switch (seclet->type)
2562 {
2563 case bfd_indirect_seclet:
2564 /* The contents of this section come from another one somewhere
2565 else. */
2566 return ecoff_rel (abfd, seclet, section, data, relocateable);
2567
2568 case bfd_fill_seclet:
2569 /* Fill in the section with fill.value. This is used to pad out
2570 sections, but we must avoid padding the .bss section. */
2571 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2572 {
2573 if (seclet->u.fill.value != 0)
2574 abort ();
2575 }
2576 else
2577 {
2578 char *d = (char *) bfd_alloc (abfd, seclet->size);
2579 unsigned int i;
2580 boolean ret;
2581
2582 for (i = 0; i < seclet->size; i+=2)
2583 d[i] = seclet->u.fill.value >> 8;
2584 for (i = 1; i < seclet->size; i+=2)
2585 d[i] = seclet->u.fill.value;
2586 ret = bfd_set_section_contents (abfd, section, d, seclet->offset,
2587 seclet->size);
2588 bfd_release (abfd, (PTR) d);
2589 return ret;
2590 }
2591 break;
2592
2593 default:
2594 abort();
2595 }
2596
2597 return true;
2598 }
2599
2600 /* Add a string to the debugging information we are accumulating for a
2601 file. Return the offset from the fdr string base or from the
2602 external string base. */
2603
2604 static long
2605 ecoff_add_string (output_bfd, fdr, string, external)
2606 bfd *output_bfd;
2607 FDR *fdr;
2608 CONST char *string;
2609 boolean external;
2610 {
2611 HDRR *symhdr;
2612 size_t len;
2613 long ret;
2614
2615 symhdr = &ecoff_data (output_bfd)->symbolic_header;
2616 len = strlen (string);
2617 if (external)
2618 {
2619 strcpy (ecoff_data (output_bfd)->ssext + symhdr->issExtMax, string);
2620 ret = symhdr->issExtMax;
2621 symhdr->issExtMax += len + 1;
2622 }
2623 else
2624 {
2625 strcpy (ecoff_data (output_bfd)->ss + symhdr->issMax, string);
2626 ret = fdr->cbSs;
2627 symhdr->issMax += len + 1;
2628 fdr->cbSs += len + 1;
2629 }
2630 return ret;
2631 }
2632
2633 /* Accumulate the debugging information from an input section. */
2634
2635 static boolean
2636 ecoff_get_debug (output_bfd, seclet, section, relocateable)
2637 bfd *output_bfd;
2638 bfd_seclet_type *seclet;
2639 asection *section;
2640 boolean relocateable;
2641 {
2642 bfd *input_bfd;
2643 HDRR *output_symhdr;
2644 HDRR *input_symhdr;
2645 ecoff_data_type *output_ecoff;
2646 ecoff_data_type *input_ecoff;
2647 unsigned int count;
2648 struct sym_ext *sym_out;
2649 ecoff_symbol_type *esym_ptr;
2650 ecoff_symbol_type *esym_end;
2651 FDR *fdr_ptr;
2652 FDR *fdr_end;
2653 struct fdr_ext *fdr_out;
2654
2655 input_bfd = seclet->u.indirect.section->owner;
2656
2657 /* Don't get the information more than once. */
2658 if (input_bfd->output_has_begun)
2659 return true;
2660 input_bfd->output_has_begun = true;
2661
2662 output_ecoff = ecoff_data (output_bfd);
2663 output_symhdr = &output_ecoff->symbolic_header;
2664
2665 if (input_bfd->xvec->flavour != bfd_target_ecoff_flavour)
2666 {
2667 FDR fdr;
2668 asymbol **symbols;
2669 asymbol **sym_ptr;
2670 asymbol **sym_end;
2671
2672 /* This is not an ECOFF BFD. Just gather the symbols. */
2673
2674 memset (&fdr, 0, sizeof fdr);
2675
2676 fdr.adr = bfd_get_section_vma (output_bfd, section) + seclet->offset;
2677 fdr.issBase = output_symhdr->issMax;
2678 fdr.cbSs = 0;
2679 fdr.rss = ecoff_add_string (output_bfd,
2680 &fdr,
2681 bfd_get_filename (input_bfd),
2682 false);
2683 fdr.isymBase = output_symhdr->isymMax;
2684
2685 /* Get the local symbols from the input BFD. */
2686 symbols = (asymbol **) bfd_alloc (output_bfd,
2687 get_symtab_upper_bound (input_bfd));
2688 if (symbols == (asymbol **) NULL)
2689 {
2690 bfd_error = no_memory;
2691 return false;
2692 }
2693 sym_end = symbols + bfd_canonicalize_symtab (input_bfd, symbols);
2694
2695 /* Handle the local symbols. Any external symbols are handled
2696 separately. */
2697 fdr.csym = 0;
2698 for (sym_ptr = symbols; sym_ptr != sym_end; sym_ptr++)
2699 {
2700 SYMR internal_sym;
2701
2702 if (((*sym_ptr)->flags & BSF_EXPORT) != 0)
2703 continue;
2704 memset (&internal_sym, 0, sizeof internal_sym);
2705 internal_sym.iss = ecoff_add_string (output_bfd,
2706 &fdr,
2707 (*sym_ptr)->name,
2708 false);
2709
2710 if (bfd_is_com_section ((*sym_ptr)->section)
2711 || (*sym_ptr)->section == &bfd_und_section)
2712 internal_sym.value = (*sym_ptr)->value;
2713 else
2714 internal_sym.value = ((*sym_ptr)->value
2715 + (*sym_ptr)->section->output_offset
2716 + (*sym_ptr)->section->output_section->vma);
2717 internal_sym.st = stNil;
2718 internal_sym.sc = scUndefined;
2719 internal_sym.index = indexNil;
2720 ecoff_swap_sym_out (output_bfd, &internal_sym,
2721 (output_ecoff->external_sym
2722 + output_symhdr->isymMax));
2723 ++fdr.csym;
2724 ++output_symhdr->isymMax;
2725 }
2726
2727 bfd_release (output_bfd, (PTR) symbols);
2728
2729 /* Leave everything else in the FDR zeroed out. This will cause
2730 the lang field to be langC. The fBigendian field will
2731 indicate little endian format, but it doesn't matter because
2732 it only applies to aux fields and there are none. */
2733
2734 ecoff_swap_fdr_out (output_bfd, &fdr,
2735 (output_ecoff->external_fdr
2736 + output_symhdr->ifdMax));
2737 ++output_symhdr->ifdMax;
2738 return true;
2739 }
2740
2741 /* This is an ECOFF BFD. We want to grab the information from
2742 input_bfd and attach it to output_bfd. */
2743 count = bfd_get_symcount (input_bfd);
2744 if (count == 0)
2745 return true;
2746 input_ecoff = ecoff_data (input_bfd);
2747 input_symhdr = &input_ecoff->symbolic_header;
2748
2749 /* I think that it is more efficient to simply copy the debugging
2750 information from the input BFD to the output BFD. Because ECOFF
2751 uses relative pointers for most of the debugging information,
2752 only a little of it has to be changed at all. */
2753
2754 /* Swap in the local symbols, adjust their values, and swap them out
2755 again. The external symbols are handled separately. */
2756 sym_out = output_ecoff->external_sym + output_symhdr->isymMax;
2757
2758 esym_ptr = ecoff_data (input_bfd)->canonical_symbols;
2759 esym_end = esym_ptr + count;
2760 for (; esym_ptr < esym_end; esym_ptr++)
2761 {
2762 if (esym_ptr->local)
2763 {
2764 SYMR sym;
2765
2766 ecoff_swap_sym_in (input_bfd, esym_ptr->native.lnative, &sym);
2767
2768 /* If we're producing an executable, move common symbols
2769 into bss. */
2770 if (relocateable == false)
2771 {
2772 if (sym.sc == scCommon)
2773 sym.sc = scBss;
2774 else if (sym.sc == scSCommon)
2775 sym.sc = scSBss;
2776 }
2777
2778 if (! bfd_is_com_section (esym_ptr->symbol.section)
2779 && (esym_ptr->symbol.flags & BSF_DEBUGGING) == 0
2780 && esym_ptr->symbol.section != &bfd_und_section)
2781 sym.value = (esym_ptr->symbol.value
2782 + esym_ptr->symbol.section->output_offset
2783 + esym_ptr->symbol.section->output_section->vma);
2784 ecoff_swap_sym_out (output_bfd, &sym, sym_out);
2785 ++sym_out;
2786 }
2787 }
2788
2789 /* That should have accounted for all the local symbols in
2790 input_bfd. */
2791 BFD_ASSERT ((sym_out - output_ecoff->external_sym) - output_symhdr->isymMax
2792 == input_symhdr->isymMax);
2793
2794 /* Copy the information that does not need swapping. */
2795 memcpy (output_ecoff->line + output_symhdr->cbLine,
2796 input_ecoff->line,
2797 input_symhdr->cbLine * sizeof (unsigned char));
2798 memcpy (output_ecoff->external_aux + output_symhdr->iauxMax,
2799 input_ecoff->external_aux,
2800 input_symhdr->iauxMax * sizeof (union aux_ext));
2801 memcpy (output_ecoff->ss + output_symhdr->issMax,
2802 input_ecoff->ss,
2803 input_symhdr->issMax * sizeof (char));
2804
2805 /* Some of the information may need to be swapped. */
2806 if (output_bfd->xvec->header_byteorder_big_p
2807 == input_bfd->xvec->header_byteorder_big_p)
2808 {
2809 /* The two BFD's have the same endianness, so memcpy will
2810 suffice. */
2811 memcpy (output_ecoff->external_dnr + output_symhdr->idnMax,
2812 input_ecoff->external_dnr,
2813 input_symhdr->idnMax * sizeof (struct dnr_ext));
2814 memcpy (output_ecoff->external_pdr + output_symhdr->ipdMax,
2815 input_ecoff->external_pdr,
2816 input_symhdr->ipdMax * sizeof (struct pdr_ext));
2817 memcpy (output_ecoff->external_opt + output_symhdr->ioptMax,
2818 input_ecoff->external_opt,
2819 input_symhdr->ioptMax * sizeof (struct opt_ext));
2820 }
2821 else
2822 {
2823 struct dnr_ext *dnr_in;
2824 struct dnr_ext *dnr_end;
2825 struct dnr_ext *dnr_out;
2826 struct pdr_ext *pdr_in;
2827 struct pdr_ext *pdr_end;
2828 struct pdr_ext *pdr_out;
2829 struct opt_ext *opt_in;
2830 struct opt_ext *opt_end;
2831 struct opt_ext *opt_out;
2832
2833 /* The two BFD's have different endianness, so we must swap
2834 everything in and out. This code would always work, but it
2835 would be slow in the normal case. */
2836 dnr_in = input_ecoff->external_dnr;
2837 dnr_end = dnr_in + input_symhdr->idnMax;
2838 dnr_out = output_ecoff->external_dnr + output_symhdr->idnMax;
2839 for (; dnr_in < dnr_end; dnr_in++, dnr_out++)
2840 {
2841 DNR dnr;
2842
2843 ecoff_swap_dnr_in (input_bfd, dnr_in, &dnr);
2844 ecoff_swap_dnr_out (output_bfd, &dnr, dnr_out);
2845 }
2846 pdr_in = input_ecoff->external_pdr;
2847 pdr_end = pdr_in + input_symhdr->ipdMax;
2848 pdr_out = output_ecoff->external_pdr + output_symhdr->ipdMax;
2849 for (; pdr_in < pdr_end; pdr_in++, pdr_out++)
2850 {
2851 PDR pdr;
2852
2853 ecoff_swap_pdr_in (input_bfd, pdr_in, &pdr);
2854 ecoff_swap_pdr_out (output_bfd, &pdr, pdr_out);
2855 }
2856 opt_in = input_ecoff->external_opt;
2857 opt_end = opt_in + input_symhdr->ioptMax;
2858 opt_out = output_ecoff->external_opt + output_symhdr->ioptMax;
2859 for (; opt_in < opt_end; opt_in++, opt_out++)
2860 {
2861 OPTR opt;
2862
2863 ecoff_swap_opt_in (input_bfd, opt_in, &opt);
2864 ecoff_swap_opt_out (output_bfd, &opt, opt_out);
2865 }
2866 }
2867
2868 /* Set ifdbase so that the external symbols know how to adjust their
2869 ifd values. */
2870 input_ecoff->ifdbase = output_symhdr->ifdMax;
2871
2872 fdr_ptr = input_ecoff->fdr;
2873 fdr_end = fdr_ptr + input_symhdr->ifdMax;
2874 fdr_out = output_ecoff->external_fdr + output_symhdr->ifdMax;
2875 for (; fdr_ptr < fdr_end; fdr_ptr++, fdr_out++)
2876 {
2877 FDR fdr;
2878 unsigned long pdr_off;
2879
2880 fdr = *fdr_ptr;
2881
2882 /* The memory address for this fdr is the address for the seclet
2883 plus the offset to this fdr within input_bfd. For some
2884 reason the offset of the first procedure pointer is also
2885 added in. */
2886 if (fdr.cpd == 0)
2887 pdr_off = 0;
2888 else
2889 {
2890 PDR pdr;
2891
2892 ecoff_swap_pdr_in (input_bfd,
2893 input_ecoff->external_pdr + fdr.ipdFirst,
2894 &pdr);
2895 pdr_off = pdr.adr;
2896 }
2897 fdr.adr = (bfd_get_section_vma (output_bfd, section)
2898 + seclet->offset
2899 + (fdr_ptr->adr - input_ecoff->fdr->adr)
2900 + pdr_off);
2901
2902 fdr.issBase += output_symhdr->issMax;
2903 fdr.isymBase += output_symhdr->isymMax;
2904 fdr.ilineBase += output_symhdr->ilineMax;
2905 fdr.ioptBase += output_symhdr->ioptMax;
2906 fdr.ipdFirst += output_symhdr->ipdMax;
2907 fdr.iauxBase += output_symhdr->iauxMax;
2908 fdr.rfdBase += output_symhdr->crfd;
2909
2910 /* If there are no RFD's, we are going to add some. We don't
2911 want to adjust irfd for this, so that all the FDR's can share
2912 the RFD's. */
2913 if (input_symhdr->crfd == 0)
2914 fdr.crfd = input_symhdr->ifdMax;
2915
2916 if (fdr.cbLine != 0)
2917 fdr.cbLineOffset += output_symhdr->cbLine;
2918
2919 ecoff_swap_fdr_out (output_bfd, &fdr, fdr_out);
2920 }
2921
2922 if (input_symhdr->crfd > 0)
2923 {
2924 struct rfd_ext *rfd_in;
2925 struct rfd_ext *rfd_end;
2926 struct rfd_ext *rfd_out;
2927
2928 /* Swap and adjust the RFD's. RFD's are only created by the
2929 linker, so this will only be necessary if one of the input
2930 files is the result of a partial link. Presumably all
2931 necessary RFD's are present. */
2932 rfd_in = input_ecoff->external_rfd;
2933 rfd_end = rfd_in + input_symhdr->crfd;
2934 rfd_out = output_ecoff->external_rfd + output_symhdr->crfd;
2935 for (; rfd_in < rfd_end; rfd_in++, rfd_out++)
2936 {
2937 RFDT rfd;
2938
2939 ecoff_swap_rfd_in (input_bfd, rfd_in, &rfd);
2940 rfd += output_symhdr->ifdMax;
2941 ecoff_swap_rfd_out (output_bfd, &rfd, rfd_out);
2942 }
2943 output_symhdr->crfd += input_symhdr->crfd;
2944 }
2945 else
2946 {
2947 struct rfd_ext *rfd_out;
2948 struct rfd_ext *rfd_end;
2949 RFDT rfd;
2950
2951 /* Create RFD's. Some of the debugging information includes
2952 relative file indices. These indices are taken as indices to
2953 the RFD table if there is one, or to the global table if
2954 there is not. If we did not create RFD's, we would have to
2955 parse and adjust all the debugging information which contains
2956 file indices. */
2957 rfd = output_symhdr->ifdMax;
2958 rfd_out = output_ecoff->external_rfd + output_symhdr->crfd;
2959 rfd_end = rfd_out + input_symhdr->ifdMax;
2960 for (; rfd_out < rfd_end; rfd_out++, rfd++)
2961 ecoff_swap_rfd_out (output_bfd, &rfd, rfd_out);
2962 output_symhdr->crfd += input_symhdr->ifdMax;
2963 }
2964
2965 /* Combine the register masks. */
2966 {
2967 int i;
2968
2969 output_ecoff->gprmask |= input_ecoff->gprmask;
2970 for (i = 0; i < 4; i++)
2971 output_ecoff->cprmask[i] |= input_ecoff->cprmask[i];
2972 }
2973
2974 /* Update the counts. */
2975 output_symhdr->ilineMax += input_symhdr->ilineMax;
2976 output_symhdr->cbLine += input_symhdr->cbLine;
2977 output_symhdr->idnMax += input_symhdr->idnMax;
2978 output_symhdr->ipdMax += input_symhdr->ipdMax;
2979 output_symhdr->isymMax += input_symhdr->isymMax;
2980 output_symhdr->ioptMax += input_symhdr->ioptMax;
2981 output_symhdr->iauxMax += input_symhdr->iauxMax;
2982 output_symhdr->issMax += input_symhdr->issMax;
2983 output_symhdr->ifdMax += input_symhdr->ifdMax;
2984
2985 return true;
2986 }
2987
2988 /* This is the actual link routine. It makes two passes over all the
2989 seclets. */
2990
2991 static boolean
2992 ecoff_bfd_seclet_link (abfd, data, relocateable)
2993 bfd *abfd;
2994 PTR data;
2995 boolean relocateable;
2996 {
2997 HDRR *symhdr;
2998 int ipass;
2999 register asection *o;
3000 register bfd_seclet_type *p;
3001 asymbol **sym_ptr_ptr;
3002 bfd_size_type size;
3003 char *raw;
3004
3005 /* We accumulate the debugging information counts in the symbolic
3006 header. */
3007 symhdr = &ecoff_data (abfd)->symbolic_header;
3008 symhdr->magic = magicSym;
3009 /* FIXME: What should the version stamp be? */
3010 symhdr->vstamp = 0;
3011 symhdr->ilineMax = 0;
3012 symhdr->cbLine = 0;
3013 symhdr->idnMax = 0;
3014 symhdr->ipdMax = 0;
3015 symhdr->isymMax = 0;
3016 symhdr->ioptMax = 0;
3017 symhdr->iauxMax = 0;
3018 symhdr->issMax = 0;
3019 symhdr->issExtMax = 0;
3020 symhdr->ifdMax = 0;
3021 symhdr->crfd = 0;
3022 symhdr->iextMax = 0;
3023
3024 /* We need to copy over the debugging symbols from each input BFD.
3025 When we do this copying, we have to adjust the text address in
3026 the FDR structures, so we have to know the text address used for
3027 the input BFD. Since we only want to copy the symbols once per
3028 input BFD, but we are going to look at each input BFD multiple
3029 times (once for each section it provides), we arrange to always
3030 look at the text section first. That means that when we copy the
3031 debugging information, we always know the text address. So we
3032 actually do each pass in two sub passes; first the text sections,
3033 then the non-text sections. We use the output_has_begun flag to
3034 determine whether we have copied over the debugging information
3035 yet. */
3036
3037 /* Do the first pass: set the output section contents and count the
3038 debugging information. */
3039 ecoff_clear_output_flags (abfd);
3040 for (ipass = 0; ipass < 2; ipass++)
3041 {
3042 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3043 {
3044 /* For SEC_CODE sections, (flags & SEC_CODE) == 0 is false,
3045 so they are done on pass 0. For other sections the
3046 expression is true, so they are done on pass 1. */
3047 if (((o->flags & SEC_CODE) == 0) != ipass)
3048 continue;
3049
3050 for (p = o->seclets_head;
3051 p != (bfd_seclet_type *) NULL;
3052 p = p->next)
3053 {
3054 if (ecoff_dump_seclet (abfd, p, o, data, relocateable)
3055 == false)
3056 return false;
3057 }
3058 }
3059 }
3060
3061 /* We handle the external symbols differently. We use the ones
3062 attached to the output_bfd. The linker will have already
3063 determined which symbols are to be attached. Here we just
3064 determine how much space we will need for them. */
3065 sym_ptr_ptr = bfd_get_outsymbols (abfd);
3066 if (sym_ptr_ptr != NULL)
3067 {
3068 asymbol **sym_end;
3069
3070 sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
3071 for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
3072 {
3073 if (((*sym_ptr_ptr)->flags & BSF_DEBUGGING) == 0
3074 && ((*sym_ptr_ptr)->flags & BSF_LOCAL) == 0)
3075 {
3076 ++symhdr->iextMax;
3077 symhdr->issExtMax += strlen ((*sym_ptr_ptr)->name) + 1;
3078 }
3079 }
3080 }
3081
3082 /* Adjust the counts so that structures are longword aligned. */
3083 symhdr->cbLine = (symhdr->cbLine + 3) &~ 3;
3084 symhdr->issMax = (symhdr->issMax + 3) &~ 3;
3085 symhdr->issExtMax = (symhdr->issExtMax + 3) &~ 3;
3086
3087 /* Now the counts in symhdr are the correct size for the debugging
3088 information. We allocate the right amount of space, and reset
3089 the counts so that the second pass can use them as indices. It
3090 would be possible to output the debugging information directly to
3091 the file in pass 2, rather than to build it in memory and then
3092 write it out. Outputting to the file would require a lot of
3093 seeks and small writes, though, and I think this approach is
3094 faster. */
3095 size = (symhdr->cbLine * sizeof (unsigned char)
3096 + symhdr->idnMax * sizeof (struct dnr_ext)
3097 + symhdr->ipdMax * sizeof (struct pdr_ext)
3098 + symhdr->isymMax * sizeof (struct sym_ext)
3099 + symhdr->ioptMax * sizeof (struct opt_ext)
3100 + symhdr->iauxMax * sizeof (union aux_ext)
3101 + symhdr->issMax * sizeof (char)
3102 + symhdr->issExtMax * sizeof (char)
3103 + symhdr->ifdMax * sizeof (struct fdr_ext)
3104 + symhdr->crfd * sizeof (struct rfd_ext)
3105 + symhdr->iextMax * sizeof (struct ext_ext));
3106 raw = (char *) bfd_alloc (abfd, size);
3107 if (raw == (char *) NULL)
3108 {
3109 bfd_error = no_memory;
3110 return false;
3111 }
3112 ecoff_data (abfd)->raw_size = size;
3113 ecoff_data (abfd)->raw_syments = (PTR) raw;
3114
3115 /* Initialize the raw pointers. */
3116 #define SET(field, count, type) \
3117 ecoff_data (abfd)->field = (type *) raw; \
3118 raw += symhdr->count * sizeof (type)
3119
3120 SET (line, cbLine, unsigned char);
3121 SET (external_dnr, idnMax, struct dnr_ext);
3122 SET (external_pdr, ipdMax, struct pdr_ext);
3123 SET (external_sym, isymMax, struct sym_ext);
3124 SET (external_opt, ioptMax, struct opt_ext);
3125 SET (external_aux, iauxMax, union aux_ext);
3126 SET (ss, issMax, char);
3127 SET (ssext, issExtMax, char);
3128 SET (external_fdr, ifdMax, struct fdr_ext);
3129 SET (external_rfd, crfd, struct rfd_ext);
3130 SET (external_ext, iextMax, struct ext_ext);
3131 #undef SET
3132
3133 /* Reset the counts so the second pass can use them to know how far
3134 it has gotten. */
3135 symhdr->ilineMax = 0;
3136 symhdr->cbLine = 0;
3137 symhdr->idnMax = 0;
3138 symhdr->ipdMax = 0;
3139 symhdr->isymMax = 0;
3140 symhdr->ioptMax = 0;
3141 symhdr->iauxMax = 0;
3142 symhdr->issMax = 0;
3143 symhdr->issExtMax = 0;
3144 symhdr->ifdMax = 0;
3145 symhdr->crfd = 0;
3146 symhdr->iextMax = 0;
3147
3148 /* Do the second pass: accumulate the debugging information. */
3149 ecoff_clear_output_flags (abfd);
3150 for (ipass = 0; ipass < 2; ipass++)
3151 {
3152 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3153 {
3154 if (((o->flags & SEC_CODE) == 0) != ipass)
3155 continue;
3156 for (p = o->seclets_head;
3157 p != (bfd_seclet_type *) NULL;
3158 p = p->next)
3159 {
3160 if (p->type == bfd_indirect_seclet)
3161 {
3162 if (ecoff_get_debug (abfd, p, o, relocateable) == false)
3163 return false;
3164 }
3165 }
3166 }
3167 }
3168
3169 /* Put in the external symbols. */
3170 sym_ptr_ptr = bfd_get_outsymbols (abfd);
3171 if (sym_ptr_ptr != NULL)
3172 {
3173 char *ssext;
3174 struct ext_ext *external_ext;
3175
3176 ssext = ecoff_data (abfd)->ssext;
3177 external_ext = ecoff_data (abfd)->external_ext;
3178 for (; *sym_ptr_ptr != NULL; sym_ptr_ptr++)
3179 {
3180 asymbol *sym_ptr;
3181 EXTR esym;
3182
3183 sym_ptr = *sym_ptr_ptr;
3184
3185 if ((sym_ptr->flags & BSF_DEBUGGING) != 0
3186 || (sym_ptr->flags & BSF_LOCAL) != 0)
3187 continue;
3188
3189 /* The enative pointer can be NULL for a symbol created by
3190 the linker via ecoff_make_empty_symbol. */
3191 if (bfd_asymbol_flavour (sym_ptr) != bfd_target_ecoff_flavour
3192 || (((ecoff_symbol_type *) sym_ptr)->native.enative
3193 == (struct ext_ext *) NULL))
3194 {
3195 esym.jmptbl = 0;
3196 esym.cobol_main = 0;
3197 esym.weakext = 0;
3198 esym.reserved = 0;
3199 esym.ifd = ifdNil;
3200 /* FIXME: we can do better than this for st and sc. */
3201 esym.asym.st = stGlobal;
3202 esym.asym.sc = scAbs;
3203 esym.asym.reserved = 0;
3204 esym.asym.index = indexNil;
3205 }
3206 else
3207 {
3208 ecoff_symbol_type *ecoff_sym_ptr;
3209
3210 ecoff_sym_ptr = (ecoff_symbol_type *) sym_ptr;
3211 if (ecoff_sym_ptr->local)
3212 abort ();
3213 ecoff_swap_ext_in (abfd, ecoff_sym_ptr->native.enative, &esym);
3214
3215 /* If we're producing an executable, move common symbols
3216 into bss. */
3217 if (relocateable == false)
3218 {
3219 if (esym.asym.sc == scCommon)
3220 esym.asym.sc = scBss;
3221 else if (esym.asym.sc == scSCommon)
3222 esym.asym.sc = scSBss;
3223 }
3224
3225 /* Adjust the FDR index for the symbol by that used for
3226 the input BFD. */
3227 esym.ifd += ecoff_data (bfd_asymbol_bfd (sym_ptr))->ifdbase;
3228 }
3229
3230 esym.asym.iss = symhdr->issExtMax;
3231
3232 if (bfd_is_com_section (sym_ptr->section)
3233 || sym_ptr->section == &bfd_und_section)
3234 esym.asym.value = sym_ptr->value;
3235 else
3236 esym.asym.value = (sym_ptr->value
3237 + sym_ptr->section->output_offset
3238 + sym_ptr->section->output_section->vma);
3239
3240 ecoff_swap_ext_out (abfd, &esym, external_ext + symhdr->iextMax);
3241
3242 ecoff_set_sym_index (sym_ptr, symhdr->iextMax);
3243
3244 ++symhdr->iextMax;
3245
3246 strcpy (ssext + symhdr->issExtMax, sym_ptr->name);
3247 symhdr->issExtMax += strlen (sym_ptr->name) + 1;
3248 }
3249 }
3250
3251 /* Adjust the counts so that structures are longword aligned. */
3252 symhdr->cbLine = (symhdr->cbLine + 3) &~ 3;
3253 symhdr->issMax = (symhdr->issMax + 3) &~ 3;
3254 symhdr->issExtMax = (symhdr->issExtMax + 3) &~ 3;
3255
3256 return true;
3257 }
3258 \f
3259 /* Set the architecture. The only architecture we support here is
3260 mips. We set the architecture anyhow, since many callers ignore
3261 the return value. */
3262
3263 static boolean
3264 ecoff_set_arch_mach (abfd, arch, machine)
3265 bfd *abfd;
3266 enum bfd_architecture arch;
3267 unsigned long machine;
3268 {
3269 bfd_default_set_arch_mach (abfd, arch, machine);
3270 return arch == bfd_arch_mips;
3271 }
3272
3273 /* Get the size of the section headers. We do not output the .scommon
3274 section which we created in ecoff_mkobject. */
3275
3276 static int
3277 ecoff_sizeof_headers (abfd, reloc)
3278 bfd *abfd;
3279 boolean reloc;
3280 {
3281 return FILHSZ + AOUTSZ + (abfd->section_count - 1) * SCNHSZ;
3282 }
3283
3284 /* Calculate the file position for each section, and set
3285 reloc_filepos. */
3286
3287 static void
3288 ecoff_compute_section_file_positions (abfd)
3289 bfd *abfd;
3290 {
3291 asection *current;
3292 file_ptr sofar;
3293 file_ptr old_sofar;
3294 boolean first_data;
3295
3296 if (bfd_get_start_address (abfd))
3297 abfd->flags |= EXEC_P;
3298
3299 sofar = ecoff_sizeof_headers (abfd, false);
3300
3301 first_data = true;
3302 for (current = abfd->sections;
3303 current != (asection *) NULL;
3304 current = current->next)
3305 {
3306 /* Only deal with sections which have contents */
3307 if (! (current->flags & SEC_HAS_CONTENTS)
3308 || strcmp (current->name, SCOMMON) == 0)
3309 continue;
3310
3311 /* On Ultrix, the data sections in an executable file must be
3312 aligned to a page boundary within the file. This does not
3313 affect the section size, though. FIXME: Does this work for
3314 other platforms? */
3315 if ((abfd->flags & EXEC_P) != 0
3316 && (abfd->flags & D_PAGED) != 0
3317 && first_data != false
3318 && (current->flags & SEC_CODE) == 0)
3319 {
3320 sofar = (sofar + ROUND_SIZE - 1) &~ (ROUND_SIZE - 1);
3321 first_data = false;
3322 }
3323
3324 /* Align the sections in the file to the same boundary on
3325 which they are aligned in virtual memory. */
3326 old_sofar = sofar;
3327 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3328
3329 current->filepos = sofar;
3330
3331 sofar += current->_raw_size;
3332
3333 /* make sure that this section is of the right size too */
3334 old_sofar = sofar;
3335 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3336 current->_raw_size += sofar - old_sofar;
3337 }
3338
3339 ecoff_data (abfd)->reloc_filepos = sofar;
3340 }
3341
3342 /* Set the contents of a section. */
3343
3344 static boolean
3345 ecoff_set_section_contents (abfd, section, location, offset, count)
3346 bfd *abfd;
3347 asection *section;
3348 PTR location;
3349 file_ptr offset;
3350 bfd_size_type count;
3351 {
3352 if (abfd->output_has_begun == false)
3353 ecoff_compute_section_file_positions (abfd);
3354
3355 bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET);
3356
3357 if (count != 0)
3358 return (bfd_write (location, 1, count, abfd) == count) ? true : false;
3359
3360 return true;
3361 }
3362
3363 /* Write out an ECOFF file. */
3364
3365 static boolean
3366 ecoff_write_object_contents (abfd)
3367 bfd *abfd;
3368 {
3369 asection *current;
3370 unsigned int count;
3371 file_ptr scn_base;
3372 file_ptr reloc_base;
3373 file_ptr sym_base;
3374 unsigned long reloc_size;
3375 unsigned long text_size;
3376 unsigned long text_start;
3377 unsigned long data_size;
3378 unsigned long data_start;
3379 unsigned long bss_size;
3380 struct internal_filehdr internal_f;
3381 struct internal_aouthdr internal_a;
3382 int i;
3383
3384 bfd_error = system_call_error;
3385
3386 if(abfd->output_has_begun == false)
3387 ecoff_compute_section_file_positions(abfd);
3388
3389 if (abfd->sections != (asection *) NULL)
3390 scn_base = abfd->sections->filepos;
3391 else
3392 scn_base = 0;
3393 reloc_base = ecoff_data (abfd)->reloc_filepos;
3394
3395 count = 1;
3396 reloc_size = 0;
3397 for (current = abfd->sections;
3398 current != (asection *)NULL;
3399 current = current->next)
3400 {
3401 if (strcmp (current->name, SCOMMON) == 0)
3402 continue;
3403 current->target_index = count;
3404 ++count;
3405 if (current->reloc_count != 0)
3406 {
3407 bfd_size_type relsize;
3408
3409 current->rel_filepos = reloc_base;
3410 relsize = current->reloc_count * RELSZ;
3411 reloc_size += relsize;
3412 reloc_base += relsize;
3413 }
3414 else
3415 current->rel_filepos = 0;
3416 }
3417
3418 sym_base = reloc_base + reloc_size;
3419
3420 /* At least on Ultrix, the symbol table of an executable file must
3421 be aligned to a page boundary. FIXME: Is this true on other
3422 platforms? */
3423 if ((abfd->flags & EXEC_P) != 0
3424 && (abfd->flags & D_PAGED) != 0)
3425 sym_base = (sym_base + ROUND_SIZE - 1) &~ (ROUND_SIZE - 1);
3426
3427 ecoff_data (abfd)->sym_filepos = sym_base;
3428
3429 if ((abfd->flags & D_PAGED) != 0)
3430 text_size = ecoff_sizeof_headers (abfd, false);
3431 else
3432 text_size = 0;
3433 text_start = 0;
3434 data_size = 0;
3435 data_start = 0;
3436 bss_size = 0;
3437
3438 /* Write section headers to the file. */
3439
3440 internal_f.f_nscns = 0;
3441 if (bfd_seek (abfd, (file_ptr) (FILHSZ + AOUTSZ), SEEK_SET) != 0)
3442 return false;
3443 for (current = abfd->sections;
3444 current != (asection *) NULL;
3445 current = current->next)
3446 {
3447 struct internal_scnhdr section;
3448 bfd_vma vma;
3449
3450 if (strcmp (current->name, SCOMMON) == 0)
3451 {
3452 BFD_ASSERT (bfd_get_section_size_before_reloc (current) == 0
3453 && current->reloc_count == 0);
3454 continue;
3455 }
3456
3457 ++internal_f.f_nscns;
3458
3459 strncpy (section.s_name, current->name, sizeof section.s_name);
3460
3461 /* FIXME: is this correct for shared libraries? I think it is
3462 but I have no platform to check. Ian Lance Taylor. */
3463 vma = bfd_get_section_vma (abfd, current);
3464 if (strcmp (current->name, _LIB) == 0)
3465 section.s_vaddr = 0;
3466 else
3467 section.s_vaddr = vma;
3468
3469 section.s_paddr = vma;
3470 section.s_size = bfd_get_section_size_before_reloc (current);
3471
3472 /* If this section has no size or is unloadable then the scnptr
3473 will be 0 too. */
3474 if (current->_raw_size == 0
3475 || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3476 section.s_scnptr = 0;
3477 else
3478 section.s_scnptr = current->filepos;
3479 section.s_relptr = current->rel_filepos;
3480
3481 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
3482 object file produced by the assembler is supposed to point to
3483 information about how much room is required by objects of
3484 various different sizes. I think this only matters if we
3485 want the linker to compute the best size to use, or
3486 something. I don't know what happens if the information is
3487 not present. */
3488 section.s_lnnoptr = 0;
3489
3490 section.s_nreloc = current->reloc_count;
3491 section.s_nlnno = 0;
3492 section.s_flags = ecoff_sec_to_styp_flags (current->name,
3493 current->flags);
3494
3495 {
3496 SCNHDR buff;
3497
3498 ecoff_swap_scnhdr_out (abfd, (PTR) &section, (PTR) &buff);
3499 if (bfd_write ((PTR) &buff, 1, SCNHSZ, abfd) != SCNHSZ)
3500 return false;
3501 }
3502
3503 if ((section.s_flags & STYP_TEXT) != 0)
3504 {
3505 text_size += bfd_get_section_size_before_reloc (current);
3506 if (text_start == 0 || text_start > vma)
3507 text_start = vma;
3508 }
3509 else if ((section.s_flags & STYP_RDATA) != 0
3510 || (section.s_flags & STYP_DATA) != 0
3511 || (section.s_flags & STYP_LIT8) != 0
3512 || (section.s_flags & STYP_LIT4) != 0
3513 || (section.s_flags & STYP_SDATA) != 0)
3514 {
3515 data_size += bfd_get_section_size_before_reloc (current);
3516 if (data_start == 0 || data_start > vma)
3517 data_start = vma;
3518 }
3519 else if ((section.s_flags & STYP_BSS) != 0
3520 || (section.s_flags & STYP_SBSS) != 0)
3521 bss_size += bfd_get_section_size_before_reloc (current);
3522 }
3523
3524 /* Set up the file header. */
3525
3526 if (abfd->xvec->header_byteorder_big_p != false)
3527 internal_f.f_magic = MIPS_MAGIC_BIG;
3528 else
3529 internal_f.f_magic = MIPS_MAGIC_LITTLE;
3530
3531 /*
3532 We will NOT put a fucking timestamp in the header here. Every time you
3533 put it back, I will come in and take it out again. I'm sorry. This
3534 field does not belong here. We fill it with a 0 so it compares the
3535 same but is not a reasonable time. -- gnu@cygnus.com
3536 */
3537 internal_f.f_timdat = 0;
3538
3539 if (bfd_get_symcount (abfd) != 0)
3540 {
3541 /* The ECOFF f_nsyms field is not actually the number of
3542 symbols, it's the size of symbolic information header. */
3543 internal_f.f_nsyms = sizeof (struct hdr_ext);
3544 internal_f.f_symptr = sym_base;
3545 }
3546 else
3547 {
3548 internal_f.f_nsyms = 0;
3549 internal_f.f_symptr = 0;
3550 }
3551
3552 internal_f.f_opthdr = AOUTSZ;
3553
3554 internal_f.f_flags = F_LNNO;
3555 if (reloc_size == 0)
3556 internal_f.f_flags |= F_RELFLG;
3557 if (bfd_get_symcount (abfd) == 0)
3558 internal_f.f_flags |= F_LSYMS;
3559 if (abfd->flags & EXEC_P)
3560 internal_f.f_flags |= F_EXEC;
3561
3562 if (! abfd->xvec->byteorder_big_p)
3563 internal_f.f_flags |= F_AR32WR;
3564 else
3565 internal_f.f_flags |= F_AR32W;
3566
3567 /* Set up the ``optional'' header. */
3568 if ((abfd->flags & D_PAGED) != 0)
3569 internal_a.magic = MIPS_AOUT_ZMAGIC;
3570 else
3571 internal_a.magic = MIPS_AOUT_OMAGIC;
3572
3573 /* FIXME: This is what Ultrix puts in, and it makes the Ultrix
3574 linker happy. But, is it right? */
3575 internal_a.vstamp = 0x20a;
3576
3577 /* At least on Ultrix, these have to be rounded to page boundaries.
3578 FIXME: Is this true on other platforms? */
3579 if ((abfd->flags & D_PAGED) != 0)
3580 {
3581 internal_a.tsize = (text_size + ROUND_SIZE - 1) &~ (ROUND_SIZE - 1);
3582 internal_a.text_start = text_start &~ (ROUND_SIZE - 1);
3583 internal_a.dsize = (data_size + ROUND_SIZE - 1) &~ (ROUND_SIZE - 1);
3584 internal_a.data_start = data_start &~ (ROUND_SIZE - 1);
3585 }
3586 else
3587 {
3588 internal_a.tsize = text_size;
3589 internal_a.text_start = text_start;
3590 internal_a.dsize = data_size;
3591 internal_a.data_start = data_start;
3592 }
3593
3594 /* On Ultrix, the initial portions of the .sbss and .bss segments
3595 are at the end of the data section. The bsize field in the
3596 optional header records how many bss bytes are required beyond
3597 those in the data section. The value is not rounded to a page
3598 boundary. */
3599 if (bss_size < internal_a.dsize - data_size)
3600 bss_size = 0;
3601 else
3602 bss_size -= internal_a.dsize - data_size;
3603 internal_a.bsize = bss_size;
3604 internal_a.bss_start = internal_a.data_start + internal_a.dsize;
3605
3606 internal_a.entry = bfd_get_start_address (abfd);
3607
3608 internal_a.gp_value = ecoff_data (abfd)->gp;
3609
3610 internal_a.gprmask = ecoff_data (abfd)->gprmask;
3611 for (i = 0; i < 4; i++)
3612 internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i];
3613
3614 /* Write out the file header and the optional header. */
3615
3616 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3617 return false;
3618
3619 {
3620 FILHDR buff;
3621 ecoff_swap_filehdr_out (abfd, (PTR) &internal_f, (PTR) &buff);
3622 if (bfd_write ((PTR) &buff, 1, FILHSZ, abfd) != FILHSZ)
3623 return false;
3624 }
3625
3626 {
3627 AOUTHDR buff;
3628
3629 ecoff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
3630 if (bfd_write ((PTR) &buff, 1, AOUTSZ, abfd) != AOUTSZ)
3631 return false;
3632 }
3633
3634 /* Write out the relocs. */
3635 for (current = abfd->sections;
3636 current != (asection *) NULL;
3637 current = current->next)
3638 {
3639 RELOC *buff;
3640 arelent **reloc_ptr_ptr;
3641 arelent **reloc_end;
3642 RELOC *out_ptr;
3643
3644 if (current->reloc_count == 0)
3645 continue;
3646
3647 buff = (RELOC *) bfd_alloc (abfd, current->reloc_count * RELSZ);
3648 if (buff == (RELOC *) NULL)
3649 {
3650 bfd_error = no_memory;
3651 return false;
3652 }
3653
3654 reloc_ptr_ptr = current->orelocation;
3655 reloc_end = reloc_ptr_ptr + current->reloc_count;
3656 out_ptr = buff;
3657 for (; reloc_ptr_ptr < reloc_end; reloc_ptr_ptr++, out_ptr++)
3658 {
3659 arelent *reloc;
3660 asymbol *sym;
3661 struct internal_reloc in;
3662
3663 memset (&in, 0, sizeof in);
3664
3665 reloc = *reloc_ptr_ptr;
3666 sym = *reloc->sym_ptr_ptr;
3667
3668 /* This must be an ECOFF reloc. */
3669 BFD_ASSERT (reloc->howto != (reloc_howto_type *) NULL
3670 && reloc->howto >= ecoff_howto_table
3671 && (reloc->howto
3672 < (ecoff_howto_table + ECOFF_HOWTO_COUNT)));
3673
3674 in.r_vaddr = reloc->address + bfd_get_section_vma (abfd, current);
3675 in.r_type = reloc->howto->type;
3676
3677 /* If this is a REFHI reloc, the next one must be a REFLO
3678 reloc for the same symbol. */
3679 BFD_ASSERT (in.r_type != ECOFF_R_REFHI
3680 || (reloc_ptr_ptr < reloc_end
3681 && (reloc_ptr_ptr[1]->howto
3682 != (reloc_howto_type *) NULL)
3683 && (reloc_ptr_ptr[1]->howto->type
3684 == ECOFF_R_REFLO)
3685 && (sym == *reloc_ptr_ptr[1]->sym_ptr_ptr)));
3686
3687 if ((sym->flags & BSF_SECTION_SYM) == 0)
3688 {
3689 in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr);
3690 in.r_extern = 1;
3691 }
3692 else
3693 {
3694 CONST char *name;
3695
3696 name = bfd_get_section_name (abfd, bfd_get_section (sym));
3697 if (strcmp (name, ".text") == 0)
3698 in.r_symndx = RELOC_SECTION_TEXT;
3699 else if (strcmp (name, ".rdata") == 0)
3700 in.r_symndx = RELOC_SECTION_RDATA;
3701 else if (strcmp (name, ".data") == 0)
3702 in.r_symndx = RELOC_SECTION_DATA;
3703 else if (strcmp (name, ".sdata") == 0)
3704 in.r_symndx = RELOC_SECTION_SDATA;
3705 else if (strcmp (name, ".sbss") == 0)
3706 in.r_symndx = RELOC_SECTION_SBSS;
3707 else if (strcmp (name, ".bss") == 0)
3708 in.r_symndx = RELOC_SECTION_BSS;
3709 else if (strcmp (name, ".init") == 0)
3710 in.r_symndx = RELOC_SECTION_INIT;
3711 else if (strcmp (name, ".lit8") == 0)
3712 in.r_symndx = RELOC_SECTION_LIT8;
3713 else if (strcmp (name, ".lit4") == 0)
3714 in.r_symndx = RELOC_SECTION_LIT4;
3715 else
3716 abort ();
3717 in.r_extern = 0;
3718 }
3719
3720 ecoff_swap_reloc_out (abfd, (PTR) &in, (PTR) out_ptr);
3721 }
3722
3723 if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0)
3724 return false;
3725 if (bfd_write ((PTR) buff, RELSZ, current->reloc_count, abfd)
3726 != RELSZ * current->reloc_count)
3727 return false;
3728 bfd_release (abfd, (PTR) buff);
3729 }
3730
3731 /* Write out the symbolic debugging information. */
3732 if (bfd_get_symcount (abfd) > 0)
3733 {
3734 HDRR *symhdr;
3735 unsigned long sym_offset;
3736 struct hdr_ext buff;
3737
3738 /* Set up the offsets in the symbolic header. */
3739 symhdr = &ecoff_data (abfd)->symbolic_header;
3740 sym_offset = ecoff_data (abfd)->sym_filepos + sizeof (struct hdr_ext);
3741
3742 #define SET(offset, size, ptr) \
3743 if (symhdr->size == 0) \
3744 symhdr->offset = 0; \
3745 else \
3746 symhdr->offset = (((char *) ecoff_data (abfd)->ptr \
3747 - (char *) ecoff_data (abfd)->raw_syments) \
3748 + sym_offset);
3749
3750 SET (cbLineOffset, cbLine, line);
3751 SET (cbDnOffset, idnMax, external_dnr);
3752 SET (cbPdOffset, ipdMax, external_pdr);
3753 SET (cbSymOffset, isymMax, external_sym);
3754 SET (cbOptOffset, ioptMax, external_opt);
3755 SET (cbAuxOffset, iauxMax, external_aux);
3756 SET (cbSsOffset, issMax, ss);
3757 SET (cbSsExtOffset, issExtMax, ssext);
3758 SET (cbFdOffset, ifdMax, external_fdr);
3759 SET (cbRfdOffset, crfd, external_rfd);
3760 SET (cbExtOffset, iextMax, external_ext);
3761 #undef SET
3762
3763 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos,
3764 SEEK_SET) != 0)
3765 return false;
3766 ecoff_swap_hdr_out (abfd, &ecoff_data (abfd)->symbolic_header, &buff);
3767 if (bfd_write ((PTR) &buff, 1, sizeof buff, abfd) != sizeof buff)
3768 return false;
3769 if (bfd_write ((PTR) ecoff_data (abfd)->raw_syments, 1,
3770 ecoff_data (abfd)->raw_size, abfd)
3771 != ecoff_data (abfd)->raw_size)
3772 return false;
3773 }
3774 else if ((abfd->flags & EXEC_P) != 0
3775 && (abfd->flags & D_PAGED) != 0)
3776 {
3777 char c;
3778
3779 /* A demand paged executable must occupy an even number of
3780 pages. */
3781 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
3782 SEEK_SET) != 0)
3783 return false;
3784 if (bfd_read (&c, 1, 1, abfd) == 0)
3785 c = 0;
3786 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
3787 SEEK_SET) != 0)
3788 return false;
3789 if (bfd_write (&c, 1, 1, abfd) != 1)
3790 return false;
3791 }
3792
3793 return true;
3794 }
3795 \f
3796 /* Archive handling. ECOFF uses what appears to be a unique type of
3797 archive header (which I call an armap). The byte ordering of the
3798 armap and the contents are encoded in the name of the armap itself.
3799 At least for now, we only support archives with the same byte
3800 ordering in the armap and the contents.
3801
3802 The first four bytes in the armap are the number of symbol
3803 definitions. This is always a power of two.
3804
3805 This is followed by the symbol definitions. Each symbol definition
3806 occupies 8 bytes. The first four bytes are the offset from the
3807 start of the armap strings to the null-terminated string naming
3808 this symbol. The second four bytes are the file offset to the
3809 archive member which defines this symbol. If the second four bytes
3810 are 0, then this is not actually a symbol definition, and it should
3811 be ignored.
3812
3813 The symbols are hashed into the armap with a closed hashing scheme.
3814 See the functions below for the details of the algorithm.
3815
3816 We could use the hash table when looking up symbols in a library.
3817 This would require a new BFD target entry point to replace the
3818 bfd_get_next_mapent function used by the linker.
3819
3820 After the symbol definitions comes four bytes holding the size of
3821 the string table, followed by the string table itself. */
3822
3823 /* The name of an archive headers looks like this:
3824 __________E[BL]E[BL]_ (with a trailing space).
3825 The trailing space is changed to an X if the archive is changed to
3826 indicate that the armap is out of date. */
3827
3828 #define ARMAP_BIG_ENDIAN 'B'
3829 #define ARMAP_LITTLE_ENDIAN 'L'
3830 #define ARMAP_MARKER 'E'
3831 #define ARMAP_START "__________"
3832 #define ARMAP_HEADER_MARKER_INDEX 10
3833 #define ARMAP_HEADER_ENDIAN_INDEX 11
3834 #define ARMAP_OBJECT_MARKER_INDEX 12
3835 #define ARMAP_OBJECT_ENDIAN_INDEX 13
3836 #define ARMAP_END_INDEX 14
3837 #define ARMAP_END "_ "
3838
3839 /* This is a magic number used in the hashing algorithm. */
3840 #define ARMAP_HASH_MAGIC 0x9dd68ab5
3841
3842 /* This returns the hash value to use for a string. It also sets
3843 *REHASH to the rehash adjustment if the first slot is taken. SIZE
3844 is the number of entries in the hash table, and HLOG is the log
3845 base 2 of SIZE. */
3846
3847 static unsigned int
3848 ecoff_armap_hash (s, rehash, size, hlog)
3849 CONST char *s;
3850 unsigned int *rehash;
3851 unsigned int size;
3852 unsigned int hlog;
3853 {
3854 unsigned int hash;
3855
3856 hash = *s++;
3857 while (*s != '\0')
3858 hash = ((hash >> 27) | (hash << 5)) + *s++;
3859 hash *= ARMAP_HASH_MAGIC;
3860 *rehash = (hash & (size - 1)) | 1;
3861 return hash >> (32 - hlog);
3862 }
3863
3864 /* Read in the armap. */
3865
3866 static boolean
3867 ecoff_slurp_armap (abfd)
3868 bfd *abfd;
3869 {
3870 char nextname[17];
3871 unsigned int i;
3872 struct areltdata *mapdata;
3873 bfd_size_type parsed_size;
3874 char *raw_armap;
3875 struct artdata *ardata;
3876 unsigned int count;
3877 char *raw_ptr;
3878 struct symdef *symdef_ptr;
3879 char *stringbase;
3880
3881 /* Get the name of the first element. */
3882 i = bfd_read ((PTR) nextname, 1, 16, abfd);
3883 if (i == 0)
3884 return true;
3885 if (i != 16)
3886 return false;
3887
3888 bfd_seek (abfd, (file_ptr) -16, SEEK_CUR);
3889
3890 /* See if the first element is an armap. */
3891 if (strncmp (nextname, ARMAP_START, sizeof ARMAP_START - 1) != 0
3892 || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER
3893 || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
3894 && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
3895 || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER
3896 || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
3897 && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
3898 || strncmp (nextname + ARMAP_END_INDEX,
3899 ARMAP_END, sizeof ARMAP_END - 1) != 0)
3900 {
3901 bfd_has_map (abfd) = false;
3902 return true;
3903 }
3904
3905 /* Make sure we have the right byte ordering. */
3906 if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
3907 ^ (abfd->xvec->header_byteorder_big_p != false))
3908 || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
3909 ^ (abfd->xvec->byteorder_big_p != false)))
3910 {
3911 bfd_error = wrong_format;
3912 return false;
3913 }
3914
3915 /* Read in the armap. */
3916 ardata = bfd_ardata (abfd);
3917 mapdata = snarf_ar_hdr (abfd);
3918 if (mapdata == (struct areltdata *) NULL)
3919 return false;
3920 parsed_size = mapdata->parsed_size;
3921 bfd_release (abfd, (PTR) mapdata);
3922
3923 raw_armap = (char *) bfd_alloc (abfd, parsed_size);
3924 if (raw_armap == (char *) NULL)
3925 {
3926 bfd_error = no_memory;
3927 return false;
3928 }
3929
3930 if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size)
3931 {
3932 bfd_error = malformed_archive;
3933 bfd_release (abfd, (PTR) raw_armap);
3934 return false;
3935 }
3936
3937 count = bfd_h_get_32 (abfd, (PTR) raw_armap);
3938
3939 ardata->symdef_count = 0;
3940 ardata->cache = (struct ar_cache *) NULL;
3941
3942 /* Hack: overlay the symdefs on top of the raw archive data. This
3943 is the way do_slurp_bsd_armap works. */
3944 raw_ptr = raw_armap + LONG_SIZE;
3945 symdef_ptr = (struct symdef *) raw_ptr;
3946 ardata->symdefs = (carsym *) symdef_ptr;
3947 stringbase = raw_ptr + count * (2 * LONG_SIZE) + LONG_SIZE;
3948
3949 #ifdef CHECK_ARMAP_HASH
3950 {
3951 unsigned int hlog;
3952
3953 /* Double check that I have the hashing algorithm right by making
3954 sure that every symbol can be looked up successfully. */
3955 hlog = 0;
3956 for (i = 1; i < count; i <<= 1)
3957 hlog++;
3958 BFD_ASSERT (i == count);
3959
3960 for (i = 0; i < count; i++, raw_ptr += 2 * LONG_SIZE)
3961 {
3962 unsigned int name_offset, file_offset;
3963 unsigned int hash, rehash, srch;
3964
3965 name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
3966 file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + LONG_SIZE));
3967 if (file_offset == 0)
3968 continue;
3969 hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count,
3970 hlog);
3971 if (hash == i)
3972 continue;
3973
3974 /* See if we can rehash to this location. */
3975 for (srch = (hash + rehash) & (count - 1);
3976 srch != hash && srch != i;
3977 srch = (srch + rehash) & (count - 1))
3978 BFD_ASSERT (bfd_h_get_32 (abfd,
3979 (PTR) (raw_armap
3980 + LONG_SIZE
3981 + (srch * 2 * LONG_SIZE)
3982 + LONG_SIZE))
3983 != 0);
3984 BFD_ASSERT (srch == i);
3985 }
3986 }
3987
3988 raw_ptr = raw_armap + LONG_SIZE;
3989 #endif /* CHECK_ARMAP_HASH */
3990
3991 for (i = 0; i < count; i++, raw_ptr += 2 * LONG_SIZE)
3992 {
3993 unsigned int name_offset, file_offset;
3994
3995 name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
3996 file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + LONG_SIZE));
3997 if (file_offset == 0)
3998 continue;
3999 symdef_ptr->s.name = stringbase + name_offset;
4000 symdef_ptr->file_offset = file_offset;
4001 ++symdef_ptr;
4002 ++ardata->symdef_count;
4003 }
4004
4005 ardata->first_file_filepos = bfd_tell (abfd);
4006 /* Pad to an even boundary. */
4007 ardata->first_file_filepos += ardata->first_file_filepos % 2;
4008
4009 bfd_has_map (abfd) = true;
4010
4011 return true;
4012 }
4013
4014 /* Write out an armap. */
4015
4016 static boolean
4017 ecoff_write_armap (abfd, elength, map, orl_count, stridx)
4018 bfd *abfd;
4019 unsigned int elength;
4020 struct orl *map;
4021 unsigned int orl_count;
4022 int stridx;
4023 {
4024 unsigned int hashsize, hashlog;
4025 unsigned int symdefsize;
4026 int padit;
4027 unsigned int stringsize;
4028 unsigned int mapsize;
4029 file_ptr firstreal;
4030 struct ar_hdr hdr;
4031 struct stat statbuf;
4032 unsigned int i;
4033 bfd_byte temp[LONG_SIZE];
4034 bfd_byte *hashtable;
4035 bfd *current;
4036 bfd *last_elt;
4037
4038 /* Ultrix appears to use as a hash table size the least power of two
4039 greater than twice the number of entries. */
4040 for (hashlog = 0; (1 << hashlog) <= 2 * orl_count; hashlog++)
4041 ;
4042 hashsize = 1 << hashlog;
4043
4044 symdefsize = hashsize * 2 * LONG_SIZE;
4045 padit = stridx % 2;
4046 stringsize = stridx + padit;
4047
4048 /* Include 8 bytes to store symdefsize and stringsize in output. */
4049 mapsize = LONG_SIZE + symdefsize + stringsize + LONG_SIZE;
4050
4051 firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength;
4052
4053 memset ((PTR) &hdr, 0, sizeof hdr);
4054
4055 /* Work out the ECOFF armap name. */
4056 strcpy (hdr.ar_name, ARMAP_START);
4057 hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER;
4058 hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] =
4059 (abfd->xvec->header_byteorder_big_p
4060 ? ARMAP_BIG_ENDIAN
4061 : ARMAP_LITTLE_ENDIAN);
4062 hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER;
4063 hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] =
4064 abfd->xvec->byteorder_big_p ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN;
4065 memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1);
4066
4067 /* Write the timestamp of the archive header to be just a little bit
4068 later than the timestamp of the file, otherwise the linker will
4069 complain that the index is out of date. Actually, the Ultrix
4070 linker just checks the archive name; the GNU linker may check the
4071 date. */
4072 stat (abfd->filename, &statbuf);
4073 sprintf (hdr.ar_date, "%ld", (long) (statbuf.st_mtime + 60));
4074
4075 /* The DECstation uses zeroes for the uid, gid and mode of the
4076 armap. */
4077 hdr.ar_uid[0] = '0';
4078 hdr.ar_gid[0] = '0';
4079 hdr.ar_mode[0] = '0';
4080
4081 sprintf (hdr.ar_size, "%-10d", (int) mapsize);
4082
4083 hdr.ar_fmag[0] = '`';
4084 hdr.ar_fmag[1] = '\n';
4085
4086 /* Turn all null bytes in the header into spaces. */
4087 for (i = 0; i < sizeof (struct ar_hdr); i++)
4088 if (((char *)(&hdr))[i] == '\0')
4089 (((char *)(&hdr))[i]) = ' ';
4090
4091 if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), abfd)
4092 != sizeof (struct ar_hdr))
4093 return false;
4094
4095 bfd_h_put_32 (abfd, hashsize, temp);
4096 if (bfd_write (temp, 1, LONG_SIZE, abfd) != LONG_SIZE)
4097 return false;
4098
4099 hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize);
4100
4101 current = abfd->archive_head;
4102 last_elt = current;
4103 for (i = 0; i < orl_count; i++)
4104 {
4105 unsigned int hash, rehash;
4106
4107 /* Advance firstreal to the file position of this archive
4108 element. */
4109 if (((bfd *) map[i].pos) != last_elt)
4110 {
4111 do
4112 {
4113 firstreal += arelt_size (current) + sizeof (struct ar_hdr);
4114 firstreal += firstreal % 2;
4115 current = current->next;
4116 }
4117 while (current != (bfd *) map[i].pos);
4118 }
4119
4120 last_elt = current;
4121
4122 hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog);
4123 if (bfd_h_get_32 (abfd, (PTR) (hashtable
4124 + (hash * 2 * LONG_SIZE)
4125 + LONG_SIZE))
4126 != 0)
4127 {
4128 unsigned int srch;
4129
4130 /* The desired slot is already taken. */
4131 for (srch = (hash + rehash) & (hashsize - 1);
4132 srch != hash;
4133 srch = (srch + rehash) & (hashsize - 1))
4134 if (bfd_h_get_32 (abfd, (PTR) (hashtable
4135 + (srch * 2 * LONG_SIZE)
4136 + LONG_SIZE))
4137 == 0)
4138 break;
4139
4140 BFD_ASSERT (srch != hash);
4141
4142 hash = srch;
4143 }
4144
4145 bfd_h_put_32 (abfd, map[i].namidx,
4146 (PTR) (hashtable + hash * 2 * LONG_SIZE));
4147 bfd_h_put_32 (abfd, firstreal,
4148 (PTR) (hashtable + hash * 2 * LONG_SIZE + LONG_SIZE));
4149 }
4150
4151 if (bfd_write (hashtable, 1, symdefsize, abfd) != symdefsize)
4152 return false;
4153
4154 bfd_release (abfd, hashtable);
4155
4156 /* Now write the strings. */
4157 bfd_h_put_32 (abfd, stringsize, temp);
4158 if (bfd_write (temp, 1, LONG_SIZE, abfd) != LONG_SIZE)
4159 return false;
4160 for (i = 0; i < orl_count; i++)
4161 {
4162 bfd_size_type len;
4163
4164 len = strlen (*map[i].name) + 1;
4165 if (bfd_write ((PTR) (*map[i].name), 1, len, abfd) != len)
4166 return false;
4167 }
4168
4169 /* The spec sez this should be a newline. But in order to be
4170 bug-compatible for DECstation ar we use a null. */
4171 if (padit)
4172 {
4173 if (bfd_write ("\0", 1, 1, abfd) != 1)
4174 return false;
4175 }
4176
4177 return true;
4178 }
4179
4180 /* We just use the generic extended name support. This is a GNU
4181 extension. */
4182 #define ecoff_slurp_extended_name_table _bfd_slurp_extended_name_table
4183
4184 /* See whether this BFD is an archive. If it is, read in the armap
4185 and the extended name table. */
4186
4187 static bfd_target *
4188 ecoff_archive_p (abfd)
4189 bfd *abfd;
4190 {
4191 char armag[SARMAG + 1];
4192
4193 if (bfd_read ((PTR) armag, 1, SARMAG, abfd) != SARMAG
4194 || strncmp (armag, ARMAG, SARMAG) != 0)
4195 {
4196 bfd_error = wrong_format;
4197 return (bfd_target *) NULL;
4198 }
4199
4200 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
4201 involves a cast, we can't do it as the left operand of
4202 assignment. */
4203 abfd->tdata.aout_ar_data =
4204 (struct artdata *) bfd_zalloc (abfd, sizeof (struct artdata));
4205
4206 if (bfd_ardata (abfd) == (struct artdata *) NULL)
4207 {
4208 bfd_error = no_memory;
4209 return (bfd_target *) NULL;
4210 }
4211
4212 bfd_ardata (abfd)->first_file_filepos = SARMAG;
4213
4214 if (ecoff_slurp_armap (abfd) == false
4215 || ecoff_slurp_extended_name_table (abfd) == false)
4216 {
4217 bfd_release (abfd, bfd_ardata (abfd));
4218 abfd->tdata.aout_ar_data = (struct artdata *) NULL;
4219 return (bfd_target *) NULL;
4220 }
4221
4222 return abfd->xvec;
4223 }
4224 \f
4225 #ifdef HOST_IRIX4
4226
4227 #include <core.out.h>
4228
4229 struct sgi_core_struct
4230 {
4231 int sig;
4232 char cmd[CORE_NAMESIZE];
4233 };
4234
4235 #define core_hdr(bfd) ((bfd)->tdata.sgi_core_data)
4236 #define core_signal(bfd) (core_hdr(bfd)->sig)
4237 #define core_command(bfd) (core_hdr(bfd)->cmd)
4238
4239 static asection *
4240 make_bfd_asection (abfd, name, flags, _raw_size, vma, filepos)
4241 bfd *abfd;
4242 CONST char *name;
4243 flagword flags;
4244 bfd_size_type _raw_size;
4245 bfd_vma vma;
4246 file_ptr filepos;
4247 {
4248 asection *asect;
4249
4250 asect = bfd_make_section (abfd, name);
4251 if (!asect)
4252 return NULL;
4253
4254 asect->flags = flags;
4255 asect->_raw_size = _raw_size;
4256 asect->vma = vma;
4257 asect->filepos = filepos;
4258 asect->alignment_power = 4;
4259
4260 return asect;
4261 }
4262
4263 static bfd_target *
4264 ecoff_core_file_p (abfd)
4265 bfd *abfd;
4266 {
4267 int val;
4268 int i;
4269 char *secname;
4270 struct coreout coreout;
4271 struct idesc *idg, *idf, *ids;
4272
4273 val = bfd_read ((PTR)&coreout, 1, sizeof coreout, abfd);
4274 if (val != sizeof coreout)
4275 return 0;
4276
4277 if (coreout.c_magic != CORE_MAGIC
4278 || coreout.c_version != CORE_VERSION1)
4279 return 0;
4280
4281 core_hdr (abfd) = (struct sgi_core_struct *) bfd_zalloc (abfd, sizeof (struct sgi_core_struct));
4282 if (!core_hdr (abfd))
4283 return NULL;
4284
4285 strncpy (core_command (abfd), coreout.c_name, CORE_NAMESIZE);
4286 core_signal (abfd) = coreout.c_sigcause;
4287
4288 bfd_seek (abfd, coreout.c_vmapoffset, SEEK_SET);
4289
4290 for (i = 0; i < coreout.c_nvmap; i++)
4291 {
4292 struct vmap vmap;
4293
4294 val = bfd_read ((PTR)&vmap, 1, sizeof vmap, abfd);
4295 if (val != sizeof vmap)
4296 break;
4297
4298 switch (vmap.v_type)
4299 {
4300 case VDATA:
4301 secname = ".data";
4302 break;
4303 case VSTACK:
4304 secname = ".stack";
4305 break;
4306 default:
4307 continue;
4308 }
4309
4310 if (!make_bfd_asection (abfd, secname,
4311 SEC_ALLOC+SEC_LOAD+SEC_HAS_CONTENTS,
4312 vmap.v_len,
4313 vmap.v_vaddr,
4314 vmap.v_offset,
4315 2))
4316 return NULL;
4317 }
4318
4319 /* Make sure that the regs are contiguous within the core file. */
4320
4321 idg = &coreout.c_idesc[I_GPREGS];
4322 idf = &coreout.c_idesc[I_FPREGS];
4323 ids = &coreout.c_idesc[I_SPECREGS];
4324
4325 if (idg->i_offset + idg->i_len != idf->i_offset
4326 || idf->i_offset + idf->i_len != ids->i_offset)
4327 return 0; /* Can't deal with non-contig regs */
4328
4329 bfd_seek (abfd, idg->i_offset, SEEK_SET);
4330
4331 make_bfd_asection (abfd, ".reg",
4332 SEC_ALLOC+SEC_HAS_CONTENTS,
4333 idg->i_len + idf->i_len + ids->i_len,
4334 0,
4335 idg->i_offset);
4336
4337 /* OK, we believe you. You're a core file (sure, sure). */
4338
4339 return abfd->xvec;
4340 }
4341
4342 static char *
4343 ecoff_core_file_failing_command (abfd)
4344 bfd *abfd;
4345 {
4346 return core_command (abfd);
4347 }
4348
4349 static int
4350 ecoff_core_file_failing_signal (abfd)
4351 bfd *abfd;
4352 {
4353 return core_signal (abfd);
4354 }
4355
4356 static boolean
4357 ecoff_core_file_matches_executable_p (core_bfd, exec_bfd)
4358 bfd *core_bfd, *exec_bfd;
4359 {
4360 return true; /* XXX - FIXME */
4361 }
4362 #else /* not def HOST_IRIX4 */
4363 #define ecoff_core_file_p _bfd_dummy_target
4364 #define ecoff_core_file_failing_command _bfd_dummy_core_file_failing_command
4365 #define ecoff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
4366 #define ecoff_core_file_matches_executable_p \
4367 _bfd_dummy_core_file_matches_executable_p
4368 #endif
4369 \f
4370 /* This is the COFF backend structure. The backend_data field of the
4371 bfd_target structure is set to this. The section reading code in
4372 coffgen.c uses this structure. */
4373
4374 static CONST bfd_coff_backend_data bfd_ecoff_std_swap_table = {
4375 (void (*) PARAMS ((bfd *,PTR,int,int,PTR))) bfd_void, /* aux_in */
4376 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
4377 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
4378 (unsigned (*) PARAMS ((bfd *,PTR,int,int,PTR))) bfd_void, /* aux_out */
4379 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
4380 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
4381 ecoff_swap_reloc_out, ecoff_swap_filehdr_out, ecoff_swap_aouthdr_out,
4382 ecoff_swap_scnhdr_out,
4383 FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, true,
4384 ecoff_swap_filehdr_in, ecoff_swap_aouthdr_in, ecoff_swap_scnhdr_in,
4385 ecoff_bad_format_hook, ecoff_set_arch_mach_hook, ecoff_mkobject_hook,
4386 ecoff_styp_to_sec_flags, ecoff_make_section_hook, ecoff_set_alignment_hook,
4387 ecoff_slurp_symbol_table
4388 };
4389
4390 /* get_lineno could be written for ECOFF, but it would currently only
4391 be useful for linking ECOFF and COFF files together, which doesn't
4392 seem too likely. */
4393 #define ecoff_get_lineno \
4394 ((alent *(*) PARAMS ((bfd *, asymbol *))) bfd_nullvoidptr)
4395
4396 /* These bfd_target functions are defined in other files. */
4397
4398 #define ecoff_truncate_arname bfd_dont_truncate_arname
4399 #define ecoff_openr_next_archived_file bfd_generic_openr_next_archived_file
4400 #define ecoff_generic_stat_arch_elt bfd_generic_stat_arch_elt
4401 #define ecoff_get_section_contents bfd_generic_get_section_contents
4402 #define ecoff_get_reloc_upper_bound coff_get_reloc_upper_bound
4403 #define ecoff_close_and_cleanup bfd_generic_close_and_cleanup
4404 #define ecoff_bfd_debug_info_start bfd_void
4405 #define ecoff_bfd_debug_info_end bfd_void
4406 #define ecoff_bfd_debug_info_accumulate \
4407 ((void (*) PARAMS ((bfd *, struct sec *))) bfd_void)
4408 #define ecoff_bfd_get_relocated_section_contents \
4409 bfd_generic_get_relocated_section_contents
4410 #define ecoff_bfd_relax_section bfd_generic_relax_section
4411 #define ecoff_bfd_make_debug_symbol \
4412 ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
4413
4414 bfd_target ecoff_little_vec =
4415 {
4416 "ecoff-littlemips", /* name */
4417 bfd_target_ecoff_flavour,
4418 false, /* data byte order is little */
4419 false, /* header byte order is little */
4420
4421 (HAS_RELOC | EXEC_P | /* object flags */
4422 HAS_LINENO | HAS_DEBUG |
4423 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
4424
4425 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* sect
4426 flags */
4427 0, /* leading underscore */
4428 ' ', /* ar_pad_char */
4429 15, /* ar_max_namelen */
4430 4, /* minimum alignment power */
4431 _do_getl64, _do_getl_signed_64, _do_putl64,
4432 _do_getl32, _do_getl_signed_32, _do_putl32,
4433 _do_getl16, _do_getl_signed_16, _do_putl16, /* data */
4434 _do_getl64, _do_getl_signed_64, _do_putl64,
4435 _do_getl32, _do_getl_signed_32, _do_putl32,
4436 _do_getl16, _do_getl_signed_16, _do_putl16, /* hdrs */
4437
4438 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
4439 ecoff_archive_p, _bfd_dummy_target},
4440 {bfd_false, ecoff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
4441 bfd_false},
4442 {bfd_false, ecoff_write_object_contents, /* bfd_write_contents */
4443 _bfd_write_archive_contents, bfd_false},
4444 JUMP_TABLE (ecoff),
4445 (PTR) &bfd_ecoff_std_swap_table
4446 };
4447
4448 bfd_target ecoff_big_vec =
4449 {
4450 "ecoff-bigmips", /* name */
4451 bfd_target_ecoff_flavour,
4452 true, /* data byte order is big */
4453 true, /* header byte order is big */
4454
4455 (HAS_RELOC | EXEC_P | /* object flags */
4456 HAS_LINENO | HAS_DEBUG |
4457 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
4458
4459 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* sect flags */
4460 0, /* leading underscore */
4461 ' ', /* ar_pad_char */
4462 15, /* ar_max_namelen */
4463 4, /* minimum alignment power */
4464 _do_getb64, _do_getb_signed_64, _do_putb64,
4465 _do_getb32, _do_getb_signed_32, _do_putb32,
4466 _do_getb16, _do_getb_signed_16, _do_putb16,
4467 _do_getb64, _do_getb_signed_64, _do_putb64,
4468 _do_getb32, _do_getb_signed_32, _do_putb32,
4469 _do_getb16, _do_getb_signed_16, _do_putb16,
4470 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
4471 ecoff_archive_p, ecoff_core_file_p},
4472 {bfd_false, ecoff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
4473 bfd_false},
4474 {bfd_false, ecoff_write_object_contents, /* bfd_write_contents */
4475 _bfd_write_archive_contents, bfd_false},
4476 JUMP_TABLE(ecoff),
4477 (PTR) &bfd_ecoff_std_swap_table
4478 /* Note that there is another bfd_target just above this one. If
4479 you are adding initializers here, you should be adding them there
4480 as well. */
4481 };