* config/tc-dlx.h (tc_coff_symbol_emit_hook): Delete.
[binutils.git] / bfd / ecoff.c
blob75e1cc2a398d6b092b827bfa106407c41f2e633c
1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright 1990, 1991, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
4 Original version by Per Bothner.
5 Full support added by Ian Lance Taylor, ian@cygnus.com.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include "bfdlink.h"
26 #include "libbfd.h"
27 #include "aout/ar.h"
28 #include "aout/ranlib.h"
29 #include "aout/stab_gnu.h"
31 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
32 some other stuff which we don't want and which conflicts with stuff
33 we do want. */
34 #include "libaout.h"
35 #include "aout/aout64.h"
36 #undef N_ABS
37 #undef exec_hdr
38 #undef obj_sym_filepos
40 #include "coff/internal.h"
41 #include "coff/sym.h"
42 #include "coff/symconst.h"
43 #include "coff/ecoff.h"
44 #include "libcoff.h"
45 #include "libecoff.h"
46 #include "libiberty.h"
48 #define streq(a, b) (strcmp ((a), (b)) == 0)
49 #define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0)
52 /* This stuff is somewhat copied from coffcode.h. */
53 static asection bfd_debug_section =
55 /* name, id, index, next, prev, flags, user_set_vma, */
56 "*DEBUG*", 0, 0, NULL, NULL, 0, 0,
57 /* linker_mark, linker_has_input, gc_mark, gc_mark_from_eh, */
58 0, 0, 1, 0,
59 /* segment_mark, sec_info_type, use_rela_p, has_tls_reloc, */
60 0, 0, 0, 0,
61 /* has_gp_reloc, need_finalize_relax, reloc_done, */
62 0, 0, 0,
63 /* vma, lma, size, rawsize, */
64 0, 0, 0, 0,
65 /* output_offset, output_section, alignment_power, */
66 0, NULL, 0,
67 /* relocation, orelocation, reloc_count, filepos, rel_filepos, */
68 NULL, NULL, 0, 0, 0,
69 /* line_filepos, userdata, contents, lineno, lineno_count, */
70 0, NULL, NULL, NULL, 0,
71 /* entsize, kept_section, moving_line_filepos, */
72 0, NULL, 0,
73 /* target_index, used_by_bfd, constructor_chain, owner, */
74 0, NULL, NULL, NULL,
75 /* symbol, */
76 NULL,
77 /* symbol_ptr_ptr, */
78 NULL,
79 /* map_head, map_tail */
80 { NULL }, { NULL }
83 /* Create an ECOFF object. */
85 bfd_boolean
86 _bfd_ecoff_mkobject (bfd *abfd)
88 bfd_size_type amt = sizeof (ecoff_data_type);
90 abfd->tdata.ecoff_obj_data = bfd_zalloc (abfd, amt);
91 if (abfd->tdata.ecoff_obj_data == NULL)
92 return FALSE;
94 return TRUE;
97 /* This is a hook called by coff_real_object_p to create any backend
98 specific information. */
100 void *
101 _bfd_ecoff_mkobject_hook (bfd *abfd, void * filehdr, void * aouthdr)
103 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
104 struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr;
105 ecoff_data_type *ecoff;
107 if (! _bfd_ecoff_mkobject (abfd))
108 return NULL;
110 ecoff = ecoff_data (abfd);
111 ecoff->gp_size = 8;
112 ecoff->sym_filepos = internal_f->f_symptr;
114 if (internal_a != NULL)
116 int i;
118 ecoff->text_start = internal_a->text_start;
119 ecoff->text_end = internal_a->text_start + internal_a->tsize;
120 ecoff->gp = internal_a->gp_value;
121 ecoff->gprmask = internal_a->gprmask;
122 for (i = 0; i < 4; i++)
123 ecoff->cprmask[i] = internal_a->cprmask[i];
124 ecoff->fprmask = internal_a->fprmask;
125 if (internal_a->magic == ECOFF_AOUT_ZMAGIC)
126 abfd->flags |= D_PAGED;
127 else
128 abfd->flags &=~ D_PAGED;
131 /* It turns out that no special action is required by the MIPS or
132 Alpha ECOFF backends. They have different information in the
133 a.out header, but we just copy it all (e.g., gprmask, cprmask and
134 fprmask) and let the swapping routines ensure that only relevant
135 information is written out. */
137 return (void *) ecoff;
140 /* Initialize a new section. */
142 bfd_boolean
143 _bfd_ecoff_new_section_hook (bfd *abfd ATTRIBUTE_UNUSED,
144 asection *section)
146 unsigned int i;
147 static struct
149 const char * name;
150 flagword flags;
152 section_flags [] =
154 { _TEXT, SEC_ALLOC | SEC_CODE | SEC_LOAD },
155 { _INIT, SEC_ALLOC | SEC_CODE | SEC_LOAD },
156 { _FINI, SEC_ALLOC | SEC_CODE | SEC_LOAD },
157 { _DATA, SEC_ALLOC | SEC_DATA | SEC_LOAD },
158 { _SDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD },
159 { _RDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
160 { _LIT8, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
161 { _LIT4, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
162 { _RCONST, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
163 { _PDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
164 { _BSS, SEC_ALLOC},
165 { _SBSS, SEC_ALLOC},
166 /* An Irix 4 shared libary. */
167 { _LIB, SEC_COFF_SHARED_LIBRARY}
170 section->alignment_power = 4;
172 for (i = 0; i < ARRAY_SIZE (section_flags); i++)
173 if (streq (section->name, section_flags[i].name))
175 section->flags |= section_flags[i].flags;
176 break;
180 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
181 uncertain about .init on some systems and I don't know how shared
182 libraries work. */
184 return TRUE;
187 /* Determine the machine architecture and type. This is called from
188 the generic COFF routines. It is the inverse of ecoff_get_magic,
189 below. This could be an ECOFF backend routine, with one version
190 for each target, but there aren't all that many ECOFF targets. */
192 bfd_boolean
193 _bfd_ecoff_set_arch_mach_hook (bfd *abfd, void * filehdr)
195 struct internal_filehdr *internal_f = filehdr;
196 enum bfd_architecture arch;
197 unsigned long mach;
199 switch (internal_f->f_magic)
201 case MIPS_MAGIC_1:
202 case MIPS_MAGIC_LITTLE:
203 case MIPS_MAGIC_BIG:
204 arch = bfd_arch_mips;
205 mach = bfd_mach_mips3000;
206 break;
208 case MIPS_MAGIC_LITTLE2:
209 case MIPS_MAGIC_BIG2:
210 /* MIPS ISA level 2: the r6000. */
211 arch = bfd_arch_mips;
212 mach = bfd_mach_mips6000;
213 break;
215 case MIPS_MAGIC_LITTLE3:
216 case MIPS_MAGIC_BIG3:
217 /* MIPS ISA level 3: the r4000. */
218 arch = bfd_arch_mips;
219 mach = bfd_mach_mips4000;
220 break;
222 case ALPHA_MAGIC:
223 arch = bfd_arch_alpha;
224 mach = 0;
225 break;
227 default:
228 arch = bfd_arch_obscure;
229 mach = 0;
230 break;
233 return bfd_default_set_arch_mach (abfd, arch, mach);
236 /* Get the magic number to use based on the architecture and machine.
237 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
239 static int
240 ecoff_get_magic (bfd *abfd)
242 int big, little;
244 switch (bfd_get_arch (abfd))
246 case bfd_arch_mips:
247 switch (bfd_get_mach (abfd))
249 default:
250 case 0:
251 case bfd_mach_mips3000:
252 big = MIPS_MAGIC_BIG;
253 little = MIPS_MAGIC_LITTLE;
254 break;
256 case bfd_mach_mips6000:
257 big = MIPS_MAGIC_BIG2;
258 little = MIPS_MAGIC_LITTLE2;
259 break;
261 case bfd_mach_mips4000:
262 big = MIPS_MAGIC_BIG3;
263 little = MIPS_MAGIC_LITTLE3;
264 break;
267 return bfd_big_endian (abfd) ? big : little;
269 case bfd_arch_alpha:
270 return ALPHA_MAGIC;
272 default:
273 abort ();
274 return 0;
278 /* Get the section s_flags to use for a section. */
280 static long
281 ecoff_sec_to_styp_flags (const char *name, flagword flags)
283 unsigned int i;
284 static struct
286 const char * name;
287 long flags;
289 styp_flags [] =
291 { _TEXT, STYP_TEXT },
292 { _DATA, STYP_DATA },
293 { _SDATA, STYP_SDATA },
294 { _RDATA, STYP_RDATA },
295 { _LITA, STYP_LITA },
296 { _LIT8, STYP_LIT8 },
297 { _LIT4, STYP_LIT4 },
298 { _BSS, STYP_BSS },
299 { _SBSS, STYP_SBSS },
300 { _INIT, STYP_ECOFF_INIT },
301 { _FINI, STYP_ECOFF_FINI },
302 { _PDATA, STYP_PDATA },
303 { _XDATA, STYP_XDATA },
304 { _LIB, STYP_ECOFF_LIB },
305 { _GOT, STYP_GOT },
306 { _HASH, STYP_HASH },
307 { _DYNAMIC, STYP_DYNAMIC },
308 { _LIBLIST, STYP_LIBLIST },
309 { _RELDYN, STYP_RELDYN },
310 { _CONFLIC, STYP_CONFLIC },
311 { _DYNSTR, STYP_DYNSTR },
312 { _DYNSYM, STYP_DYNSYM },
313 { _RCONST, STYP_RCONST }
315 long styp = 0;
317 for (i = 0; i < ARRAY_SIZE (styp_flags); i++)
318 if (streq (name, styp_flags[i].name))
320 styp = styp_flags[i].flags;
321 break;
324 if (styp == 0)
326 if (streq (name, _COMMENT))
328 styp = STYP_COMMENT;
329 flags &=~ SEC_NEVER_LOAD;
331 else if (flags & SEC_CODE)
332 styp = STYP_TEXT;
333 else if (flags & SEC_DATA)
334 styp = STYP_DATA;
335 else if (flags & SEC_READONLY)
336 styp = STYP_RDATA;
337 else if (flags & SEC_LOAD)
338 styp = STYP_REG;
339 else
340 styp = STYP_BSS;
343 if (flags & SEC_NEVER_LOAD)
344 styp |= STYP_NOLOAD;
346 return styp;
349 /* Get the BFD flags to use for a section. */
351 bfd_boolean
352 _bfd_ecoff_styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED,
353 void * hdr,
354 const char *name ATTRIBUTE_UNUSED,
355 asection *section ATTRIBUTE_UNUSED,
356 flagword * flags_ptr)
358 struct internal_scnhdr *internal_s = hdr;
359 long styp_flags = internal_s->s_flags;
360 flagword sec_flags = 0;
362 if (styp_flags & STYP_NOLOAD)
363 sec_flags |= SEC_NEVER_LOAD;
365 /* For 386 COFF, at least, an unloadable text or data section is
366 actually a shared library section. */
367 if ((styp_flags & STYP_TEXT)
368 || (styp_flags & STYP_ECOFF_INIT)
369 || (styp_flags & STYP_ECOFF_FINI)
370 || (styp_flags & STYP_DYNAMIC)
371 || (styp_flags & STYP_LIBLIST)
372 || (styp_flags & STYP_RELDYN)
373 || styp_flags == STYP_CONFLIC
374 || (styp_flags & STYP_DYNSTR)
375 || (styp_flags & STYP_DYNSYM)
376 || (styp_flags & STYP_HASH))
378 if (sec_flags & SEC_NEVER_LOAD)
379 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
380 else
381 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
383 else if ((styp_flags & STYP_DATA)
384 || (styp_flags & STYP_RDATA)
385 || (styp_flags & STYP_SDATA)
386 || styp_flags == STYP_PDATA
387 || styp_flags == STYP_XDATA
388 || (styp_flags & STYP_GOT)
389 || styp_flags == STYP_RCONST)
391 if (sec_flags & SEC_NEVER_LOAD)
392 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
393 else
394 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
395 if ((styp_flags & STYP_RDATA)
396 || styp_flags == STYP_PDATA
397 || styp_flags == STYP_RCONST)
398 sec_flags |= SEC_READONLY;
400 else if ((styp_flags & STYP_BSS)
401 || (styp_flags & STYP_SBSS))
402 sec_flags |= SEC_ALLOC;
403 else if ((styp_flags & STYP_INFO) || styp_flags == STYP_COMMENT)
404 sec_flags |= SEC_NEVER_LOAD;
405 else if ((styp_flags & STYP_LITA)
406 || (styp_flags & STYP_LIT8)
407 || (styp_flags & STYP_LIT4))
408 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
409 else if (styp_flags & STYP_ECOFF_LIB)
410 sec_flags |= SEC_COFF_SHARED_LIBRARY;
411 else
412 sec_flags |= SEC_ALLOC | SEC_LOAD;
414 * flags_ptr = sec_flags;
415 return TRUE;
418 /* Read in the symbolic header for an ECOFF object file. */
420 static bfd_boolean
421 ecoff_slurp_symbolic_header (bfd *abfd)
423 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
424 bfd_size_type external_hdr_size;
425 void * raw = NULL;
426 HDRR *internal_symhdr;
428 /* See if we've already read it in. */
429 if (ecoff_data (abfd)->debug_info.symbolic_header.magic ==
430 backend->debug_swap.sym_magic)
431 return TRUE;
433 /* See whether there is a symbolic header. */
434 if (ecoff_data (abfd)->sym_filepos == 0)
436 bfd_get_symcount (abfd) = 0;
437 return TRUE;
440 /* At this point bfd_get_symcount (abfd) holds the number of symbols
441 as read from the file header, but on ECOFF this is always the
442 size of the symbolic information header. It would be cleaner to
443 handle this when we first read the file in coffgen.c. */
444 external_hdr_size = backend->debug_swap.external_hdr_size;
445 if (bfd_get_symcount (abfd) != external_hdr_size)
447 bfd_set_error (bfd_error_bad_value);
448 return FALSE;
451 /* Read the symbolic information header. */
452 raw = bfd_malloc (external_hdr_size);
453 if (raw == NULL)
454 goto error_return;
456 if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) != 0
457 || bfd_bread (raw, external_hdr_size, abfd) != external_hdr_size)
458 goto error_return;
459 internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
460 (*backend->debug_swap.swap_hdr_in) (abfd, raw, internal_symhdr);
462 if (internal_symhdr->magic != backend->debug_swap.sym_magic)
464 bfd_set_error (bfd_error_bad_value);
465 goto error_return;
468 /* Now we can get the correct number of symbols. */
469 bfd_get_symcount (abfd) = (internal_symhdr->isymMax
470 + internal_symhdr->iextMax);
472 if (raw != NULL)
473 free (raw);
474 return TRUE;
475 error_return:
476 if (raw != NULL)
477 free (raw);
478 return FALSE;
481 /* Read in and swap the important symbolic information for an ECOFF
482 object file. This is called by gdb via the read_debug_info entry
483 point in the backend structure. */
485 bfd_boolean
486 _bfd_ecoff_slurp_symbolic_info (bfd *abfd,
487 asection *ignore ATTRIBUTE_UNUSED,
488 struct ecoff_debug_info *debug)
490 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
491 HDRR *internal_symhdr;
492 bfd_size_type raw_base;
493 bfd_size_type raw_size;
494 void * raw;
495 bfd_size_type external_fdr_size;
496 char *fraw_src;
497 char *fraw_end;
498 struct fdr *fdr_ptr;
499 bfd_size_type raw_end;
500 bfd_size_type cb_end;
501 bfd_size_type amt;
502 file_ptr pos;
504 BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info);
506 /* Check whether we've already gotten it, and whether there's any to
507 get. */
508 if (ecoff_data (abfd)->raw_syments != NULL)
509 return TRUE;
510 if (ecoff_data (abfd)->sym_filepos == 0)
512 bfd_get_symcount (abfd) = 0;
513 return TRUE;
516 if (! ecoff_slurp_symbolic_header (abfd))
517 return FALSE;
519 internal_symhdr = &debug->symbolic_header;
521 /* Read all the symbolic information at once. */
522 raw_base = (ecoff_data (abfd)->sym_filepos
523 + backend->debug_swap.external_hdr_size);
525 /* Alpha ecoff makes the determination of raw_size difficult. It has
526 an undocumented debug data section between the symhdr and the first
527 documented section. And the ordering of the sections varies between
528 statically and dynamically linked executables.
529 If bfd supports SEEK_END someday, this code could be simplified. */
530 raw_end = 0;
532 #define UPDATE_RAW_END(start, count, size) \
533 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
534 if (cb_end > raw_end) \
535 raw_end = cb_end
537 UPDATE_RAW_END (cbLineOffset, cbLine, sizeof (unsigned char));
538 UPDATE_RAW_END (cbDnOffset, idnMax, backend->debug_swap.external_dnr_size);
539 UPDATE_RAW_END (cbPdOffset, ipdMax, backend->debug_swap.external_pdr_size);
540 UPDATE_RAW_END (cbSymOffset, isymMax, backend->debug_swap.external_sym_size);
541 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
542 optimization symtab, not the number of entries. */
543 UPDATE_RAW_END (cbOptOffset, ioptMax, sizeof (char));
544 UPDATE_RAW_END (cbAuxOffset, iauxMax, sizeof (union aux_ext));
545 UPDATE_RAW_END (cbSsOffset, issMax, sizeof (char));
546 UPDATE_RAW_END (cbSsExtOffset, issExtMax, sizeof (char));
547 UPDATE_RAW_END (cbFdOffset, ifdMax, backend->debug_swap.external_fdr_size);
548 UPDATE_RAW_END (cbRfdOffset, crfd, backend->debug_swap.external_rfd_size);
549 UPDATE_RAW_END (cbExtOffset, iextMax, backend->debug_swap.external_ext_size);
551 #undef UPDATE_RAW_END
553 raw_size = raw_end - raw_base;
554 if (raw_size == 0)
556 ecoff_data (abfd)->sym_filepos = 0;
557 return TRUE;
559 raw = bfd_alloc (abfd, raw_size);
560 if (raw == NULL)
561 return FALSE;
563 pos = ecoff_data (abfd)->sym_filepos;
564 pos += backend->debug_swap.external_hdr_size;
565 if (bfd_seek (abfd, pos, SEEK_SET) != 0
566 || bfd_bread (raw, raw_size, abfd) != raw_size)
568 bfd_release (abfd, raw);
569 return FALSE;
572 ecoff_data (abfd)->raw_syments = raw;
574 /* Get pointers for the numeric offsets in the HDRR structure. */
575 #define FIX(off1, off2, type) \
576 if (internal_symhdr->off1 == 0) \
577 debug->off2 = NULL; \
578 else \
579 debug->off2 = (type) ((char *) raw \
580 + (internal_symhdr->off1 \
581 - raw_base))
583 FIX (cbLineOffset, line, unsigned char *);
584 FIX (cbDnOffset, external_dnr, void *);
585 FIX (cbPdOffset, external_pdr, void *);
586 FIX (cbSymOffset, external_sym, void *);
587 FIX (cbOptOffset, external_opt, void *);
588 FIX (cbAuxOffset, external_aux, union aux_ext *);
589 FIX (cbSsOffset, ss, char *);
590 FIX (cbSsExtOffset, ssext, char *);
591 FIX (cbFdOffset, external_fdr, void *);
592 FIX (cbRfdOffset, external_rfd, void *);
593 FIX (cbExtOffset, external_ext, void *);
594 #undef FIX
596 /* I don't want to always swap all the data, because it will just
597 waste time and most programs will never look at it. The only
598 time the linker needs most of the debugging information swapped
599 is when linking big-endian and little-endian MIPS object files
600 together, which is not a common occurrence.
602 We need to look at the fdr to deal with a lot of information in
603 the symbols, so we swap them here. */
604 amt = internal_symhdr->ifdMax;
605 amt *= sizeof (struct fdr);
606 debug->fdr = bfd_alloc (abfd, amt);
607 if (debug->fdr == NULL)
608 return FALSE;
609 external_fdr_size = backend->debug_swap.external_fdr_size;
610 fdr_ptr = debug->fdr;
611 fraw_src = (char *) debug->external_fdr;
612 fraw_end = fraw_src + internal_symhdr->ifdMax * external_fdr_size;
613 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
614 (*backend->debug_swap.swap_fdr_in) (abfd, (void *) fraw_src, fdr_ptr);
616 return TRUE;
619 /* ECOFF symbol table routines. The ECOFF symbol table is described
620 in gcc/mips-tfile.c. */
622 /* ECOFF uses two common sections. One is the usual one, and the
623 other is for small objects. All the small objects are kept
624 together, and then referenced via the gp pointer, which yields
625 faster assembler code. This is what we use for the small common
626 section. */
627 static asection ecoff_scom_section;
628 static asymbol ecoff_scom_symbol;
629 static asymbol *ecoff_scom_symbol_ptr;
631 /* Create an empty symbol. */
633 asymbol *
634 _bfd_ecoff_make_empty_symbol (bfd *abfd)
636 ecoff_symbol_type *new;
637 bfd_size_type amt = sizeof (ecoff_symbol_type);
639 new = bfd_zalloc (abfd, amt);
640 if (new == NULL)
641 return NULL;
642 new->symbol.section = NULL;
643 new->fdr = NULL;
644 new->local = FALSE;
645 new->native = NULL;
646 new->symbol.the_bfd = abfd;
647 return &new->symbol;
650 /* Set the BFD flags and section for an ECOFF symbol. */
652 static bfd_boolean
653 ecoff_set_symbol_info (bfd *abfd,
654 SYMR *ecoff_sym,
655 asymbol *asym,
656 int ext,
657 int weak)
659 asym->the_bfd = abfd;
660 asym->value = ecoff_sym->value;
661 asym->section = &bfd_debug_section;
662 asym->udata.i = 0;
664 /* Most symbol types are just for debugging. */
665 switch (ecoff_sym->st)
667 case stGlobal:
668 case stStatic:
669 case stLabel:
670 case stProc:
671 case stStaticProc:
672 break;
673 case stNil:
674 if (ECOFF_IS_STAB (ecoff_sym))
676 asym->flags = BSF_DEBUGGING;
677 return TRUE;
679 break;
680 default:
681 asym->flags = BSF_DEBUGGING;
682 return TRUE;
685 if (weak)
686 asym->flags = BSF_EXPORT | BSF_WEAK;
687 else if (ext)
688 asym->flags = BSF_EXPORT | BSF_GLOBAL;
689 else
691 asym->flags = BSF_LOCAL;
692 /* Normally, a local stProc symbol will have a corresponding
693 external symbol. We mark the local symbol as a debugging
694 symbol, in order to prevent nm from printing both out.
695 Similarly, we mark stLabel and stabs symbols as debugging
696 symbols. In both cases, we do want to set the value
697 correctly based on the symbol class. */
698 if (ecoff_sym->st == stProc
699 || ecoff_sym->st == stLabel
700 || ECOFF_IS_STAB (ecoff_sym))
701 asym->flags |= BSF_DEBUGGING;
704 if (ecoff_sym->st == stProc || ecoff_sym->st == stStaticProc)
705 asym->flags |= BSF_FUNCTION;
707 switch (ecoff_sym->sc)
709 case scNil:
710 /* Used for compiler generated labels. Leave them in the
711 debugging section, and mark them as local. If BSF_DEBUGGING
712 is set, then nm does not display them for some reason. If no
713 flags are set then the linker whines about them. */
714 asym->flags = BSF_LOCAL;
715 break;
716 case scText:
717 asym->section = bfd_make_section_old_way (abfd, _TEXT);
718 asym->value -= asym->section->vma;
719 break;
720 case scData:
721 asym->section = bfd_make_section_old_way (abfd, _DATA);
722 asym->value -= asym->section->vma;
723 break;
724 case scBss:
725 asym->section = bfd_make_section_old_way (abfd, _BSS);
726 asym->value -= asym->section->vma;
727 break;
728 case scRegister:
729 asym->flags = BSF_DEBUGGING;
730 break;
731 case scAbs:
732 asym->section = bfd_abs_section_ptr;
733 break;
734 case scUndefined:
735 asym->section = bfd_und_section_ptr;
736 asym->flags = 0;
737 asym->value = 0;
738 break;
739 case scCdbLocal:
740 case scBits:
741 case scCdbSystem:
742 case scRegImage:
743 case scInfo:
744 case scUserStruct:
745 asym->flags = BSF_DEBUGGING;
746 break;
747 case scSData:
748 asym->section = bfd_make_section_old_way (abfd, ".sdata");
749 asym->value -= asym->section->vma;
750 break;
751 case scSBss:
752 asym->section = bfd_make_section_old_way (abfd, ".sbss");
753 asym->value -= asym->section->vma;
754 break;
755 case scRData:
756 asym->section = bfd_make_section_old_way (abfd, ".rdata");
757 asym->value -= asym->section->vma;
758 break;
759 case scVar:
760 asym->flags = BSF_DEBUGGING;
761 break;
762 case scCommon:
763 if (asym->value > ecoff_data (abfd)->gp_size)
765 asym->section = bfd_com_section_ptr;
766 asym->flags = 0;
767 break;
769 /* Fall through. */
770 case scSCommon:
771 if (ecoff_scom_section.name == NULL)
773 /* Initialize the small common section. */
774 ecoff_scom_section.name = SCOMMON;
775 ecoff_scom_section.flags = SEC_IS_COMMON;
776 ecoff_scom_section.output_section = &ecoff_scom_section;
777 ecoff_scom_section.symbol = &ecoff_scom_symbol;
778 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
779 ecoff_scom_symbol.name = SCOMMON;
780 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
781 ecoff_scom_symbol.section = &ecoff_scom_section;
782 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
784 asym->section = &ecoff_scom_section;
785 asym->flags = 0;
786 break;
787 case scVarRegister:
788 case scVariant:
789 asym->flags = BSF_DEBUGGING;
790 break;
791 case scSUndefined:
792 asym->section = bfd_und_section_ptr;
793 asym->flags = 0;
794 asym->value = 0;
795 break;
796 case scInit:
797 asym->section = bfd_make_section_old_way (abfd, ".init");
798 asym->value -= asym->section->vma;
799 break;
800 case scBasedVar:
801 case scXData:
802 case scPData:
803 asym->flags = BSF_DEBUGGING;
804 break;
805 case scFini:
806 asym->section = bfd_make_section_old_way (abfd, ".fini");
807 asym->value -= asym->section->vma;
808 break;
809 case scRConst:
810 asym->section = bfd_make_section_old_way (abfd, ".rconst");
811 asym->value -= asym->section->vma;
812 break;
813 default:
814 break;
817 /* Look for special constructors symbols and make relocation entries
818 in a special construction section. These are produced by the
819 -fgnu-linker argument to g++. */
820 if (ECOFF_IS_STAB (ecoff_sym))
822 switch (ECOFF_UNMARK_STAB (ecoff_sym->index))
824 default:
825 break;
827 case N_SETA:
828 case N_SETT:
829 case N_SETD:
830 case N_SETB:
831 /* Mark the symbol as a constructor. */
832 asym->flags |= BSF_CONSTRUCTOR;
833 break;
836 return TRUE;
839 /* Read an ECOFF symbol table. */
841 bfd_boolean
842 _bfd_ecoff_slurp_symbol_table (bfd *abfd)
844 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
845 const bfd_size_type external_ext_size
846 = backend->debug_swap.external_ext_size;
847 const bfd_size_type external_sym_size
848 = backend->debug_swap.external_sym_size;
849 void (* const swap_ext_in) (bfd *, void *, EXTR *)
850 = backend->debug_swap.swap_ext_in;
851 void (* const swap_sym_in) (bfd *, void *, SYMR *)
852 = backend->debug_swap.swap_sym_in;
853 bfd_size_type internal_size;
854 ecoff_symbol_type *internal;
855 ecoff_symbol_type *internal_ptr;
856 char *eraw_src;
857 char *eraw_end;
858 FDR *fdr_ptr;
859 FDR *fdr_end;
861 /* If we've already read in the symbol table, do nothing. */
862 if (ecoff_data (abfd)->canonical_symbols != NULL)
863 return TRUE;
865 /* Get the symbolic information. */
866 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL,
867 &ecoff_data (abfd)->debug_info))
868 return FALSE;
869 if (bfd_get_symcount (abfd) == 0)
870 return TRUE;
872 internal_size = bfd_get_symcount (abfd);
873 internal_size *= sizeof (ecoff_symbol_type);
874 internal = bfd_alloc (abfd, internal_size);
875 if (internal == NULL)
876 return FALSE;
878 internal_ptr = internal;
879 eraw_src = (char *) ecoff_data (abfd)->debug_info.external_ext;
880 eraw_end = (eraw_src
881 + (ecoff_data (abfd)->debug_info.symbolic_header.iextMax
882 * external_ext_size));
883 for (; eraw_src < eraw_end; eraw_src += external_ext_size, internal_ptr++)
885 EXTR internal_esym;
887 (*swap_ext_in) (abfd, (void *) eraw_src, &internal_esym);
888 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ssext
889 + internal_esym.asym.iss);
890 if (!ecoff_set_symbol_info (abfd, &internal_esym.asym,
891 &internal_ptr->symbol, 1,
892 internal_esym.weakext))
893 return FALSE;
894 /* The alpha uses a negative ifd field for section symbols. */
895 if (internal_esym.ifd >= 0)
896 internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr
897 + internal_esym.ifd);
898 else
899 internal_ptr->fdr = NULL;
900 internal_ptr->local = FALSE;
901 internal_ptr->native = (void *) eraw_src;
904 /* The local symbols must be accessed via the fdr's, because the
905 string and aux indices are relative to the fdr information. */
906 fdr_ptr = ecoff_data (abfd)->debug_info.fdr;
907 fdr_end = fdr_ptr + ecoff_data (abfd)->debug_info.symbolic_header.ifdMax;
908 for (; fdr_ptr < fdr_end; fdr_ptr++)
910 char *lraw_src;
911 char *lraw_end;
913 lraw_src = ((char *) ecoff_data (abfd)->debug_info.external_sym
914 + fdr_ptr->isymBase * external_sym_size);
915 lraw_end = lraw_src + fdr_ptr->csym * external_sym_size;
916 for (;
917 lraw_src < lraw_end;
918 lraw_src += external_sym_size, internal_ptr++)
920 SYMR internal_sym;
922 (*swap_sym_in) (abfd, (void *) lraw_src, &internal_sym);
923 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ss
924 + fdr_ptr->issBase
925 + internal_sym.iss);
926 if (!ecoff_set_symbol_info (abfd, &internal_sym,
927 &internal_ptr->symbol, 0, 0))
928 return FALSE;
929 internal_ptr->fdr = fdr_ptr;
930 internal_ptr->local = TRUE;
931 internal_ptr->native = (void *) lraw_src;
935 ecoff_data (abfd)->canonical_symbols = internal;
937 return TRUE;
940 /* Return the amount of space needed for the canonical symbols. */
942 long
943 _bfd_ecoff_get_symtab_upper_bound (bfd *abfd)
945 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL,
946 &ecoff_data (abfd)->debug_info))
947 return -1;
949 if (bfd_get_symcount (abfd) == 0)
950 return 0;
952 return (bfd_get_symcount (abfd) + 1) * (sizeof (ecoff_symbol_type *));
955 /* Get the canonical symbols. */
957 long
958 _bfd_ecoff_canonicalize_symtab (bfd *abfd, asymbol **alocation)
960 unsigned int counter = 0;
961 ecoff_symbol_type *symbase;
962 ecoff_symbol_type **location = (ecoff_symbol_type **) alocation;
964 if (! _bfd_ecoff_slurp_symbol_table (abfd))
965 return -1;
966 if (bfd_get_symcount (abfd) == 0)
967 return 0;
969 symbase = ecoff_data (abfd)->canonical_symbols;
970 while (counter < bfd_get_symcount (abfd))
972 *(location++) = symbase++;
973 counter++;
975 *location++ = NULL;
976 return bfd_get_symcount (abfd);
979 /* Turn ECOFF type information into a printable string.
980 ecoff_emit_aggregate and ecoff_type_to_string are from
981 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
983 /* Write aggregate information to a string. */
985 static void
986 ecoff_emit_aggregate (bfd *abfd,
987 FDR *fdr,
988 char *string,
989 RNDXR *rndx,
990 long isym,
991 const char *which)
993 const struct ecoff_debug_swap * const debug_swap =
994 &ecoff_backend (abfd)->debug_swap;
995 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
996 unsigned int ifd = rndx->rfd;
997 unsigned int indx = rndx->index;
998 const char *name;
1000 if (ifd == 0xfff)
1001 ifd = isym;
1003 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1004 struct return type of a procedure compiled without -g. */
1005 if (ifd == 0xffffffff
1006 || (rndx->rfd == 0xfff && indx == 0))
1007 name = "<undefined>";
1008 else if (indx == indexNil)
1009 name = "<no name>";
1010 else
1012 SYMR sym;
1014 if (debug_info->external_rfd == NULL)
1015 fdr = debug_info->fdr + ifd;
1016 else
1018 RFDT rfd;
1020 (*debug_swap->swap_rfd_in) (abfd,
1021 ((char *) debug_info->external_rfd
1022 + ((fdr->rfdBase + ifd)
1023 * debug_swap->external_rfd_size)),
1024 &rfd);
1025 fdr = debug_info->fdr + rfd;
1028 indx += fdr->isymBase;
1030 (*debug_swap->swap_sym_in) (abfd,
1031 ((char *) debug_info->external_sym
1032 + indx * debug_swap->external_sym_size),
1033 &sym);
1035 name = debug_info->ss + fdr->issBase + sym.iss;
1038 sprintf (string,
1039 "%s %s { ifd = %u, index = %lu }",
1040 which, name, ifd,
1041 ((long) indx
1042 + debug_info->symbolic_header.iextMax));
1045 /* Convert the type information to string format. */
1047 static char *
1048 ecoff_type_to_string (bfd *abfd, FDR *fdr, unsigned int indx)
1050 union aux_ext *aux_ptr;
1051 int bigendian;
1052 AUXU u;
1053 struct qual
1055 unsigned int type;
1056 int low_bound;
1057 int high_bound;
1058 int stride;
1059 } qualifiers[7];
1060 unsigned int basic_type;
1061 int i;
1062 char buffer1[1024];
1063 static char buffer2[1024];
1064 char *p1 = buffer1;
1065 char *p2 = buffer2;
1066 RNDXR rndx;
1068 aux_ptr = ecoff_data (abfd)->debug_info.external_aux + fdr->iauxBase;
1069 bigendian = fdr->fBigendian;
1071 for (i = 0; i < 7; i++)
1073 qualifiers[i].low_bound = 0;
1074 qualifiers[i].high_bound = 0;
1075 qualifiers[i].stride = 0;
1078 if (AUX_GET_ISYM (bigendian, &aux_ptr[indx]) == (bfd_vma) -1)
1079 return "-1 (no type)";
1080 _bfd_ecoff_swap_tir_in (bigendian, &aux_ptr[indx++].a_ti, &u.ti);
1082 basic_type = u.ti.bt;
1083 qualifiers[0].type = u.ti.tq0;
1084 qualifiers[1].type = u.ti.tq1;
1085 qualifiers[2].type = u.ti.tq2;
1086 qualifiers[3].type = u.ti.tq3;
1087 qualifiers[4].type = u.ti.tq4;
1088 qualifiers[5].type = u.ti.tq5;
1089 qualifiers[6].type = tqNil;
1091 /* Go get the basic type. */
1092 switch (basic_type)
1094 case btNil: /* Undefined. */
1095 strcpy (p1, "nil");
1096 break;
1098 case btAdr: /* Address - integer same size as pointer. */
1099 strcpy (p1, "address");
1100 break;
1102 case btChar: /* Character. */
1103 strcpy (p1, "char");
1104 break;
1106 case btUChar: /* Unsigned character. */
1107 strcpy (p1, "unsigned char");
1108 break;
1110 case btShort: /* Short. */
1111 strcpy (p1, "short");
1112 break;
1114 case btUShort: /* Unsigned short. */
1115 strcpy (p1, "unsigned short");
1116 break;
1118 case btInt: /* Int. */
1119 strcpy (p1, "int");
1120 break;
1122 case btUInt: /* Unsigned int. */
1123 strcpy (p1, "unsigned int");
1124 break;
1126 case btLong: /* Long. */
1127 strcpy (p1, "long");
1128 break;
1130 case btULong: /* Unsigned long. */
1131 strcpy (p1, "unsigned long");
1132 break;
1134 case btFloat: /* Float (real). */
1135 strcpy (p1, "float");
1136 break;
1138 case btDouble: /* Double (real). */
1139 strcpy (p1, "double");
1140 break;
1142 /* Structures add 1-2 aux words:
1143 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1144 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1146 case btStruct: /* Structure (Record). */
1147 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1148 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1149 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1150 "struct");
1151 indx++; /* Skip aux words. */
1152 break;
1154 /* Unions add 1-2 aux words:
1155 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1156 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1158 case btUnion: /* Union. */
1159 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1160 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1161 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1162 "union");
1163 indx++; /* Skip aux words. */
1164 break;
1166 /* Enumerations add 1-2 aux words:
1167 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1168 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1170 case btEnum: /* Enumeration. */
1171 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1172 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1173 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1174 "enum");
1175 indx++; /* Skip aux words. */
1176 break;
1178 case btTypedef: /* Defined via a typedef, isymRef points. */
1179 strcpy (p1, "typedef");
1180 break;
1182 case btRange: /* Subrange of int. */
1183 strcpy (p1, "subrange");
1184 break;
1186 case btSet: /* Pascal sets. */
1187 strcpy (p1, "set");
1188 break;
1190 case btComplex: /* Fortran complex. */
1191 strcpy (p1, "complex");
1192 break;
1194 case btDComplex: /* Fortran double complex. */
1195 strcpy (p1, "double complex");
1196 break;
1198 case btIndirect: /* Forward or unnamed typedef. */
1199 strcpy (p1, "forward/unamed typedef");
1200 break;
1202 case btFixedDec: /* Fixed Decimal. */
1203 strcpy (p1, "fixed decimal");
1204 break;
1206 case btFloatDec: /* Float Decimal. */
1207 strcpy (p1, "float decimal");
1208 break;
1210 case btString: /* Varying Length Character String. */
1211 strcpy (p1, "string");
1212 break;
1214 case btBit: /* Aligned Bit String. */
1215 strcpy (p1, "bit");
1216 break;
1218 case btPicture: /* Picture. */
1219 strcpy (p1, "picture");
1220 break;
1222 case btVoid: /* Void. */
1223 strcpy (p1, "void");
1224 break;
1226 default:
1227 sprintf (p1, _("Unknown basic type %d"), (int) basic_type);
1228 break;
1231 p1 += strlen (buffer1);
1233 /* If this is a bitfield, get the bitsize. */
1234 if (u.ti.fBitfield)
1236 int bitsize;
1238 bitsize = AUX_GET_WIDTH (bigendian, &aux_ptr[indx++]);
1239 sprintf (p1, " : %d", bitsize);
1240 p1 += strlen (buffer1);
1243 /* Deal with any qualifiers. */
1244 if (qualifiers[0].type != tqNil)
1246 /* Snarf up any array bounds in the correct order. Arrays
1247 store 5 successive words in the aux. table:
1248 word 0 RNDXR to type of the bounds (ie, int)
1249 word 1 Current file descriptor index
1250 word 2 low bound
1251 word 3 high bound (or -1 if [])
1252 word 4 stride size in bits. */
1253 for (i = 0; i < 7; i++)
1255 if (qualifiers[i].type == tqArray)
1257 qualifiers[i].low_bound =
1258 AUX_GET_DNLOW (bigendian, &aux_ptr[indx+2]);
1259 qualifiers[i].high_bound =
1260 AUX_GET_DNHIGH (bigendian, &aux_ptr[indx+3]);
1261 qualifiers[i].stride =
1262 AUX_GET_WIDTH (bigendian, &aux_ptr[indx+4]);
1263 indx += 5;
1267 /* Now print out the qualifiers. */
1268 for (i = 0; i < 6; i++)
1270 switch (qualifiers[i].type)
1272 case tqNil:
1273 case tqMax:
1274 break;
1276 case tqPtr:
1277 strcpy (p2, "ptr to ");
1278 p2 += sizeof ("ptr to ")-1;
1279 break;
1281 case tqVol:
1282 strcpy (p2, "volatile ");
1283 p2 += sizeof ("volatile ")-1;
1284 break;
1286 case tqFar:
1287 strcpy (p2, "far ");
1288 p2 += sizeof ("far ")-1;
1289 break;
1291 case tqProc:
1292 strcpy (p2, "func. ret. ");
1293 p2 += sizeof ("func. ret. ");
1294 break;
1296 case tqArray:
1298 int first_array = i;
1299 int j;
1301 /* Print array bounds reversed (ie, in the order the C
1302 programmer writes them). C is such a fun language.... */
1303 while (i < 5 && qualifiers[i+1].type == tqArray)
1304 i++;
1306 for (j = i; j >= first_array; j--)
1308 strcpy (p2, "array [");
1309 p2 += sizeof ("array [")-1;
1310 if (qualifiers[j].low_bound != 0)
1311 sprintf (p2,
1312 "%ld:%ld {%ld bits}",
1313 (long) qualifiers[j].low_bound,
1314 (long) qualifiers[j].high_bound,
1315 (long) qualifiers[j].stride);
1317 else if (qualifiers[j].high_bound != -1)
1318 sprintf (p2,
1319 "%ld {%ld bits}",
1320 (long) (qualifiers[j].high_bound + 1),
1321 (long) (qualifiers[j].stride));
1323 else
1324 sprintf (p2, " {%ld bits}", (long) (qualifiers[j].stride));
1326 p2 += strlen (p2);
1327 strcpy (p2, "] of ");
1328 p2 += sizeof ("] of ")-1;
1331 break;
1336 strcpy (p2, buffer1);
1337 return buffer2;
1340 /* Return information about ECOFF symbol SYMBOL in RET. */
1342 void
1343 _bfd_ecoff_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
1344 asymbol *symbol,
1345 symbol_info *ret)
1347 bfd_symbol_info (symbol, ret);
1350 /* Return whether this is a local label. */
1352 bfd_boolean
1353 _bfd_ecoff_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
1354 const char *name)
1356 return name[0] == '$';
1359 /* Print information about an ECOFF symbol. */
1361 void
1362 _bfd_ecoff_print_symbol (bfd *abfd,
1363 void * filep,
1364 asymbol *symbol,
1365 bfd_print_symbol_type how)
1367 const struct ecoff_debug_swap * const debug_swap
1368 = &ecoff_backend (abfd)->debug_swap;
1369 FILE *file = (FILE *)filep;
1371 switch (how)
1373 case bfd_print_symbol_name:
1374 fprintf (file, "%s", symbol->name);
1375 break;
1376 case bfd_print_symbol_more:
1377 if (ecoffsymbol (symbol)->local)
1379 SYMR ecoff_sym;
1381 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1382 &ecoff_sym);
1383 fprintf (file, "ecoff local ");
1384 fprintf_vma (file, (bfd_vma) ecoff_sym.value);
1385 fprintf (file, " %x %x", (unsigned) ecoff_sym.st,
1386 (unsigned) ecoff_sym.sc);
1388 else
1390 EXTR ecoff_ext;
1392 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1393 &ecoff_ext);
1394 fprintf (file, "ecoff extern ");
1395 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1396 fprintf (file, " %x %x", (unsigned) ecoff_ext.asym.st,
1397 (unsigned) ecoff_ext.asym.sc);
1399 break;
1400 case bfd_print_symbol_all:
1401 /* Print out the symbols in a reasonable way. */
1403 char type;
1404 int pos;
1405 EXTR ecoff_ext;
1406 char jmptbl;
1407 char cobol_main;
1408 char weakext;
1410 if (ecoffsymbol (symbol)->local)
1412 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1413 &ecoff_ext.asym);
1414 type = 'l';
1415 pos = ((((char *) ecoffsymbol (symbol)->native
1416 - (char *) ecoff_data (abfd)->debug_info.external_sym)
1417 / debug_swap->external_sym_size)
1418 + ecoff_data (abfd)->debug_info.symbolic_header.iextMax);
1419 jmptbl = ' ';
1420 cobol_main = ' ';
1421 weakext = ' ';
1423 else
1425 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1426 &ecoff_ext);
1427 type = 'e';
1428 pos = (((char *) ecoffsymbol (symbol)->native
1429 - (char *) ecoff_data (abfd)->debug_info.external_ext)
1430 / debug_swap->external_ext_size);
1431 jmptbl = ecoff_ext.jmptbl ? 'j' : ' ';
1432 cobol_main = ecoff_ext.cobol_main ? 'c' : ' ';
1433 weakext = ecoff_ext.weakext ? 'w' : ' ';
1436 fprintf (file, "[%3d] %c ",
1437 pos, type);
1438 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1439 fprintf (file, " st %x sc %x indx %x %c%c%c %s",
1440 (unsigned) ecoff_ext.asym.st,
1441 (unsigned) ecoff_ext.asym.sc,
1442 (unsigned) ecoff_ext.asym.index,
1443 jmptbl, cobol_main, weakext,
1444 symbol->name);
1446 if (ecoffsymbol (symbol)->fdr != NULL
1447 && ecoff_ext.asym.index != indexNil)
1449 FDR *fdr;
1450 unsigned int indx;
1451 int bigendian;
1452 bfd_size_type sym_base;
1453 union aux_ext *aux_base;
1455 fdr = ecoffsymbol (symbol)->fdr;
1456 indx = ecoff_ext.asym.index;
1458 /* sym_base is used to map the fdr relative indices which
1459 appear in the file to the position number which we are
1460 using. */
1461 sym_base = fdr->isymBase;
1462 if (ecoffsymbol (symbol)->local)
1463 sym_base +=
1464 ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
1466 /* aux_base is the start of the aux entries for this file;
1467 asym.index is an offset from this. */
1468 aux_base = (ecoff_data (abfd)->debug_info.external_aux
1469 + fdr->iauxBase);
1471 /* The aux entries are stored in host byte order; the
1472 order is indicated by a bit in the fdr. */
1473 bigendian = fdr->fBigendian;
1475 /* This switch is basically from gcc/mips-tdump.c. */
1476 switch (ecoff_ext.asym.st)
1478 case stNil:
1479 case stLabel:
1480 break;
1482 case stFile:
1483 case stBlock:
1484 fprintf (file, _("\n End+1 symbol: %ld"),
1485 (long) (indx + sym_base));
1486 break;
1488 case stEnd:
1489 if (ecoff_ext.asym.sc == scText
1490 || ecoff_ext.asym.sc == scInfo)
1491 fprintf (file, _("\n First symbol: %ld"),
1492 (long) (indx + sym_base));
1493 else
1494 fprintf (file, _("\n First symbol: %ld"),
1495 ((long)
1496 (AUX_GET_ISYM (bigendian,
1497 &aux_base[ecoff_ext.asym.index])
1498 + sym_base)));
1499 break;
1501 case stProc:
1502 case stStaticProc:
1503 if (ECOFF_IS_STAB (&ecoff_ext.asym))
1505 else if (ecoffsymbol (symbol)->local)
1506 fprintf (file, _("\n End+1 symbol: %-7ld Type: %s"),
1507 ((long)
1508 (AUX_GET_ISYM (bigendian,
1509 &aux_base[ecoff_ext.asym.index])
1510 + sym_base)),
1511 ecoff_type_to_string (abfd, fdr, indx + 1));
1512 else
1513 fprintf (file, _("\n Local symbol: %ld"),
1514 ((long) indx
1515 + (long) sym_base
1516 + (ecoff_data (abfd)
1517 ->debug_info.symbolic_header.iextMax)));
1518 break;
1520 case stStruct:
1521 fprintf (file, _("\n struct; End+1 symbol: %ld"),
1522 (long) (indx + sym_base));
1523 break;
1525 case stUnion:
1526 fprintf (file, _("\n union; End+1 symbol: %ld"),
1527 (long) (indx + sym_base));
1528 break;
1530 case stEnum:
1531 fprintf (file, _("\n enum; End+1 symbol: %ld"),
1532 (long) (indx + sym_base));
1533 break;
1535 default:
1536 if (! ECOFF_IS_STAB (&ecoff_ext.asym))
1537 fprintf (file, _("\n Type: %s"),
1538 ecoff_type_to_string (abfd, fdr, indx));
1539 break;
1543 break;
1547 /* Read in the relocs for a section. */
1549 static bfd_boolean
1550 ecoff_slurp_reloc_table (bfd *abfd,
1551 asection *section,
1552 asymbol **symbols)
1554 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
1555 arelent *internal_relocs;
1556 bfd_size_type external_reloc_size;
1557 bfd_size_type amt;
1558 char *external_relocs;
1559 arelent *rptr;
1560 unsigned int i;
1562 if (section->relocation != NULL
1563 || section->reloc_count == 0
1564 || (section->flags & SEC_CONSTRUCTOR) != 0)
1565 return TRUE;
1567 if (! _bfd_ecoff_slurp_symbol_table (abfd))
1568 return FALSE;
1570 amt = section->reloc_count;
1571 amt *= sizeof (arelent);
1572 internal_relocs = bfd_alloc (abfd, amt);
1574 external_reloc_size = backend->external_reloc_size;
1575 amt = external_reloc_size * section->reloc_count;
1576 external_relocs = bfd_alloc (abfd, amt);
1577 if (internal_relocs == NULL || external_relocs == NULL)
1578 return FALSE;
1579 if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0)
1580 return FALSE;
1581 if (bfd_bread (external_relocs, amt, abfd) != amt)
1582 return FALSE;
1584 for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++)
1586 struct internal_reloc intern;
1588 (*backend->swap_reloc_in) (abfd,
1589 external_relocs + i * external_reloc_size,
1590 &intern);
1592 if (intern.r_extern)
1594 /* r_symndx is an index into the external symbols. */
1595 BFD_ASSERT (intern.r_symndx >= 0
1596 && (intern.r_symndx
1597 < (ecoff_data (abfd)
1598 ->debug_info.symbolic_header.iextMax)));
1599 rptr->sym_ptr_ptr = symbols + intern.r_symndx;
1600 rptr->addend = 0;
1602 else if (intern.r_symndx == RELOC_SECTION_NONE
1603 || intern.r_symndx == RELOC_SECTION_ABS)
1605 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1606 rptr->addend = 0;
1608 else
1610 const char *sec_name;
1611 asection *sec;
1613 /* r_symndx is a section key. */
1614 switch (intern.r_symndx)
1616 case RELOC_SECTION_TEXT: sec_name = _TEXT; break;
1617 case RELOC_SECTION_RDATA: sec_name = _RDATA; break;
1618 case RELOC_SECTION_DATA: sec_name = _DATA; break;
1619 case RELOC_SECTION_SDATA: sec_name = _SDATA; break;
1620 case RELOC_SECTION_SBSS: sec_name = _SBSS; break;
1621 case RELOC_SECTION_BSS: sec_name = _BSS; break;
1622 case RELOC_SECTION_INIT: sec_name = _INIT; break;
1623 case RELOC_SECTION_LIT8: sec_name = _LIT8; break;
1624 case RELOC_SECTION_LIT4: sec_name = _LIT4; break;
1625 case RELOC_SECTION_XDATA: sec_name = _XDATA; break;
1626 case RELOC_SECTION_PDATA: sec_name = _PDATA; break;
1627 case RELOC_SECTION_FINI: sec_name = _FINI; break;
1628 case RELOC_SECTION_LITA: sec_name = _LITA; break;
1629 case RELOC_SECTION_RCONST: sec_name = _RCONST; break;
1630 default: abort ();
1633 sec = bfd_get_section_by_name (abfd, sec_name);
1634 if (sec == NULL)
1635 abort ();
1636 rptr->sym_ptr_ptr = sec->symbol_ptr_ptr;
1638 rptr->addend = - bfd_get_section_vma (abfd, sec);
1641 rptr->address = intern.r_vaddr - bfd_get_section_vma (abfd, section);
1643 /* Let the backend select the howto field and do any other
1644 required processing. */
1645 (*backend->adjust_reloc_in) (abfd, &intern, rptr);
1648 bfd_release (abfd, external_relocs);
1650 section->relocation = internal_relocs;
1652 return TRUE;
1655 /* Get a canonical list of relocs. */
1657 long
1658 _bfd_ecoff_canonicalize_reloc (bfd *abfd,
1659 asection *section,
1660 arelent **relptr,
1661 asymbol **symbols)
1663 unsigned int count;
1665 if (section->flags & SEC_CONSTRUCTOR)
1667 arelent_chain *chain;
1669 /* This section has relocs made up by us, not the file, so take
1670 them out of their chain and place them into the data area
1671 provided. */
1672 for (count = 0, chain = section->constructor_chain;
1673 count < section->reloc_count;
1674 count++, chain = chain->next)
1675 *relptr++ = &chain->relent;
1677 else
1679 arelent *tblptr;
1681 if (! ecoff_slurp_reloc_table (abfd, section, symbols))
1682 return -1;
1684 tblptr = section->relocation;
1686 for (count = 0; count < section->reloc_count; count++)
1687 *relptr++ = tblptr++;
1690 *relptr = NULL;
1692 return section->reloc_count;
1695 /* Provided a BFD, a section and an offset into the section, calculate
1696 and return the name of the source file and the line nearest to the
1697 wanted location. */
1699 bfd_boolean
1700 _bfd_ecoff_find_nearest_line (bfd *abfd,
1701 asection *section,
1702 asymbol **ignore_symbols ATTRIBUTE_UNUSED,
1703 bfd_vma offset,
1704 const char **filename_ptr,
1705 const char **functionname_ptr,
1706 unsigned int *retline_ptr)
1708 const struct ecoff_debug_swap * const debug_swap
1709 = &ecoff_backend (abfd)->debug_swap;
1710 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
1711 struct ecoff_find_line *line_info;
1713 /* Make sure we have the FDR's. */
1714 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, debug_info)
1715 || bfd_get_symcount (abfd) == 0)
1716 return FALSE;
1718 if (ecoff_data (abfd)->find_line_info == NULL)
1720 bfd_size_type amt = sizeof (struct ecoff_find_line);
1722 ecoff_data (abfd)->find_line_info = bfd_zalloc (abfd, amt);
1723 if (ecoff_data (abfd)->find_line_info == NULL)
1724 return FALSE;
1726 line_info = ecoff_data (abfd)->find_line_info;
1728 return _bfd_ecoff_locate_line (abfd, section, offset, debug_info,
1729 debug_swap, line_info, filename_ptr,
1730 functionname_ptr, retline_ptr);
1733 /* Copy private BFD data. This is called by objcopy and strip. We
1734 use it to copy the ECOFF debugging information from one BFD to the
1735 other. It would be theoretically possible to represent the ECOFF
1736 debugging information in the symbol table. However, it would be a
1737 lot of work, and there would be little gain (gas, gdb, and ld
1738 already access the ECOFF debugging information via the
1739 ecoff_debug_info structure, and that structure would have to be
1740 retained in order to support ECOFF debugging in MIPS ELF).
1742 The debugging information for the ECOFF external symbols comes from
1743 the symbol table, so this function only handles the other debugging
1744 information. */
1746 bfd_boolean
1747 _bfd_ecoff_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1749 struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info;
1750 struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info;
1751 int i;
1752 asymbol **sym_ptr_ptr;
1753 size_t c;
1754 bfd_boolean local;
1756 /* We only want to copy information over if both BFD's use ECOFF
1757 format. */
1758 if (bfd_get_flavour (ibfd) != bfd_target_ecoff_flavour
1759 || bfd_get_flavour (obfd) != bfd_target_ecoff_flavour)
1760 return TRUE;
1762 /* Copy the GP value and the register masks. */
1763 ecoff_data (obfd)->gp = ecoff_data (ibfd)->gp;
1764 ecoff_data (obfd)->gprmask = ecoff_data (ibfd)->gprmask;
1765 ecoff_data (obfd)->fprmask = ecoff_data (ibfd)->fprmask;
1766 for (i = 0; i < 3; i++)
1767 ecoff_data (obfd)->cprmask[i] = ecoff_data (ibfd)->cprmask[i];
1769 /* Copy the version stamp. */
1770 oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp;
1772 /* If there are no symbols, don't copy any debugging information. */
1773 c = bfd_get_symcount (obfd);
1774 sym_ptr_ptr = bfd_get_outsymbols (obfd);
1775 if (c == 0 || sym_ptr_ptr == NULL)
1776 return TRUE;
1778 /* See if there are any local symbols. */
1779 local = FALSE;
1780 for (; c > 0; c--, sym_ptr_ptr++)
1782 if (ecoffsymbol (*sym_ptr_ptr)->local)
1784 local = TRUE;
1785 break;
1789 if (local)
1791 /* There are some local symbols. We just bring over all the
1792 debugging information. FIXME: This is not quite the right
1793 thing to do. If the user has asked us to discard all
1794 debugging information, then we are probably going to wind up
1795 keeping it because there will probably be some local symbol
1796 which objcopy did not discard. We should actually break
1797 apart the debugging information and only keep that which
1798 applies to the symbols we want to keep. */
1799 oinfo->symbolic_header.ilineMax = iinfo->symbolic_header.ilineMax;
1800 oinfo->symbolic_header.cbLine = iinfo->symbolic_header.cbLine;
1801 oinfo->line = iinfo->line;
1803 oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax;
1804 oinfo->external_dnr = iinfo->external_dnr;
1806 oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax;
1807 oinfo->external_pdr = iinfo->external_pdr;
1809 oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax;
1810 oinfo->external_sym = iinfo->external_sym;
1812 oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax;
1813 oinfo->external_opt = iinfo->external_opt;
1815 oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax;
1816 oinfo->external_aux = iinfo->external_aux;
1818 oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax;
1819 oinfo->ss = iinfo->ss;
1821 oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax;
1822 oinfo->external_fdr = iinfo->external_fdr;
1824 oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd;
1825 oinfo->external_rfd = iinfo->external_rfd;
1827 else
1829 /* We are discarding all the local symbol information. Look
1830 through the external symbols and remove all references to FDR
1831 or aux information. */
1832 c = bfd_get_symcount (obfd);
1833 sym_ptr_ptr = bfd_get_outsymbols (obfd);
1834 for (; c > 0; c--, sym_ptr_ptr++)
1836 EXTR esym;
1838 (*(ecoff_backend (obfd)->debug_swap.swap_ext_in))
1839 (obfd, ecoffsymbol (*sym_ptr_ptr)->native, &esym);
1840 esym.ifd = ifdNil;
1841 esym.asym.index = indexNil;
1842 (*(ecoff_backend (obfd)->debug_swap.swap_ext_out))
1843 (obfd, &esym, ecoffsymbol (*sym_ptr_ptr)->native);
1847 return TRUE;
1850 /* Set the architecture. The supported architecture is stored in the
1851 backend pointer. We always set the architecture anyhow, since many
1852 callers ignore the return value. */
1854 bfd_boolean
1855 _bfd_ecoff_set_arch_mach (bfd *abfd,
1856 enum bfd_architecture arch,
1857 unsigned long machine)
1859 bfd_default_set_arch_mach (abfd, arch, machine);
1860 return arch == ecoff_backend (abfd)->arch;
1863 /* Get the size of the section headers. */
1866 _bfd_ecoff_sizeof_headers (bfd *abfd, bfd_boolean reloc ATTRIBUTE_UNUSED)
1868 asection *current;
1869 int c;
1870 int ret;
1872 c = 0;
1873 for (current = abfd->sections;
1874 current != NULL;
1875 current = current->next)
1876 ++c;
1878 ret = (bfd_coff_filhsz (abfd)
1879 + bfd_coff_aoutsz (abfd)
1880 + c * bfd_coff_scnhsz (abfd));
1881 return BFD_ALIGN (ret, 16);
1884 /* Get the contents of a section. */
1886 bfd_boolean
1887 _bfd_ecoff_get_section_contents (bfd *abfd,
1888 asection *section,
1889 void * location,
1890 file_ptr offset,
1891 bfd_size_type count)
1893 return _bfd_generic_get_section_contents (abfd, section, location,
1894 offset, count);
1897 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1898 called via qsort. */
1900 static int
1901 ecoff_sort_hdrs (const void * arg1, const void * arg2)
1903 const asection *hdr1 = *(const asection **) arg1;
1904 const asection *hdr2 = *(const asection **) arg2;
1906 if ((hdr1->flags & SEC_ALLOC) != 0)
1908 if ((hdr2->flags & SEC_ALLOC) == 0)
1909 return -1;
1911 else
1913 if ((hdr2->flags & SEC_ALLOC) != 0)
1914 return 1;
1916 if (hdr1->vma < hdr2->vma)
1917 return -1;
1918 else if (hdr1->vma > hdr2->vma)
1919 return 1;
1920 else
1921 return 0;
1924 /* Calculate the file position for each section, and set
1925 reloc_filepos. */
1927 static bfd_boolean
1928 ecoff_compute_section_file_positions (bfd *abfd)
1930 file_ptr sofar, file_sofar;
1931 asection **sorted_hdrs;
1932 asection *current;
1933 unsigned int i;
1934 file_ptr old_sofar;
1935 bfd_boolean rdata_in_text;
1936 bfd_boolean first_data, first_nonalloc;
1937 const bfd_vma round = ecoff_backend (abfd)->round;
1938 bfd_size_type amt;
1940 sofar = _bfd_ecoff_sizeof_headers (abfd, FALSE);
1941 file_sofar = sofar;
1943 /* Sort the sections by VMA. */
1944 amt = abfd->section_count;
1945 amt *= sizeof (asection *);
1946 sorted_hdrs = bfd_malloc (amt);
1947 if (sorted_hdrs == NULL)
1948 return FALSE;
1949 for (current = abfd->sections, i = 0;
1950 current != NULL;
1951 current = current->next, i++)
1952 sorted_hdrs[i] = current;
1953 BFD_ASSERT (i == abfd->section_count);
1955 qsort (sorted_hdrs, abfd->section_count, sizeof (asection *),
1956 ecoff_sort_hdrs);
1958 /* Some versions of the OSF linker put the .rdata section in the
1959 text segment, and some do not. */
1960 rdata_in_text = ecoff_backend (abfd)->rdata_in_text;
1961 if (rdata_in_text)
1963 for (i = 0; i < abfd->section_count; i++)
1965 current = sorted_hdrs[i];
1966 if (streq (current->name, _RDATA))
1967 break;
1968 if ((current->flags & SEC_CODE) == 0
1969 && ! streq (current->name, _PDATA)
1970 && ! streq (current->name, _RCONST))
1972 rdata_in_text = FALSE;
1973 break;
1977 ecoff_data (abfd)->rdata_in_text = rdata_in_text;
1979 first_data = TRUE;
1980 first_nonalloc = TRUE;
1981 for (i = 0; i < abfd->section_count; i++)
1983 unsigned int alignment_power;
1985 current = sorted_hdrs[i];
1987 /* For the Alpha ECOFF .pdata section the lnnoptr field is
1988 supposed to indicate the number of .pdata entries that are
1989 really in the section. Each entry is 8 bytes. We store this
1990 away in line_filepos before increasing the section size. */
1991 if (streq (current->name, _PDATA))
1992 current->line_filepos = current->size / 8;
1994 alignment_power = current->alignment_power;
1996 /* On Ultrix, the data sections in an executable file must be
1997 aligned to a page boundary within the file. This does not
1998 affect the section size, though. FIXME: Does this work for
1999 other platforms? It requires some modification for the
2000 Alpha, because .rdata on the Alpha goes with the text, not
2001 the data. */
2002 if ((abfd->flags & EXEC_P) != 0
2003 && (abfd->flags & D_PAGED) != 0
2004 && ! first_data
2005 && (current->flags & SEC_CODE) == 0
2006 && (! rdata_in_text
2007 || ! streq (current->name, _RDATA))
2008 && ! streq (current->name, _PDATA)
2009 && ! streq (current->name, _RCONST))
2011 sofar = (sofar + round - 1) &~ (round - 1);
2012 file_sofar = (file_sofar + round - 1) &~ (round - 1);
2013 first_data = FALSE;
2015 else if (streq (current->name, _LIB))
2017 /* On Irix 4, the location of contents of the .lib section
2018 from a shared library section is also rounded up to a
2019 page boundary. */
2021 sofar = (sofar + round - 1) &~ (round - 1);
2022 file_sofar = (file_sofar + round - 1) &~ (round - 1);
2024 else if (first_nonalloc
2025 && (current->flags & SEC_ALLOC) == 0
2026 && (abfd->flags & D_PAGED) != 0)
2028 /* Skip up to the next page for an unallocated section, such
2029 as the .comment section on the Alpha. This leaves room
2030 for the .bss section. */
2031 first_nonalloc = FALSE;
2032 sofar = (sofar + round - 1) &~ (round - 1);
2033 file_sofar = (file_sofar + round - 1) &~ (round - 1);
2036 /* Align the sections in the file to the same boundary on
2037 which they are aligned in virtual memory. */
2038 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2039 if ((current->flags & SEC_HAS_CONTENTS) != 0)
2040 file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power);
2042 if ((abfd->flags & D_PAGED) != 0
2043 && (current->flags & SEC_ALLOC) != 0)
2045 sofar += (current->vma - sofar) % round;
2046 if ((current->flags & SEC_HAS_CONTENTS) != 0)
2047 file_sofar += (current->vma - file_sofar) % round;
2050 if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) != 0)
2051 current->filepos = file_sofar;
2053 sofar += current->size;
2054 if ((current->flags & SEC_HAS_CONTENTS) != 0)
2055 file_sofar += current->size;
2057 /* Make sure that this section is of the right size too. */
2058 old_sofar = sofar;
2059 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2060 if ((current->flags & SEC_HAS_CONTENTS) != 0)
2061 file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power);
2062 current->size += sofar - old_sofar;
2065 free (sorted_hdrs);
2066 sorted_hdrs = NULL;
2068 ecoff_data (abfd)->reloc_filepos = file_sofar;
2070 return TRUE;
2073 /* Determine the location of the relocs for all the sections in the
2074 output file, as well as the location of the symbolic debugging
2075 information. */
2077 static bfd_size_type
2078 ecoff_compute_reloc_file_positions (bfd *abfd)
2080 const bfd_size_type external_reloc_size =
2081 ecoff_backend (abfd)->external_reloc_size;
2082 file_ptr reloc_base;
2083 bfd_size_type reloc_size;
2084 asection *current;
2085 file_ptr sym_base;
2087 if (! abfd->output_has_begun)
2089 if (! ecoff_compute_section_file_positions (abfd))
2090 abort ();
2091 abfd->output_has_begun = TRUE;
2094 reloc_base = ecoff_data (abfd)->reloc_filepos;
2096 reloc_size = 0;
2097 for (current = abfd->sections;
2098 current != NULL;
2099 current = current->next)
2101 if (current->reloc_count == 0)
2102 current->rel_filepos = 0;
2103 else
2105 bfd_size_type relsize;
2107 current->rel_filepos = reloc_base;
2108 relsize = current->reloc_count * external_reloc_size;
2109 reloc_size += relsize;
2110 reloc_base += relsize;
2114 sym_base = ecoff_data (abfd)->reloc_filepos + reloc_size;
2116 /* At least on Ultrix, the symbol table of an executable file must
2117 be aligned to a page boundary. FIXME: Is this true on other
2118 platforms? */
2119 if ((abfd->flags & EXEC_P) != 0
2120 && (abfd->flags & D_PAGED) != 0)
2121 sym_base = ((sym_base + ecoff_backend (abfd)->round - 1)
2122 &~ (ecoff_backend (abfd)->round - 1));
2124 ecoff_data (abfd)->sym_filepos = sym_base;
2126 return reloc_size;
2129 /* Set the contents of a section. */
2131 bfd_boolean
2132 _bfd_ecoff_set_section_contents (bfd *abfd,
2133 asection *section,
2134 const void * location,
2135 file_ptr offset,
2136 bfd_size_type count)
2138 file_ptr pos;
2140 /* This must be done first, because bfd_set_section_contents is
2141 going to set output_has_begun to TRUE. */
2142 if (! abfd->output_has_begun
2143 && ! ecoff_compute_section_file_positions (abfd))
2144 return FALSE;
2146 /* Handle the .lib section specially so that Irix 4 shared libraries
2147 work out. See coff_set_section_contents in coffcode.h. */
2148 if (streq (section->name, _LIB))
2150 bfd_byte *rec, *recend;
2152 rec = (bfd_byte *) location;
2153 recend = rec + count;
2154 while (rec < recend)
2156 ++section->lma;
2157 rec += bfd_get_32 (abfd, rec) * 4;
2160 BFD_ASSERT (rec == recend);
2163 if (count == 0)
2164 return TRUE;
2166 pos = section->filepos + offset;
2167 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2168 || bfd_bwrite (location, count, abfd) != count)
2169 return FALSE;
2171 return TRUE;
2174 /* Get the GP value for an ECOFF file. This is a hook used by
2175 nlmconv. */
2177 bfd_vma
2178 bfd_ecoff_get_gp_value (bfd *abfd)
2180 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2181 || bfd_get_format (abfd) != bfd_object)
2183 bfd_set_error (bfd_error_invalid_operation);
2184 return 0;
2187 return ecoff_data (abfd)->gp;
2190 /* Set the GP value for an ECOFF file. This is a hook used by the
2191 assembler. */
2193 bfd_boolean
2194 bfd_ecoff_set_gp_value (bfd *abfd, bfd_vma gp_value)
2196 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2197 || bfd_get_format (abfd) != bfd_object)
2199 bfd_set_error (bfd_error_invalid_operation);
2200 return FALSE;
2203 ecoff_data (abfd)->gp = gp_value;
2205 return TRUE;
2208 /* Set the register masks for an ECOFF file. This is a hook used by
2209 the assembler. */
2211 bfd_boolean
2212 bfd_ecoff_set_regmasks (bfd *abfd,
2213 unsigned long gprmask,
2214 unsigned long fprmask,
2215 unsigned long *cprmask)
2217 ecoff_data_type *tdata;
2219 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2220 || bfd_get_format (abfd) != bfd_object)
2222 bfd_set_error (bfd_error_invalid_operation);
2223 return FALSE;
2226 tdata = ecoff_data (abfd);
2227 tdata->gprmask = gprmask;
2228 tdata->fprmask = fprmask;
2229 if (cprmask != NULL)
2231 int i;
2233 for (i = 0; i < 3; i++)
2234 tdata->cprmask[i] = cprmask[i];
2237 return TRUE;
2240 /* Get ECOFF EXTR information for an external symbol. This function
2241 is passed to bfd_ecoff_debug_externals. */
2243 static bfd_boolean
2244 ecoff_get_extr (asymbol *sym, EXTR *esym)
2246 ecoff_symbol_type *ecoff_sym_ptr;
2247 bfd *input_bfd;
2249 if (bfd_asymbol_flavour (sym) != bfd_target_ecoff_flavour
2250 || ecoffsymbol (sym)->native == NULL)
2252 /* Don't include debugging, local, or section symbols. */
2253 if ((sym->flags & BSF_DEBUGGING) != 0
2254 || (sym->flags & BSF_LOCAL) != 0
2255 || (sym->flags & BSF_SECTION_SYM) != 0)
2256 return FALSE;
2258 esym->jmptbl = 0;
2259 esym->cobol_main = 0;
2260 esym->weakext = (sym->flags & BSF_WEAK) != 0;
2261 esym->reserved = 0;
2262 esym->ifd = ifdNil;
2263 /* FIXME: we can do better than this for st and sc. */
2264 esym->asym.st = stGlobal;
2265 esym->asym.sc = scAbs;
2266 esym->asym.reserved = 0;
2267 esym->asym.index = indexNil;
2268 return TRUE;
2271 ecoff_sym_ptr = ecoffsymbol (sym);
2273 if (ecoff_sym_ptr->local)
2274 return FALSE;
2276 input_bfd = bfd_asymbol_bfd (sym);
2277 (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in))
2278 (input_bfd, ecoff_sym_ptr->native, esym);
2280 /* If the symbol was defined by the linker, then esym will be
2281 undefined but sym will not be. Get a better class for such a
2282 symbol. */
2283 if ((esym->asym.sc == scUndefined
2284 || esym->asym.sc == scSUndefined)
2285 && ! bfd_is_und_section (bfd_get_section (sym)))
2286 esym->asym.sc = scAbs;
2288 /* Adjust the FDR index for the symbol by that used for the input
2289 BFD. */
2290 if (esym->ifd != -1)
2292 struct ecoff_debug_info *input_debug;
2294 input_debug = &ecoff_data (input_bfd)->debug_info;
2295 BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax);
2296 if (input_debug->ifdmap != NULL)
2297 esym->ifd = input_debug->ifdmap[esym->ifd];
2300 return TRUE;
2303 /* Set the external symbol index. This routine is passed to
2304 bfd_ecoff_debug_externals. */
2306 static void
2307 ecoff_set_index (asymbol *sym, bfd_size_type indx)
2309 ecoff_set_sym_index (sym, indx);
2312 /* Write out an ECOFF file. */
2314 bfd_boolean
2315 _bfd_ecoff_write_object_contents (bfd *abfd)
2317 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
2318 const bfd_vma round = backend->round;
2319 const bfd_size_type filhsz = bfd_coff_filhsz (abfd);
2320 const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd);
2321 const bfd_size_type scnhsz = bfd_coff_scnhsz (abfd);
2322 const bfd_size_type external_hdr_size
2323 = backend->debug_swap.external_hdr_size;
2324 const bfd_size_type external_reloc_size = backend->external_reloc_size;
2325 void (* const adjust_reloc_out) (bfd *, const arelent *, struct internal_reloc *)
2326 = backend->adjust_reloc_out;
2327 void (* const swap_reloc_out) (bfd *, const struct internal_reloc *, void *)
2328 = backend->swap_reloc_out;
2329 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
2330 HDRR * const symhdr = &debug->symbolic_header;
2331 asection *current;
2332 unsigned int count;
2333 bfd_size_type reloc_size;
2334 bfd_size_type text_size;
2335 bfd_vma text_start;
2336 bfd_boolean set_text_start;
2337 bfd_size_type data_size;
2338 bfd_vma data_start;
2339 bfd_boolean set_data_start;
2340 bfd_size_type bss_size;
2341 void * buff = NULL;
2342 void * reloc_buff = NULL;
2343 struct internal_filehdr internal_f;
2344 struct internal_aouthdr internal_a;
2345 int i;
2347 /* Determine where the sections and relocs will go in the output
2348 file. */
2349 reloc_size = ecoff_compute_reloc_file_positions (abfd);
2351 count = 1;
2352 for (current = abfd->sections;
2353 current != NULL;
2354 current = current->next)
2356 current->target_index = count;
2357 ++count;
2360 if ((abfd->flags & D_PAGED) != 0)
2361 text_size = _bfd_ecoff_sizeof_headers (abfd, FALSE);
2362 else
2363 text_size = 0;
2364 text_start = 0;
2365 set_text_start = FALSE;
2366 data_size = 0;
2367 data_start = 0;
2368 set_data_start = FALSE;
2369 bss_size = 0;
2371 /* Write section headers to the file. */
2373 /* Allocate buff big enough to hold a section header,
2374 file header, or a.out header. */
2376 bfd_size_type siz;
2378 siz = scnhsz;
2379 if (siz < filhsz)
2380 siz = filhsz;
2381 if (siz < aoutsz)
2382 siz = aoutsz;
2383 buff = bfd_malloc (siz);
2384 if (buff == NULL)
2385 goto error_return;
2388 internal_f.f_nscns = 0;
2389 if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0)
2390 goto error_return;
2392 for (current = abfd->sections;
2393 current != NULL;
2394 current = current->next)
2396 struct internal_scnhdr section;
2397 bfd_vma vma;
2399 ++internal_f.f_nscns;
2401 strncpy (section.s_name, current->name, sizeof section.s_name);
2403 /* This seems to be correct for Irix 4 shared libraries. */
2404 vma = bfd_get_section_vma (abfd, current);
2405 if (streq (current->name, _LIB))
2406 section.s_vaddr = 0;
2407 else
2408 section.s_vaddr = vma;
2410 section.s_paddr = current->lma;
2411 section.s_size = current->size;
2413 /* If this section is unloadable then the scnptr will be 0. */
2414 if ((current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2415 section.s_scnptr = 0;
2416 else
2417 section.s_scnptr = current->filepos;
2418 section.s_relptr = current->rel_filepos;
2420 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2421 object file produced by the assembler is supposed to point to
2422 information about how much room is required by objects of
2423 various different sizes. I think this only matters if we
2424 want the linker to compute the best size to use, or
2425 something. I don't know what happens if the information is
2426 not present. */
2427 if (! streq (current->name, _PDATA))
2428 section.s_lnnoptr = 0;
2429 else
2431 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2432 hold the number of entries in the section (each entry is
2433 8 bytes). We stored this in the line_filepos field in
2434 ecoff_compute_section_file_positions. */
2435 section.s_lnnoptr = current->line_filepos;
2438 section.s_nreloc = current->reloc_count;
2439 section.s_nlnno = 0;
2440 section.s_flags = ecoff_sec_to_styp_flags (current->name,
2441 current->flags);
2443 if (bfd_coff_swap_scnhdr_out (abfd, (void *) &section, buff) == 0
2444 || bfd_bwrite (buff, scnhsz, abfd) != scnhsz)
2445 goto error_return;
2447 if ((section.s_flags & STYP_TEXT) != 0
2448 || ((section.s_flags & STYP_RDATA) != 0
2449 && ecoff_data (abfd)->rdata_in_text)
2450 || section.s_flags == STYP_PDATA
2451 || (section.s_flags & STYP_DYNAMIC) != 0
2452 || (section.s_flags & STYP_LIBLIST) != 0
2453 || (section.s_flags & STYP_RELDYN) != 0
2454 || section.s_flags == STYP_CONFLIC
2455 || (section.s_flags & STYP_DYNSTR) != 0
2456 || (section.s_flags & STYP_DYNSYM) != 0
2457 || (section.s_flags & STYP_HASH) != 0
2458 || (section.s_flags & STYP_ECOFF_INIT) != 0
2459 || (section.s_flags & STYP_ECOFF_FINI) != 0
2460 || section.s_flags == STYP_RCONST)
2462 text_size += current->size;
2463 if (! set_text_start || text_start > vma)
2465 text_start = vma;
2466 set_text_start = TRUE;
2469 else if ((section.s_flags & STYP_RDATA) != 0
2470 || (section.s_flags & STYP_DATA) != 0
2471 || (section.s_flags & STYP_LITA) != 0
2472 || (section.s_flags & STYP_LIT8) != 0
2473 || (section.s_flags & STYP_LIT4) != 0
2474 || (section.s_flags & STYP_SDATA) != 0
2475 || section.s_flags == STYP_XDATA
2476 || (section.s_flags & STYP_GOT) != 0)
2478 data_size += current->size;
2479 if (! set_data_start || data_start > vma)
2481 data_start = vma;
2482 set_data_start = TRUE;
2485 else if ((section.s_flags & STYP_BSS) != 0
2486 || (section.s_flags & STYP_SBSS) != 0)
2487 bss_size += current->size;
2488 else if (section.s_flags == 0
2489 || (section.s_flags & STYP_ECOFF_LIB) != 0
2490 || section.s_flags == STYP_COMMENT)
2491 /* Do nothing. */ ;
2492 else
2493 abort ();
2496 /* Set up the file header. */
2497 internal_f.f_magic = ecoff_get_magic (abfd);
2499 /* We will NOT put a fucking timestamp in the header here. Every
2500 time you put it back, I will come in and take it out again. I'm
2501 sorry. This field does not belong here. We fill it with a 0 so
2502 it compares the same but is not a reasonable time. --
2503 gnu@cygnus.com. */
2504 internal_f.f_timdat = 0;
2506 if (bfd_get_symcount (abfd) != 0)
2508 /* The ECOFF f_nsyms field is not actually the number of
2509 symbols, it's the size of symbolic information header. */
2510 internal_f.f_nsyms = external_hdr_size;
2511 internal_f.f_symptr = ecoff_data (abfd)->sym_filepos;
2513 else
2515 internal_f.f_nsyms = 0;
2516 internal_f.f_symptr = 0;
2519 internal_f.f_opthdr = aoutsz;
2521 internal_f.f_flags = F_LNNO;
2522 if (reloc_size == 0)
2523 internal_f.f_flags |= F_RELFLG;
2524 if (bfd_get_symcount (abfd) == 0)
2525 internal_f.f_flags |= F_LSYMS;
2526 if (abfd->flags & EXEC_P)
2527 internal_f.f_flags |= F_EXEC;
2529 if (bfd_little_endian (abfd))
2530 internal_f.f_flags |= F_AR32WR;
2531 else
2532 internal_f.f_flags |= F_AR32W;
2534 /* Set up the ``optional'' header. */
2535 if ((abfd->flags & D_PAGED) != 0)
2536 internal_a.magic = ECOFF_AOUT_ZMAGIC;
2537 else
2538 internal_a.magic = ECOFF_AOUT_OMAGIC;
2540 /* FIXME: Is this really correct? */
2541 internal_a.vstamp = symhdr->vstamp;
2543 /* At least on Ultrix, these have to be rounded to page boundaries.
2544 FIXME: Is this true on other platforms? */
2545 if ((abfd->flags & D_PAGED) != 0)
2547 internal_a.tsize = (text_size + round - 1) &~ (round - 1);
2548 internal_a.text_start = text_start &~ (round - 1);
2549 internal_a.dsize = (data_size + round - 1) &~ (round - 1);
2550 internal_a.data_start = data_start &~ (round - 1);
2552 else
2554 internal_a.tsize = text_size;
2555 internal_a.text_start = text_start;
2556 internal_a.dsize = data_size;
2557 internal_a.data_start = data_start;
2560 /* On Ultrix, the initial portions of the .sbss and .bss segments
2561 are at the end of the data section. The bsize field in the
2562 optional header records how many bss bytes are required beyond
2563 those in the data section. The value is not rounded to a page
2564 boundary. */
2565 if (bss_size < internal_a.dsize - data_size)
2566 bss_size = 0;
2567 else
2568 bss_size -= internal_a.dsize - data_size;
2569 internal_a.bsize = bss_size;
2570 internal_a.bss_start = internal_a.data_start + internal_a.dsize;
2572 internal_a.entry = bfd_get_start_address (abfd);
2574 internal_a.gp_value = ecoff_data (abfd)->gp;
2576 internal_a.gprmask = ecoff_data (abfd)->gprmask;
2577 internal_a.fprmask = ecoff_data (abfd)->fprmask;
2578 for (i = 0; i < 4; i++)
2579 internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i];
2581 /* Let the backend adjust the headers if necessary. */
2582 if (backend->adjust_headers)
2584 if (! (*backend->adjust_headers) (abfd, &internal_f, &internal_a))
2585 goto error_return;
2588 /* Write out the file header and the optional header. */
2589 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
2590 goto error_return;
2592 bfd_coff_swap_filehdr_out (abfd, (void *) &internal_f, buff);
2593 if (bfd_bwrite (buff, filhsz, abfd) != filhsz)
2594 goto error_return;
2596 bfd_coff_swap_aouthdr_out (abfd, (void *) &internal_a, buff);
2597 if (bfd_bwrite (buff, aoutsz, abfd) != aoutsz)
2598 goto error_return;
2600 /* Build the external symbol information. This must be done before
2601 writing out the relocs so that we know the symbol indices. We
2602 don't do this if this BFD was created by the backend linker,
2603 since it will have already handled the symbols and relocs. */
2604 if (! ecoff_data (abfd)->linker)
2606 symhdr->iextMax = 0;
2607 symhdr->issExtMax = 0;
2608 debug->external_ext = debug->external_ext_end = NULL;
2609 debug->ssext = debug->ssext_end = NULL;
2610 if (! bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap,
2611 (abfd->flags & EXEC_P) == 0,
2612 ecoff_get_extr, ecoff_set_index))
2613 goto error_return;
2615 /* Write out the relocs. */
2616 for (current = abfd->sections;
2617 current != NULL;
2618 current = current->next)
2620 arelent **reloc_ptr_ptr;
2621 arelent **reloc_end;
2622 char *out_ptr;
2623 bfd_size_type amt;
2625 if (current->reloc_count == 0)
2626 continue;
2628 amt = current->reloc_count * external_reloc_size;
2629 reloc_buff = bfd_alloc (abfd, amt);
2630 if (reloc_buff == NULL)
2631 goto error_return;
2633 reloc_ptr_ptr = current->orelocation;
2634 reloc_end = reloc_ptr_ptr + current->reloc_count;
2635 out_ptr = (char *) reloc_buff;
2637 for (;
2638 reloc_ptr_ptr < reloc_end;
2639 reloc_ptr_ptr++, out_ptr += external_reloc_size)
2641 arelent *reloc;
2642 asymbol *sym;
2643 struct internal_reloc in;
2645 memset ((void *) &in, 0, sizeof in);
2647 reloc = *reloc_ptr_ptr;
2648 sym = *reloc->sym_ptr_ptr;
2650 /* If the howto field has not been initialised then skip this reloc.
2651 This assumes that an error message has been issued elsewhere. */
2652 if (reloc->howto == NULL)
2653 continue;
2655 in.r_vaddr = (reloc->address
2656 + bfd_get_section_vma (abfd, current));
2657 in.r_type = reloc->howto->type;
2659 if ((sym->flags & BSF_SECTION_SYM) == 0)
2661 in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr);
2662 in.r_extern = 1;
2664 else
2666 const char *name;
2667 unsigned int i;
2668 static struct
2670 const char * name;
2671 long r_symndx;
2673 section_symndx [] =
2675 { _TEXT, RELOC_SECTION_TEXT },
2676 { _RDATA, RELOC_SECTION_RDATA },
2677 { _DATA, RELOC_SECTION_DATA },
2678 { _SDATA, RELOC_SECTION_SDATA },
2679 { _SBSS, RELOC_SECTION_SBSS },
2680 { _BSS, RELOC_SECTION_BSS },
2681 { _INIT, RELOC_SECTION_INIT },
2682 { _LIT8, RELOC_SECTION_LIT8 },
2683 { _LIT4, RELOC_SECTION_LIT4 },
2684 { _XDATA, RELOC_SECTION_XDATA },
2685 { _PDATA, RELOC_SECTION_PDATA },
2686 { _FINI, RELOC_SECTION_FINI },
2687 { _LITA, RELOC_SECTION_LITA },
2688 { "*ABS*", RELOC_SECTION_ABS },
2689 { _RCONST, RELOC_SECTION_RCONST }
2692 name = bfd_get_section_name (abfd, bfd_get_section (sym));
2694 for (i = 0; i < ARRAY_SIZE (section_symndx); i++)
2695 if (streq (name, section_symndx[i].name))
2697 in.r_symndx = section_symndx[i].r_symndx;
2698 break;
2701 if (i == ARRAY_SIZE (section_symndx))
2702 abort ();
2703 in.r_extern = 0;
2706 (*adjust_reloc_out) (abfd, reloc, &in);
2708 (*swap_reloc_out) (abfd, &in, (void *) out_ptr);
2711 if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0)
2712 goto error_return;
2713 amt = current->reloc_count * external_reloc_size;
2714 if (bfd_bwrite (reloc_buff, amt, abfd) != amt)
2715 goto error_return;
2716 bfd_release (abfd, reloc_buff);
2717 reloc_buff = NULL;
2720 /* Write out the symbolic debugging information. */
2721 if (bfd_get_symcount (abfd) > 0)
2723 /* Write out the debugging information. */
2724 if (! bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap,
2725 ecoff_data (abfd)->sym_filepos))
2726 goto error_return;
2730 /* The .bss section of a demand paged executable must receive an
2731 entire page. If there are symbols, the symbols will start on the
2732 next page. If there are no symbols, we must fill out the page by
2733 hand. */
2734 if (bfd_get_symcount (abfd) == 0
2735 && (abfd->flags & EXEC_P) != 0
2736 && (abfd->flags & D_PAGED) != 0)
2738 char c;
2740 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2741 SEEK_SET) != 0)
2742 goto error_return;
2743 if (bfd_bread (&c, (bfd_size_type) 1, abfd) == 0)
2744 c = 0;
2745 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2746 SEEK_SET) != 0)
2747 goto error_return;
2748 if (bfd_bwrite (&c, (bfd_size_type) 1, abfd) != 1)
2749 goto error_return;
2752 if (reloc_buff != NULL)
2753 bfd_release (abfd, reloc_buff);
2754 if (buff != NULL)
2755 free (buff);
2756 return TRUE;
2757 error_return:
2758 if (reloc_buff != NULL)
2759 bfd_release (abfd, reloc_buff);
2760 if (buff != NULL)
2761 free (buff);
2762 return FALSE;
2765 /* Archive handling. ECOFF uses what appears to be a unique type of
2766 archive header (armap). The byte ordering of the armap and the
2767 contents are encoded in the name of the armap itself. At least for
2768 now, we only support archives with the same byte ordering in the
2769 armap and the contents.
2771 The first four bytes in the armap are the number of symbol
2772 definitions. This is always a power of two.
2774 This is followed by the symbol definitions. Each symbol definition
2775 occupies 8 bytes. The first four bytes are the offset from the
2776 start of the armap strings to the null-terminated string naming
2777 this symbol. The second four bytes are the file offset to the
2778 archive member which defines this symbol. If the second four bytes
2779 are 0, then this is not actually a symbol definition, and it should
2780 be ignored.
2782 The symbols are hashed into the armap with a closed hashing scheme.
2783 See the functions below for the details of the algorithm.
2785 After the symbol definitions comes four bytes holding the size of
2786 the string table, followed by the string table itself. */
2788 /* The name of an archive headers looks like this:
2789 __________E[BL]E[BL]_ (with a trailing space).
2790 The trailing space is changed to an X if the archive is changed to
2791 indicate that the armap is out of date.
2793 The Alpha seems to use ________64E[BL]E[BL]_. */
2795 #define ARMAP_BIG_ENDIAN 'B'
2796 #define ARMAP_LITTLE_ENDIAN 'L'
2797 #define ARMAP_MARKER 'E'
2798 #define ARMAP_START_LENGTH 10
2799 #define ARMAP_HEADER_MARKER_INDEX 10
2800 #define ARMAP_HEADER_ENDIAN_INDEX 11
2801 #define ARMAP_OBJECT_MARKER_INDEX 12
2802 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2803 #define ARMAP_END_INDEX 14
2804 #define ARMAP_END "_ "
2806 /* This is a magic number used in the hashing algorithm. */
2807 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2809 /* This returns the hash value to use for a string. It also sets
2810 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2811 is the number of entries in the hash table, and HLOG is the log
2812 base 2 of SIZE. */
2814 static unsigned int
2815 ecoff_armap_hash (const char *s,
2816 unsigned int *rehash,
2817 unsigned int size,
2818 unsigned int hlog)
2820 unsigned int hash;
2822 if (hlog == 0)
2823 return 0;
2824 hash = *s++;
2825 while (*s != '\0')
2826 hash = ((hash >> 27) | (hash << 5)) + *s++;
2827 hash *= ARMAP_HASH_MAGIC;
2828 *rehash = (hash & (size - 1)) | 1;
2829 return hash >> (32 - hlog);
2832 /* Read in the armap. */
2834 bfd_boolean
2835 _bfd_ecoff_slurp_armap (bfd *abfd)
2837 char nextname[17];
2838 unsigned int i;
2839 struct areltdata *mapdata;
2840 bfd_size_type parsed_size;
2841 char *raw_armap;
2842 struct artdata *ardata;
2843 unsigned int count;
2844 char *raw_ptr;
2845 struct symdef *symdef_ptr;
2846 char *stringbase;
2847 bfd_size_type amt;
2849 /* Get the name of the first element. */
2850 i = bfd_bread ((void *) nextname, (bfd_size_type) 16, abfd);
2851 if (i == 0)
2852 return TRUE;
2853 if (i != 16)
2854 return FALSE;
2856 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
2857 return FALSE;
2859 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2860 standard COFF armap. We could move the ECOFF armap stuff into
2861 bfd_slurp_armap, but that seems inappropriate since no other
2862 target uses this format. Instead, we check directly for a COFF
2863 armap. */
2864 if (strneq (nextname, "/ ", 16))
2865 return bfd_slurp_armap (abfd);
2867 /* See if the first element is an armap. */
2868 if (! strneq (nextname, ecoff_backend (abfd)->armap_start, ARMAP_START_LENGTH)
2869 || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER
2870 || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2871 && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2872 || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER
2873 || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2874 && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2875 || ! strneq (nextname + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1))
2877 bfd_has_map (abfd) = FALSE;
2878 return TRUE;
2881 /* Make sure we have the right byte ordering. */
2882 if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2883 ^ (bfd_header_big_endian (abfd)))
2884 || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2885 ^ (bfd_big_endian (abfd))))
2887 bfd_set_error (bfd_error_wrong_format);
2888 return FALSE;
2891 /* Read in the armap. */
2892 ardata = bfd_ardata (abfd);
2893 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
2894 if (mapdata == NULL)
2895 return FALSE;
2896 parsed_size = mapdata->parsed_size;
2897 bfd_release (abfd, (void *) mapdata);
2899 raw_armap = bfd_alloc (abfd, parsed_size);
2900 if (raw_armap == NULL)
2901 return FALSE;
2903 if (bfd_bread ((void *) raw_armap, parsed_size, abfd) != parsed_size)
2905 if (bfd_get_error () != bfd_error_system_call)
2906 bfd_set_error (bfd_error_malformed_archive);
2907 bfd_release (abfd, (void *) raw_armap);
2908 return FALSE;
2911 ardata->tdata = (void *) raw_armap;
2913 count = H_GET_32 (abfd, raw_armap);
2915 ardata->symdef_count = 0;
2916 ardata->cache = NULL;
2918 /* This code used to overlay the symdefs over the raw archive data,
2919 but that doesn't work on a 64 bit host. */
2920 stringbase = raw_armap + count * 8 + 8;
2922 #ifdef CHECK_ARMAP_HASH
2924 unsigned int hlog;
2926 /* Double check that I have the hashing algorithm right by making
2927 sure that every symbol can be looked up successfully. */
2928 hlog = 0;
2929 for (i = 1; i < count; i <<= 1)
2930 hlog++;
2931 BFD_ASSERT (i == count);
2933 raw_ptr = raw_armap + 4;
2934 for (i = 0; i < count; i++, raw_ptr += 8)
2936 unsigned int name_offset, file_offset;
2937 unsigned int hash, rehash, srch;
2939 name_offset = H_GET_32 (abfd, raw_ptr);
2940 file_offset = H_GET_32 (abfd, (raw_ptr + 4));
2941 if (file_offset == 0)
2942 continue;
2943 hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count,
2944 hlog);
2945 if (hash == i)
2946 continue;
2948 /* See if we can rehash to this location. */
2949 for (srch = (hash + rehash) & (count - 1);
2950 srch != hash && srch != i;
2951 srch = (srch + rehash) & (count - 1))
2952 BFD_ASSERT (H_GET_32 (abfd, (raw_armap + 8 + srch * 8)) != 0);
2953 BFD_ASSERT (srch == i);
2957 #endif /* CHECK_ARMAP_HASH */
2959 raw_ptr = raw_armap + 4;
2960 for (i = 0; i < count; i++, raw_ptr += 8)
2961 if (H_GET_32 (abfd, (raw_ptr + 4)) != 0)
2962 ++ardata->symdef_count;
2964 amt = ardata->symdef_count;
2965 amt *= sizeof (struct symdef);
2966 symdef_ptr = bfd_alloc (abfd, amt);
2967 if (!symdef_ptr)
2968 return FALSE;
2970 ardata->symdefs = (carsym *) symdef_ptr;
2972 raw_ptr = raw_armap + 4;
2973 for (i = 0; i < count; i++, raw_ptr += 8)
2975 unsigned int name_offset, file_offset;
2977 file_offset = H_GET_32 (abfd, (raw_ptr + 4));
2978 if (file_offset == 0)
2979 continue;
2980 name_offset = H_GET_32 (abfd, raw_ptr);
2981 symdef_ptr->s.name = stringbase + name_offset;
2982 symdef_ptr->file_offset = file_offset;
2983 ++symdef_ptr;
2986 ardata->first_file_filepos = bfd_tell (abfd);
2987 /* Pad to an even boundary. */
2988 ardata->first_file_filepos += ardata->first_file_filepos % 2;
2990 bfd_has_map (abfd) = TRUE;
2992 return TRUE;
2995 /* Write out an armap. */
2997 bfd_boolean
2998 _bfd_ecoff_write_armap (bfd *abfd,
2999 unsigned int elength,
3000 struct orl *map,
3001 unsigned int orl_count,
3002 int stridx)
3004 unsigned int hashsize, hashlog;
3005 bfd_size_type symdefsize;
3006 int padit;
3007 unsigned int stringsize;
3008 unsigned int mapsize;
3009 file_ptr firstreal;
3010 struct ar_hdr hdr;
3011 struct stat statbuf;
3012 unsigned int i;
3013 bfd_byte temp[4];
3014 bfd_byte *hashtable;
3015 bfd *current;
3016 bfd *last_elt;
3018 /* Ultrix appears to use as a hash table size the least power of two
3019 greater than twice the number of entries. */
3020 for (hashlog = 0; ((unsigned int) 1 << hashlog) <= 2 * orl_count; hashlog++)
3022 hashsize = 1 << hashlog;
3024 symdefsize = hashsize * 8;
3025 padit = stridx % 2;
3026 stringsize = stridx + padit;
3028 /* Include 8 bytes to store symdefsize and stringsize in output. */
3029 mapsize = symdefsize + stringsize + 8;
3031 firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength;
3033 memset ((void *) &hdr, 0, sizeof hdr);
3035 /* Work out the ECOFF armap name. */
3036 strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start);
3037 hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER;
3038 hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] =
3039 (bfd_header_big_endian (abfd)
3040 ? ARMAP_BIG_ENDIAN
3041 : ARMAP_LITTLE_ENDIAN);
3042 hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER;
3043 hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] =
3044 bfd_big_endian (abfd) ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN;
3045 memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1);
3047 /* Write the timestamp of the archive header to be just a little bit
3048 later than the timestamp of the file, otherwise the linker will
3049 complain that the index is out of date. Actually, the Ultrix
3050 linker just checks the archive name; the GNU linker may check the
3051 date. */
3052 stat (abfd->filename, &statbuf);
3053 sprintf (hdr.ar_date, "%ld", (long) (statbuf.st_mtime + 60));
3055 /* The DECstation uses zeroes for the uid, gid and mode of the
3056 armap. */
3057 hdr.ar_uid[0] = '0';
3058 hdr.ar_gid[0] = '0';
3059 /* Building gcc ends up extracting the armap as a file - twice. */
3060 hdr.ar_mode[0] = '6';
3061 hdr.ar_mode[1] = '4';
3062 hdr.ar_mode[2] = '4';
3064 sprintf (hdr.ar_size, "%-10d", (int) mapsize);
3066 hdr.ar_fmag[0] = '`';
3067 hdr.ar_fmag[1] = '\012';
3069 /* Turn all null bytes in the header into spaces. */
3070 for (i = 0; i < sizeof (struct ar_hdr); i++)
3071 if (((char *) (&hdr))[i] == '\0')
3072 (((char *) (&hdr))[i]) = ' ';
3074 if (bfd_bwrite ((void *) &hdr, (bfd_size_type) sizeof (struct ar_hdr), abfd)
3075 != sizeof (struct ar_hdr))
3076 return FALSE;
3078 H_PUT_32 (abfd, hashsize, temp);
3079 if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4)
3080 return FALSE;
3082 hashtable = bfd_zalloc (abfd, symdefsize);
3083 if (!hashtable)
3084 return FALSE;
3086 current = abfd->archive_head;
3087 last_elt = current;
3088 for (i = 0; i < orl_count; i++)
3090 unsigned int hash, rehash;
3092 /* Advance firstreal to the file position of this archive
3093 element. */
3094 if (map[i].u.abfd != last_elt)
3098 firstreal += arelt_size (current) + sizeof (struct ar_hdr);
3099 firstreal += firstreal % 2;
3100 current = current->next;
3102 while (current != map[i].u.abfd);
3105 last_elt = current;
3107 hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog);
3108 if (H_GET_32 (abfd, (hashtable + (hash * 8) + 4)) != 0)
3110 unsigned int srch;
3112 /* The desired slot is already taken. */
3113 for (srch = (hash + rehash) & (hashsize - 1);
3114 srch != hash;
3115 srch = (srch + rehash) & (hashsize - 1))
3116 if (H_GET_32 (abfd, (hashtable + (srch * 8) + 4)) == 0)
3117 break;
3119 BFD_ASSERT (srch != hash);
3121 hash = srch;
3124 H_PUT_32 (abfd, map[i].namidx, (hashtable + hash * 8));
3125 H_PUT_32 (abfd, firstreal, (hashtable + hash * 8 + 4));
3128 if (bfd_bwrite ((void *) hashtable, symdefsize, abfd) != symdefsize)
3129 return FALSE;
3131 bfd_release (abfd, hashtable);
3133 /* Now write the strings. */
3134 H_PUT_32 (abfd, stringsize, temp);
3135 if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4)
3136 return FALSE;
3137 for (i = 0; i < orl_count; i++)
3139 bfd_size_type len;
3141 len = strlen (*map[i].name) + 1;
3142 if (bfd_bwrite ((void *) (*map[i].name), len, abfd) != len)
3143 return FALSE;
3146 /* The spec sez this should be a newline. But in order to be
3147 bug-compatible for DECstation ar we use a null. */
3148 if (padit)
3150 if (bfd_bwrite ("", (bfd_size_type) 1, abfd) != 1)
3151 return FALSE;
3154 return TRUE;
3157 /* See whether this BFD is an archive. If it is, read in the armap
3158 and the extended name table. */
3160 const bfd_target *
3161 _bfd_ecoff_archive_p (bfd *abfd)
3163 struct artdata *tdata_hold;
3164 char armag[SARMAG + 1];
3165 bfd_size_type amt;
3167 if (bfd_bread ((void *) armag, (bfd_size_type) SARMAG, abfd) != SARMAG)
3169 if (bfd_get_error () != bfd_error_system_call)
3170 bfd_set_error (bfd_error_wrong_format);
3171 return NULL;
3174 if (! strneq (armag, ARMAG, SARMAG))
3176 bfd_set_error (bfd_error_wrong_format);
3177 return NULL;
3180 tdata_hold = bfd_ardata (abfd);
3182 amt = sizeof (struct artdata);
3183 bfd_ardata (abfd) = bfd_zalloc (abfd, amt);
3184 if (bfd_ardata (abfd) == NULL)
3186 bfd_ardata (abfd) = tdata_hold;
3187 return NULL;
3190 bfd_ardata (abfd)->first_file_filepos = SARMAG;
3191 /* Already cleared by bfd_zalloc above.
3192 bfd_ardata (abfd)->cache = NULL;
3193 bfd_ardata (abfd)->archive_head = NULL;
3194 bfd_ardata (abfd)->symdefs = NULL;
3195 bfd_ardata (abfd)->extended_names = NULL;
3196 bfd_ardata (abfd)->extended_names_size = 0;
3197 bfd_ardata (abfd)->tdata = NULL; */
3199 if (! _bfd_ecoff_slurp_armap (abfd)
3200 || ! _bfd_ecoff_slurp_extended_name_table (abfd))
3202 bfd_release (abfd, bfd_ardata (abfd));
3203 bfd_ardata (abfd) = tdata_hold;
3204 return NULL;
3207 if (bfd_has_map (abfd))
3209 bfd *first;
3211 /* This archive has a map, so we may presume that the contents
3212 are object files. Make sure that if the first file in the
3213 archive can be recognized as an object file, it is for this
3214 target. If not, assume that this is the wrong format. If
3215 the first file is not an object file, somebody is doing
3216 something weird, and we permit it so that ar -t will work. */
3218 first = bfd_openr_next_archived_file (abfd, NULL);
3219 if (first != NULL)
3221 first->target_defaulted = FALSE;
3222 if (bfd_check_format (first, bfd_object)
3223 && first->xvec != abfd->xvec)
3225 /* We ought to close `first' here, but we can't, because
3226 we have no way to remove it from the archive cache.
3227 It's almost impossible to figure out when we can
3228 release bfd_ardata. FIXME. */
3229 bfd_set_error (bfd_error_wrong_object_format);
3230 bfd_ardata (abfd) = tdata_hold;
3231 return NULL;
3233 /* And we ought to close `first' here too. */
3237 return abfd->xvec;
3240 /* ECOFF linker code. */
3242 /* Routine to create an entry in an ECOFF link hash table. */
3244 static struct bfd_hash_entry *
3245 ecoff_link_hash_newfunc (struct bfd_hash_entry *entry,
3246 struct bfd_hash_table *table,
3247 const char *string)
3249 struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry;
3251 /* Allocate the structure if it has not already been allocated by a
3252 subclass. */
3253 if (ret == NULL)
3254 ret = ((struct ecoff_link_hash_entry *)
3255 bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry)));
3256 if (ret == NULL)
3257 return NULL;
3259 /* Call the allocation method of the superclass. */
3260 ret = ((struct ecoff_link_hash_entry *)
3261 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3262 table, string));
3264 if (ret)
3266 /* Set local fields. */
3267 ret->indx = -1;
3268 ret->abfd = NULL;
3269 ret->written = 0;
3270 ret->small = 0;
3272 memset ((void *) &ret->esym, 0, sizeof ret->esym);
3274 return (struct bfd_hash_entry *) ret;
3277 /* Create an ECOFF link hash table. */
3279 struct bfd_link_hash_table *
3280 _bfd_ecoff_bfd_link_hash_table_create (bfd *abfd)
3282 struct ecoff_link_hash_table *ret;
3283 bfd_size_type amt = sizeof (struct ecoff_link_hash_table);
3285 ret = bfd_malloc (amt);
3286 if (ret == NULL)
3287 return NULL;
3288 if (!_bfd_link_hash_table_init (&ret->root, abfd,
3289 ecoff_link_hash_newfunc,
3290 sizeof (struct ecoff_link_hash_entry)))
3292 free (ret);
3293 return NULL;
3295 return &ret->root;
3298 /* Look up an entry in an ECOFF link hash table. */
3300 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3301 ((struct ecoff_link_hash_entry *) \
3302 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3304 /* Traverse an ECOFF link hash table. */
3306 #define ecoff_link_hash_traverse(table, func, info) \
3307 (bfd_link_hash_traverse \
3308 (&(table)->root, \
3309 (bfd_boolean (*) (struct bfd_link_hash_entry *, void *)) (func), \
3310 (info)))
3312 /* Get the ECOFF link hash table from the info structure. This is
3313 just a cast. */
3315 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3317 /* Add the external symbols of an object file to the global linker
3318 hash table. The external symbols and strings we are passed are
3319 just allocated on the stack, and will be discarded. We must
3320 explicitly save any information we may need later on in the link.
3321 We do not want to read the external symbol information again. */
3323 static bfd_boolean
3324 ecoff_link_add_externals (bfd *abfd,
3325 struct bfd_link_info *info,
3326 void * external_ext,
3327 char *ssext)
3329 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3330 void (* const swap_ext_in) (bfd *, void *, EXTR *)
3331 = backend->debug_swap.swap_ext_in;
3332 bfd_size_type external_ext_size = backend->debug_swap.external_ext_size;
3333 unsigned long ext_count;
3334 struct bfd_link_hash_entry **sym_hash;
3335 char *ext_ptr;
3336 char *ext_end;
3337 bfd_size_type amt;
3339 ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
3341 amt = ext_count;
3342 amt *= sizeof (struct bfd_link_hash_entry *);
3343 sym_hash = bfd_alloc (abfd, amt);
3344 if (!sym_hash)
3345 return FALSE;
3346 ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash;
3348 ext_ptr = (char *) external_ext;
3349 ext_end = ext_ptr + ext_count * external_ext_size;
3350 for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++)
3352 EXTR esym;
3353 bfd_boolean skip;
3354 bfd_vma value;
3355 asection *section;
3356 const char *name;
3357 struct ecoff_link_hash_entry *h;
3359 *sym_hash = NULL;
3361 (*swap_ext_in) (abfd, (void *) ext_ptr, &esym);
3363 /* Skip debugging symbols. */
3364 skip = FALSE;
3365 switch (esym.asym.st)
3367 case stGlobal:
3368 case stStatic:
3369 case stLabel:
3370 case stProc:
3371 case stStaticProc:
3372 break;
3373 default:
3374 skip = TRUE;
3375 break;
3378 if (skip)
3379 continue;
3381 /* Get the information for this symbol. */
3382 value = esym.asym.value;
3383 switch (esym.asym.sc)
3385 default:
3386 case scNil:
3387 case scRegister:
3388 case scCdbLocal:
3389 case scBits:
3390 case scCdbSystem:
3391 case scRegImage:
3392 case scInfo:
3393 case scUserStruct:
3394 case scVar:
3395 case scVarRegister:
3396 case scVariant:
3397 case scBasedVar:
3398 case scXData:
3399 case scPData:
3400 section = NULL;
3401 break;
3402 case scText:
3403 section = bfd_make_section_old_way (abfd, _TEXT);
3404 value -= section->vma;
3405 break;
3406 case scData:
3407 section = bfd_make_section_old_way (abfd, _DATA);
3408 value -= section->vma;
3409 break;
3410 case scBss:
3411 section = bfd_make_section_old_way (abfd, _BSS);
3412 value -= section->vma;
3413 break;
3414 case scAbs:
3415 section = bfd_abs_section_ptr;
3416 break;
3417 case scUndefined:
3418 section = bfd_und_section_ptr;
3419 break;
3420 case scSData:
3421 section = bfd_make_section_old_way (abfd, _SDATA);
3422 value -= section->vma;
3423 break;
3424 case scSBss:
3425 section = bfd_make_section_old_way (abfd, _SBSS);
3426 value -= section->vma;
3427 break;
3428 case scRData:
3429 section = bfd_make_section_old_way (abfd, _RDATA);
3430 value -= section->vma;
3431 break;
3432 case scCommon:
3433 if (value > ecoff_data (abfd)->gp_size)
3435 section = bfd_com_section_ptr;
3436 break;
3438 /* Fall through. */
3439 case scSCommon:
3440 if (ecoff_scom_section.name == NULL)
3442 /* Initialize the small common section. */
3443 ecoff_scom_section.name = SCOMMON;
3444 ecoff_scom_section.flags = SEC_IS_COMMON;
3445 ecoff_scom_section.output_section = &ecoff_scom_section;
3446 ecoff_scom_section.symbol = &ecoff_scom_symbol;
3447 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
3448 ecoff_scom_symbol.name = SCOMMON;
3449 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
3450 ecoff_scom_symbol.section = &ecoff_scom_section;
3451 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
3453 section = &ecoff_scom_section;
3454 break;
3455 case scSUndefined:
3456 section = bfd_und_section_ptr;
3457 break;
3458 case scInit:
3459 section = bfd_make_section_old_way (abfd, _INIT);
3460 value -= section->vma;
3461 break;
3462 case scFini:
3463 section = bfd_make_section_old_way (abfd, _FINI);
3464 value -= section->vma;
3465 break;
3466 case scRConst:
3467 section = bfd_make_section_old_way (abfd, _RCONST);
3468 value -= section->vma;
3469 break;
3472 if (section == NULL)
3473 continue;
3475 name = ssext + esym.asym.iss;
3477 if (! (_bfd_generic_link_add_one_symbol
3478 (info, abfd, name,
3479 (flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL),
3480 section, value, NULL, TRUE, TRUE, sym_hash)))
3481 return FALSE;
3483 h = (struct ecoff_link_hash_entry *) *sym_hash;
3485 /* If we are building an ECOFF hash table, save the external
3486 symbol information. */
3487 if (info->hash->creator->flavour == bfd_get_flavour (abfd))
3489 if (h->abfd == NULL
3490 || (! bfd_is_und_section (section)
3491 && (! bfd_is_com_section (section)
3492 || (h->root.type != bfd_link_hash_defined
3493 && h->root.type != bfd_link_hash_defweak))))
3495 h->abfd = abfd;
3496 h->esym = esym;
3499 /* Remember whether this symbol was small undefined. */
3500 if (esym.asym.sc == scSUndefined)
3501 h->small = 1;
3503 /* If this symbol was ever small undefined, it needs to wind
3504 up in a GP relative section. We can't control the
3505 section of a defined symbol, but we can control the
3506 section of a common symbol. This case is actually needed
3507 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3508 if (h->small
3509 && h->root.type == bfd_link_hash_common
3510 && streq (h->root.u.c.p->section->name, SCOMMON))
3512 h->root.u.c.p->section = bfd_make_section_old_way (abfd,
3513 SCOMMON);
3514 h->root.u.c.p->section->flags = SEC_ALLOC;
3515 if (h->esym.asym.sc == scCommon)
3516 h->esym.asym.sc = scSCommon;
3521 return TRUE;
3524 /* Add symbols from an ECOFF object file to the global linker hash
3525 table. */
3527 static bfd_boolean
3528 ecoff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3530 HDRR *symhdr;
3531 bfd_size_type external_ext_size;
3532 void * external_ext = NULL;
3533 bfd_size_type esize;
3534 char *ssext = NULL;
3535 bfd_boolean result;
3537 if (! ecoff_slurp_symbolic_header (abfd))
3538 return FALSE;
3540 /* If there are no symbols, we don't want it. */
3541 if (bfd_get_symcount (abfd) == 0)
3542 return TRUE;
3544 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3546 /* Read in the external symbols and external strings. */
3547 external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size;
3548 esize = symhdr->iextMax * external_ext_size;
3549 external_ext = bfd_malloc (esize);
3550 if (external_ext == NULL && esize != 0)
3551 goto error_return;
3553 if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0
3554 || bfd_bread (external_ext, esize, abfd) != esize)
3555 goto error_return;
3557 ssext = bfd_malloc ((bfd_size_type) symhdr->issExtMax);
3558 if (ssext == NULL && symhdr->issExtMax != 0)
3559 goto error_return;
3561 if (bfd_seek (abfd, (file_ptr) symhdr->cbSsExtOffset, SEEK_SET) != 0
3562 || (bfd_bread (ssext, (bfd_size_type) symhdr->issExtMax, abfd)
3563 != (bfd_size_type) symhdr->issExtMax))
3564 goto error_return;
3566 result = ecoff_link_add_externals (abfd, info, external_ext, ssext);
3568 if (ssext != NULL)
3569 free (ssext);
3570 if (external_ext != NULL)
3571 free (external_ext);
3572 return result;
3574 error_return:
3575 if (ssext != NULL)
3576 free (ssext);
3577 if (external_ext != NULL)
3578 free (external_ext);
3579 return FALSE;
3582 /* This is called if we used _bfd_generic_link_add_archive_symbols
3583 because we were not dealing with an ECOFF archive. */
3585 static bfd_boolean
3586 ecoff_link_check_archive_element (bfd *abfd,
3587 struct bfd_link_info *info,
3588 bfd_boolean *pneeded)
3590 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3591 void (* const swap_ext_in) (bfd *, void *, EXTR *)
3592 = backend->debug_swap.swap_ext_in;
3593 HDRR *symhdr;
3594 bfd_size_type external_ext_size;
3595 void * external_ext = NULL;
3596 bfd_size_type esize;
3597 char *ssext = NULL;
3598 char *ext_ptr;
3599 char *ext_end;
3601 *pneeded = FALSE;
3603 if (! ecoff_slurp_symbolic_header (abfd))
3604 goto error_return;
3606 /* If there are no symbols, we don't want it. */
3607 if (bfd_get_symcount (abfd) == 0)
3608 goto successful_return;
3610 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3612 /* Read in the external symbols and external strings. */
3613 external_ext_size = backend->debug_swap.external_ext_size;
3614 esize = symhdr->iextMax * external_ext_size;
3615 external_ext = bfd_malloc (esize);
3616 if (external_ext == NULL && esize != 0)
3617 goto error_return;
3619 if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0
3620 || bfd_bread (external_ext, esize, abfd) != esize)
3621 goto error_return;
3623 ssext = bfd_malloc ((bfd_size_type) symhdr->issExtMax);
3624 if (ssext == NULL && symhdr->issExtMax != 0)
3625 goto error_return;
3627 if (bfd_seek (abfd, (file_ptr) symhdr->cbSsExtOffset, SEEK_SET) != 0
3628 || (bfd_bread (ssext, (bfd_size_type) symhdr->issExtMax, abfd)
3629 != (bfd_size_type) symhdr->issExtMax))
3630 goto error_return;
3632 /* Look through the external symbols to see if they define some
3633 symbol that is currently undefined. */
3634 ext_ptr = (char *) external_ext;
3635 ext_end = ext_ptr + esize;
3636 for (; ext_ptr < ext_end; ext_ptr += external_ext_size)
3638 EXTR esym;
3639 bfd_boolean def;
3640 const char *name;
3641 struct bfd_link_hash_entry *h;
3643 (*swap_ext_in) (abfd, (void *) ext_ptr, &esym);
3645 /* See if this symbol defines something. */
3646 if (esym.asym.st != stGlobal
3647 && esym.asym.st != stLabel
3648 && esym.asym.st != stProc)
3649 continue;
3651 switch (esym.asym.sc)
3653 case scText:
3654 case scData:
3655 case scBss:
3656 case scAbs:
3657 case scSData:
3658 case scSBss:
3659 case scRData:
3660 case scCommon:
3661 case scSCommon:
3662 case scInit:
3663 case scFini:
3664 case scRConst:
3665 def = TRUE;
3666 break;
3667 default:
3668 def = FALSE;
3669 break;
3672 if (! def)
3673 continue;
3675 name = ssext + esym.asym.iss;
3676 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
3678 /* Unlike the generic linker, we do not pull in elements because
3679 of common symbols. */
3680 if (h == NULL
3681 || h->type != bfd_link_hash_undefined)
3682 continue;
3684 /* Include this element. */
3685 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3686 goto error_return;
3687 if (! ecoff_link_add_externals (abfd, info, external_ext, ssext))
3688 goto error_return;
3690 *pneeded = TRUE;
3691 goto successful_return;
3694 successful_return:
3695 if (external_ext != NULL)
3696 free (external_ext);
3697 if (ssext != NULL)
3698 free (ssext);
3699 return TRUE;
3700 error_return:
3701 if (external_ext != NULL)
3702 free (external_ext);
3703 if (ssext != NULL)
3704 free (ssext);
3705 return FALSE;
3708 /* Add the symbols from an archive file to the global hash table.
3709 This looks through the undefined symbols, looks each one up in the
3710 archive hash table, and adds any associated object file. We do not
3711 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3712 already have a hash table, so there is no reason to construct
3713 another one. */
3715 static bfd_boolean
3716 ecoff_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
3718 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3719 const bfd_byte *raw_armap;
3720 struct bfd_link_hash_entry **pundef;
3721 unsigned int armap_count;
3722 unsigned int armap_log;
3723 unsigned int i;
3724 const bfd_byte *hashtable;
3725 const char *stringbase;
3727 if (! bfd_has_map (abfd))
3729 /* An empty archive is a special case. */
3730 if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
3731 return TRUE;
3732 bfd_set_error (bfd_error_no_armap);
3733 return FALSE;
3736 /* If we don't have any raw data for this archive, as can happen on
3737 Irix 4.0.5F, we call the generic routine.
3738 FIXME: We should be more clever about this, since someday tdata
3739 may get to something for a generic archive. */
3740 raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata;
3741 if (raw_armap == NULL)
3742 return (_bfd_generic_link_add_archive_symbols
3743 (abfd, info, ecoff_link_check_archive_element));
3745 armap_count = H_GET_32 (abfd, raw_armap);
3747 armap_log = 0;
3748 for (i = 1; i < armap_count; i <<= 1)
3749 armap_log++;
3750 BFD_ASSERT (i == armap_count);
3752 hashtable = raw_armap + 4;
3753 stringbase = (const char *) raw_armap + armap_count * 8 + 8;
3755 /* Look through the list of undefined symbols. */
3756 pundef = &info->hash->undefs;
3757 while (*pundef != NULL)
3759 struct bfd_link_hash_entry *h;
3760 unsigned int hash, rehash;
3761 unsigned int file_offset;
3762 const char *name;
3763 bfd *element;
3765 h = *pundef;
3767 /* When a symbol is defined, it is not necessarily removed from
3768 the list. */
3769 if (h->type != bfd_link_hash_undefined
3770 && h->type != bfd_link_hash_common)
3772 /* Remove this entry from the list, for general cleanliness
3773 and because we are going to look through the list again
3774 if we search any more libraries. We can't remove the
3775 entry if it is the tail, because that would lose any
3776 entries we add to the list later on. */
3777 if (*pundef != info->hash->undefs_tail)
3778 *pundef = (*pundef)->u.undef.next;
3779 else
3780 pundef = &(*pundef)->u.undef.next;
3781 continue;
3784 /* Native ECOFF linkers do not pull in archive elements merely
3785 to satisfy common definitions, so neither do we. We leave
3786 them on the list, though, in case we are linking against some
3787 other object format. */
3788 if (h->type != bfd_link_hash_undefined)
3790 pundef = &(*pundef)->u.undef.next;
3791 continue;
3794 /* Look for this symbol in the archive hash table. */
3795 hash = ecoff_armap_hash (h->root.string, &rehash, armap_count,
3796 armap_log);
3798 file_offset = H_GET_32 (abfd, hashtable + (hash * 8) + 4);
3799 if (file_offset == 0)
3801 /* Nothing in this slot. */
3802 pundef = &(*pundef)->u.undef.next;
3803 continue;
3806 name = stringbase + H_GET_32 (abfd, hashtable + (hash * 8));
3807 if (name[0] != h->root.string[0]
3808 || ! streq (name, h->root.string))
3810 unsigned int srch;
3811 bfd_boolean found;
3813 /* That was the wrong symbol. Try rehashing. */
3814 found = FALSE;
3815 for (srch = (hash + rehash) & (armap_count - 1);
3816 srch != hash;
3817 srch = (srch + rehash) & (armap_count - 1))
3819 file_offset = H_GET_32 (abfd, hashtable + (srch * 8) + 4);
3820 if (file_offset == 0)
3821 break;
3822 name = stringbase + H_GET_32 (abfd, hashtable + (srch * 8));
3823 if (name[0] == h->root.string[0]
3824 && streq (name, h->root.string))
3826 found = TRUE;
3827 break;
3831 if (! found)
3833 pundef = &(*pundef)->u.undef.next;
3834 continue;
3837 hash = srch;
3840 element = (*backend->get_elt_at_filepos) (abfd, (file_ptr) file_offset);
3841 if (element == NULL)
3842 return FALSE;
3844 if (! bfd_check_format (element, bfd_object))
3845 return FALSE;
3847 /* Unlike the generic linker, we know that this element provides
3848 a definition for an undefined symbol and we know that we want
3849 to include it. We don't need to check anything. */
3850 if (! (*info->callbacks->add_archive_element) (info, element, name))
3851 return FALSE;
3852 if (! ecoff_link_add_object_symbols (element, info))
3853 return FALSE;
3855 pundef = &(*pundef)->u.undef.next;
3858 return TRUE;
3861 /* Given an ECOFF BFD, add symbols to the global hash table as
3862 appropriate. */
3864 bfd_boolean
3865 _bfd_ecoff_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
3867 switch (bfd_get_format (abfd))
3869 case bfd_object:
3870 return ecoff_link_add_object_symbols (abfd, info);
3871 case bfd_archive:
3872 return ecoff_link_add_archive_symbols (abfd, info);
3873 default:
3874 bfd_set_error (bfd_error_wrong_format);
3875 return FALSE;
3880 /* ECOFF final link routines. */
3882 /* Structure used to pass information to ecoff_link_write_external. */
3884 struct extsym_info
3886 bfd *abfd;
3887 struct bfd_link_info *info;
3890 /* Accumulate the debugging information for an input BFD into the
3891 output BFD. This must read in the symbolic information of the
3892 input BFD. */
3894 static bfd_boolean
3895 ecoff_final_link_debug_accumulate (bfd *output_bfd,
3896 bfd *input_bfd,
3897 struct bfd_link_info *info,
3898 void * handle)
3900 struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info;
3901 const struct ecoff_debug_swap * const swap =
3902 &ecoff_backend (input_bfd)->debug_swap;
3903 HDRR *symhdr = &debug->symbolic_header;
3904 bfd_boolean ret;
3906 #define READ(ptr, offset, count, size, type) \
3907 if (symhdr->count == 0) \
3908 debug->ptr = NULL; \
3909 else \
3911 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
3912 debug->ptr = bfd_malloc (amt); \
3913 if (debug->ptr == NULL) \
3915 ret = FALSE; \
3916 goto return_something; \
3918 if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3919 || bfd_bread (debug->ptr, amt, input_bfd) != amt) \
3921 ret = FALSE; \
3922 goto return_something; \
3926 /* If raw_syments is not NULL, then the data was already by read by
3927 _bfd_ecoff_slurp_symbolic_info. */
3928 if (ecoff_data (input_bfd)->raw_syments == NULL)
3930 READ (line, cbLineOffset, cbLine, sizeof (unsigned char),
3931 unsigned char *);
3932 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
3933 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
3934 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
3935 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
3936 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
3937 union aux_ext *);
3938 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
3939 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
3940 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
3942 #undef READ
3944 /* We do not read the external strings or the external symbols. */
3946 ret = (bfd_ecoff_debug_accumulate
3947 (handle, output_bfd, &ecoff_data (output_bfd)->debug_info,
3948 &ecoff_backend (output_bfd)->debug_swap,
3949 input_bfd, debug, swap, info));
3951 return_something:
3952 if (ecoff_data (input_bfd)->raw_syments == NULL)
3954 if (debug->line != NULL)
3955 free (debug->line);
3956 if (debug->external_dnr != NULL)
3957 free (debug->external_dnr);
3958 if (debug->external_pdr != NULL)
3959 free (debug->external_pdr);
3960 if (debug->external_sym != NULL)
3961 free (debug->external_sym);
3962 if (debug->external_opt != NULL)
3963 free (debug->external_opt);
3964 if (debug->external_aux != NULL)
3965 free (debug->external_aux);
3966 if (debug->ss != NULL)
3967 free (debug->ss);
3968 if (debug->external_fdr != NULL)
3969 free (debug->external_fdr);
3970 if (debug->external_rfd != NULL)
3971 free (debug->external_rfd);
3973 /* Make sure we don't accidentally follow one of these pointers
3974 into freed memory. */
3975 debug->line = NULL;
3976 debug->external_dnr = NULL;
3977 debug->external_pdr = NULL;
3978 debug->external_sym = NULL;
3979 debug->external_opt = NULL;
3980 debug->external_aux = NULL;
3981 debug->ss = NULL;
3982 debug->external_fdr = NULL;
3983 debug->external_rfd = NULL;
3986 return ret;
3989 /* Relocate and write an ECOFF section into an ECOFF output file. */
3991 static bfd_boolean
3992 ecoff_indirect_link_order (bfd *output_bfd,
3993 struct bfd_link_info *info,
3994 asection *output_section,
3995 struct bfd_link_order *link_order)
3997 asection *input_section;
3998 bfd *input_bfd;
3999 bfd_byte *contents = NULL;
4000 bfd_size_type external_reloc_size;
4001 bfd_size_type external_relocs_size;
4002 void * external_relocs = NULL;
4004 BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
4006 input_section = link_order->u.indirect.section;
4007 input_bfd = input_section->owner;
4008 if (input_section->size == 0)
4009 return TRUE;
4011 BFD_ASSERT (input_section->output_section == output_section);
4012 BFD_ASSERT (input_section->output_offset == link_order->offset);
4013 BFD_ASSERT (input_section->size == link_order->size);
4015 /* Get the section contents. */
4016 if (!bfd_malloc_and_get_section (input_bfd, input_section, &contents))
4017 goto error_return;
4019 /* Get the relocs. If we are relaxing MIPS code, they will already
4020 have been read in. Otherwise, we read them in now. */
4021 external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size;
4022 external_relocs_size = external_reloc_size * input_section->reloc_count;
4024 external_relocs = bfd_malloc (external_relocs_size);
4025 if (external_relocs == NULL && external_relocs_size != 0)
4026 goto error_return;
4028 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4029 || (bfd_bread (external_relocs, external_relocs_size, input_bfd)
4030 != external_relocs_size))
4031 goto error_return;
4033 /* Relocate the section contents. */
4034 if (! ((*ecoff_backend (input_bfd)->relocate_section)
4035 (output_bfd, info, input_bfd, input_section, contents,
4036 external_relocs)))
4037 goto error_return;
4039 /* Write out the relocated section. */
4040 if (! bfd_set_section_contents (output_bfd,
4041 output_section,
4042 contents,
4043 input_section->output_offset,
4044 input_section->size))
4045 goto error_return;
4047 /* If we are producing relocatable output, the relocs were
4048 modified, and we write them out now. We use the reloc_count
4049 field of output_section to keep track of the number of relocs we
4050 have output so far. */
4051 if (info->relocatable)
4053 file_ptr pos = (output_section->rel_filepos
4054 + output_section->reloc_count * external_reloc_size);
4055 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
4056 || (bfd_bwrite (external_relocs, external_relocs_size, output_bfd)
4057 != external_relocs_size))
4058 goto error_return;
4059 output_section->reloc_count += input_section->reloc_count;
4062 if (contents != NULL)
4063 free (contents);
4064 if (external_relocs != NULL)
4065 free (external_relocs);
4066 return TRUE;
4068 error_return:
4069 if (contents != NULL)
4070 free (contents);
4071 if (external_relocs != NULL)
4072 free (external_relocs);
4073 return FALSE;
4076 /* Generate a reloc when linking an ECOFF file. This is a reloc
4077 requested by the linker, and does come from any input file. This
4078 is used to build constructor and destructor tables when linking
4079 with -Ur. */
4081 static bfd_boolean
4082 ecoff_reloc_link_order (bfd *output_bfd,
4083 struct bfd_link_info *info,
4084 asection *output_section,
4085 struct bfd_link_order *link_order)
4087 enum bfd_link_order_type type;
4088 asection *section;
4089 bfd_vma addend;
4090 arelent rel;
4091 struct internal_reloc in;
4092 bfd_size_type external_reloc_size;
4093 bfd_byte *rbuf;
4094 bfd_boolean ok;
4095 file_ptr pos;
4097 type = link_order->type;
4098 section = NULL;
4099 addend = link_order->u.reloc.p->addend;
4101 /* We set up an arelent to pass to the backend adjust_reloc_out
4102 routine. */
4103 rel.address = link_order->offset;
4105 rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
4106 if (rel.howto == 0)
4108 bfd_set_error (bfd_error_bad_value);
4109 return FALSE;
4112 if (type == bfd_section_reloc_link_order)
4114 section = link_order->u.reloc.p->u.section;
4115 rel.sym_ptr_ptr = section->symbol_ptr_ptr;
4117 else
4119 struct bfd_link_hash_entry *h;
4121 /* Treat a reloc against a defined symbol as though it were
4122 actually against the section. */
4123 h = bfd_wrapped_link_hash_lookup (output_bfd, info,
4124 link_order->u.reloc.p->u.name,
4125 FALSE, FALSE, FALSE);
4126 if (h != NULL
4127 && (h->type == bfd_link_hash_defined
4128 || h->type == bfd_link_hash_defweak))
4130 type = bfd_section_reloc_link_order;
4131 section = h->u.def.section->output_section;
4132 /* It seems that we ought to add the symbol value to the
4133 addend here, but in practice it has already been added
4134 because it was passed to constructor_callback. */
4135 addend += section->vma + h->u.def.section->output_offset;
4137 else
4139 /* We can't set up a reloc against a symbol correctly,
4140 because we have no asymbol structure. Currently no
4141 adjust_reloc_out routine cares. */
4142 rel.sym_ptr_ptr = NULL;
4146 /* All ECOFF relocs are in-place. Put the addend into the object
4147 file. */
4149 BFD_ASSERT (rel.howto->partial_inplace);
4150 if (addend != 0)
4152 bfd_size_type size;
4153 bfd_reloc_status_type rstat;
4154 bfd_byte *buf;
4156 size = bfd_get_reloc_size (rel.howto);
4157 buf = bfd_zmalloc (size);
4158 if (buf == NULL)
4159 return FALSE;
4160 rstat = _bfd_relocate_contents (rel.howto, output_bfd,
4161 (bfd_vma) addend, buf);
4162 switch (rstat)
4164 case bfd_reloc_ok:
4165 break;
4166 default:
4167 case bfd_reloc_outofrange:
4168 abort ();
4169 case bfd_reloc_overflow:
4170 if (! ((*info->callbacks->reloc_overflow)
4171 (info, NULL,
4172 (link_order->type == bfd_section_reloc_link_order
4173 ? bfd_section_name (output_bfd, section)
4174 : link_order->u.reloc.p->u.name),
4175 rel.howto->name, addend, NULL,
4176 NULL, (bfd_vma) 0)))
4178 free (buf);
4179 return FALSE;
4181 break;
4183 ok = bfd_set_section_contents (output_bfd, output_section, (void *) buf,
4184 (file_ptr) link_order->offset, size);
4185 free (buf);
4186 if (! ok)
4187 return FALSE;
4190 rel.addend = 0;
4192 /* Move the information into an internal_reloc structure. */
4193 in.r_vaddr = (rel.address
4194 + bfd_get_section_vma (output_bfd, output_section));
4195 in.r_type = rel.howto->type;
4197 if (type == bfd_symbol_reloc_link_order)
4199 struct ecoff_link_hash_entry *h;
4201 h = ((struct ecoff_link_hash_entry *)
4202 bfd_wrapped_link_hash_lookup (output_bfd, info,
4203 link_order->u.reloc.p->u.name,
4204 FALSE, FALSE, TRUE));
4205 if (h != NULL
4206 && h->indx != -1)
4207 in.r_symndx = h->indx;
4208 else
4210 if (! ((*info->callbacks->unattached_reloc)
4211 (info, link_order->u.reloc.p->u.name, NULL,
4212 NULL, (bfd_vma) 0)))
4213 return FALSE;
4214 in.r_symndx = 0;
4216 in.r_extern = 1;
4218 else
4220 const char *name;
4221 unsigned int i;
4222 static struct
4224 const char * name;
4225 long r_symndx;
4227 section_symndx [] =
4229 { _TEXT, RELOC_SECTION_TEXT },
4230 { _RDATA, RELOC_SECTION_RDATA },
4231 { _DATA, RELOC_SECTION_DATA },
4232 { _SDATA, RELOC_SECTION_SDATA },
4233 { _SBSS, RELOC_SECTION_SBSS },
4234 { _BSS, RELOC_SECTION_BSS },
4235 { _INIT, RELOC_SECTION_INIT },
4236 { _LIT8, RELOC_SECTION_LIT8 },
4237 { _LIT4, RELOC_SECTION_LIT4 },
4238 { _XDATA, RELOC_SECTION_XDATA },
4239 { _PDATA, RELOC_SECTION_PDATA },
4240 { _FINI, RELOC_SECTION_FINI },
4241 { _LITA, RELOC_SECTION_LITA },
4242 { "*ABS*", RELOC_SECTION_ABS },
4243 { _RCONST, RELOC_SECTION_RCONST }
4246 name = bfd_get_section_name (output_bfd, section);
4248 for (i = 0; i < ARRAY_SIZE (section_symndx); i++)
4249 if (streq (name, section_symndx[i].name))
4251 in.r_symndx = section_symndx[i].r_symndx;
4252 break;
4255 if (i == ARRAY_SIZE (section_symndx))
4256 abort ();
4258 in.r_extern = 0;
4261 /* Let the BFD backend adjust the reloc. */
4262 (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in);
4264 /* Get some memory and swap out the reloc. */
4265 external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
4266 rbuf = bfd_malloc (external_reloc_size);
4267 if (rbuf == NULL)
4268 return FALSE;
4270 (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (void *) rbuf);
4272 pos = (output_section->rel_filepos
4273 + output_section->reloc_count * external_reloc_size);
4274 ok = (bfd_seek (output_bfd, pos, SEEK_SET) == 0
4275 && (bfd_bwrite ((void *) rbuf, external_reloc_size, output_bfd)
4276 == external_reloc_size));
4278 if (ok)
4279 ++output_section->reloc_count;
4281 free (rbuf);
4283 return ok;
4286 /* Put out information for an external symbol. These come only from
4287 the hash table. */
4289 static bfd_boolean
4290 ecoff_link_write_external (struct ecoff_link_hash_entry *h, void * data)
4292 struct extsym_info *einfo = (struct extsym_info *) data;
4293 bfd *output_bfd = einfo->abfd;
4294 bfd_boolean strip;
4296 if (h->root.type == bfd_link_hash_warning)
4298 h = (struct ecoff_link_hash_entry *) h->root.u.i.link;
4299 if (h->root.type == bfd_link_hash_new)
4300 return TRUE;
4303 /* We need to check if this symbol is being stripped. */
4304 if (h->root.type == bfd_link_hash_undefined
4305 || h->root.type == bfd_link_hash_undefweak)
4306 strip = FALSE;
4307 else if (einfo->info->strip == strip_all
4308 || (einfo->info->strip == strip_some
4309 && bfd_hash_lookup (einfo->info->keep_hash,
4310 h->root.root.string,
4311 FALSE, FALSE) == NULL))
4312 strip = TRUE;
4313 else
4314 strip = FALSE;
4316 if (strip || h->written)
4317 return TRUE;
4319 if (h->abfd == NULL)
4321 h->esym.jmptbl = 0;
4322 h->esym.cobol_main = 0;
4323 h->esym.weakext = 0;
4324 h->esym.reserved = 0;
4325 h->esym.ifd = ifdNil;
4326 h->esym.asym.value = 0;
4327 h->esym.asym.st = stGlobal;
4329 if (h->root.type != bfd_link_hash_defined
4330 && h->root.type != bfd_link_hash_defweak)
4331 h->esym.asym.sc = scAbs;
4332 else
4334 asection *output_section;
4335 const char *name;
4336 unsigned int i;
4337 static struct
4339 const char * name;
4340 int sc;
4342 section_storage_classes [] =
4344 { _TEXT, scText },
4345 { _DATA, scData },
4346 { _SDATA, scSData },
4347 { _RDATA, scRData },
4348 { _BSS, scBss },
4349 { _SBSS, scSBss },
4350 { _INIT, scInit },
4351 { _FINI, scFini },
4352 { _PDATA, scPData },
4353 { _XDATA, scXData },
4354 { _RCONST, scRConst }
4357 output_section = h->root.u.def.section->output_section;
4358 name = bfd_section_name (output_section->owner, output_section);
4360 for (i = 0; i < ARRAY_SIZE (section_storage_classes); i++)
4361 if (streq (name, section_storage_classes[i].name))
4363 h->esym.asym.sc = section_storage_classes[i].sc;
4364 break;
4367 if (i == ARRAY_SIZE (section_storage_classes))
4368 h->esym.asym.sc = scAbs;
4371 h->esym.asym.reserved = 0;
4372 h->esym.asym.index = indexNil;
4374 else if (h->esym.ifd != -1)
4376 struct ecoff_debug_info *debug;
4378 /* Adjust the FDR index for the symbol by that used for the
4379 input BFD. */
4380 debug = &ecoff_data (h->abfd)->debug_info;
4381 BFD_ASSERT (h->esym.ifd >= 0
4382 && h->esym.ifd < debug->symbolic_header.ifdMax);
4383 h->esym.ifd = debug->ifdmap[h->esym.ifd];
4386 switch (h->root.type)
4388 default:
4389 case bfd_link_hash_warning:
4390 case bfd_link_hash_new:
4391 abort ();
4392 case bfd_link_hash_undefined:
4393 case bfd_link_hash_undefweak:
4394 if (h->esym.asym.sc != scUndefined
4395 && h->esym.asym.sc != scSUndefined)
4396 h->esym.asym.sc = scUndefined;
4397 break;
4398 case bfd_link_hash_defined:
4399 case bfd_link_hash_defweak:
4400 if (h->esym.asym.sc == scUndefined
4401 || h->esym.asym.sc == scSUndefined)
4402 h->esym.asym.sc = scAbs;
4403 else if (h->esym.asym.sc == scCommon)
4404 h->esym.asym.sc = scBss;
4405 else if (h->esym.asym.sc == scSCommon)
4406 h->esym.asym.sc = scSBss;
4407 h->esym.asym.value = (h->root.u.def.value
4408 + h->root.u.def.section->output_section->vma
4409 + h->root.u.def.section->output_offset);
4410 break;
4411 case bfd_link_hash_common:
4412 if (h->esym.asym.sc != scCommon
4413 && h->esym.asym.sc != scSCommon)
4414 h->esym.asym.sc = scCommon;
4415 h->esym.asym.value = h->root.u.c.size;
4416 break;
4417 case bfd_link_hash_indirect:
4418 /* We ignore these symbols, since the indirected symbol is
4419 already in the hash table. */
4420 return TRUE;
4423 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4424 symbol number. */
4425 h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax;
4426 h->written = 1;
4428 return (bfd_ecoff_debug_one_external
4429 (output_bfd, &ecoff_data (output_bfd)->debug_info,
4430 &ecoff_backend (output_bfd)->debug_swap, h->root.root.string,
4431 &h->esym));
4434 /* ECOFF final link routine. This looks through all the input BFDs
4435 and gathers together all the debugging information, and then
4436 processes all the link order information. This may cause it to
4437 close and reopen some input BFDs; I'll see how bad this is. */
4439 bfd_boolean
4440 _bfd_ecoff_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
4442 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
4443 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
4444 HDRR *symhdr;
4445 void * handle;
4446 bfd *input_bfd;
4447 asection *o;
4448 struct bfd_link_order *p;
4449 struct extsym_info einfo;
4451 /* We accumulate the debugging information counts in the symbolic
4452 header. */
4453 symhdr = &debug->symbolic_header;
4454 symhdr->vstamp = 0;
4455 symhdr->ilineMax = 0;
4456 symhdr->cbLine = 0;
4457 symhdr->idnMax = 0;
4458 symhdr->ipdMax = 0;
4459 symhdr->isymMax = 0;
4460 symhdr->ioptMax = 0;
4461 symhdr->iauxMax = 0;
4462 symhdr->issMax = 0;
4463 symhdr->issExtMax = 0;
4464 symhdr->ifdMax = 0;
4465 symhdr->crfd = 0;
4466 symhdr->iextMax = 0;
4468 /* We accumulate the debugging information itself in the debug_info
4469 structure. */
4470 debug->line = NULL;
4471 debug->external_dnr = NULL;
4472 debug->external_pdr = NULL;
4473 debug->external_sym = NULL;
4474 debug->external_opt = NULL;
4475 debug->external_aux = NULL;
4476 debug->ss = NULL;
4477 debug->ssext = debug->ssext_end = NULL;
4478 debug->external_fdr = NULL;
4479 debug->external_rfd = NULL;
4480 debug->external_ext = debug->external_ext_end = NULL;
4482 handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info);
4483 if (handle == NULL)
4484 return FALSE;
4486 /* Accumulate the debugging symbols from each input BFD. */
4487 for (input_bfd = info->input_bfds;
4488 input_bfd != NULL;
4489 input_bfd = input_bfd->link_next)
4491 bfd_boolean ret;
4493 if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour)
4495 /* Arbitrarily set the symbolic header vstamp to the vstamp
4496 of the first object file in the link. */
4497 if (symhdr->vstamp == 0)
4498 symhdr->vstamp
4499 = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp;
4500 ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info,
4501 handle);
4503 else
4504 ret = bfd_ecoff_debug_accumulate_other (handle, abfd,
4505 debug, &backend->debug_swap,
4506 input_bfd, info);
4507 if (! ret)
4508 return FALSE;
4510 /* Combine the register masks. */
4511 ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask;
4512 ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask;
4513 ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0];
4514 ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1];
4515 ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2];
4516 ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3];
4519 /* Write out the external symbols. */
4520 einfo.abfd = abfd;
4521 einfo.info = info;
4522 ecoff_link_hash_traverse (ecoff_hash_table (info),
4523 ecoff_link_write_external,
4524 (void *) &einfo);
4526 if (info->relocatable)
4528 /* We need to make a pass over the link_orders to count up the
4529 number of relocations we will need to output, so that we know
4530 how much space they will take up. */
4531 for (o = abfd->sections; o != NULL; o = o->next)
4533 o->reloc_count = 0;
4534 for (p = o->map_head.link_order;
4535 p != NULL;
4536 p = p->next)
4537 if (p->type == bfd_indirect_link_order)
4538 o->reloc_count += p->u.indirect.section->reloc_count;
4539 else if (p->type == bfd_section_reloc_link_order
4540 || p->type == bfd_symbol_reloc_link_order)
4541 ++o->reloc_count;
4545 /* Compute the reloc and symbol file positions. */
4546 ecoff_compute_reloc_file_positions (abfd);
4548 /* Write out the debugging information. */
4549 if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug,
4550 &backend->debug_swap, info,
4551 ecoff_data (abfd)->sym_filepos))
4552 return FALSE;
4554 bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info);
4556 if (info->relocatable)
4558 /* Now reset the reloc_count field of the sections in the output
4559 BFD to 0, so that we can use them to keep track of how many
4560 relocs we have output thus far. */
4561 for (o = abfd->sections; o != NULL; o = o->next)
4562 o->reloc_count = 0;
4565 /* Get a value for the GP register. */
4566 if (ecoff_data (abfd)->gp == 0)
4568 struct bfd_link_hash_entry *h;
4570 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
4571 if (h != NULL
4572 && h->type == bfd_link_hash_defined)
4573 ecoff_data (abfd)->gp = (h->u.def.value
4574 + h->u.def.section->output_section->vma
4575 + h->u.def.section->output_offset);
4576 else if (info->relocatable)
4578 bfd_vma lo;
4580 /* Make up a value. */
4581 lo = (bfd_vma) -1;
4582 for (o = abfd->sections; o != NULL; o = o->next)
4584 if (o->vma < lo
4585 && (streq (o->name, _SBSS)
4586 || streq (o->name, _SDATA)
4587 || streq (o->name, _LIT4)
4588 || streq (o->name, _LIT8)
4589 || streq (o->name, _LITA)))
4590 lo = o->vma;
4592 ecoff_data (abfd)->gp = lo + 0x8000;
4594 else
4596 /* If the relocate_section function needs to do a reloc
4597 involving the GP value, it should make a reloc_dangerous
4598 callback to warn that GP is not defined. */
4602 for (o = abfd->sections; o != NULL; o = o->next)
4604 for (p = o->map_head.link_order;
4605 p != NULL;
4606 p = p->next)
4608 if (p->type == bfd_indirect_link_order
4609 && (bfd_get_flavour (p->u.indirect.section->owner)
4610 == bfd_target_ecoff_flavour))
4612 if (! ecoff_indirect_link_order (abfd, info, o, p))
4613 return FALSE;
4615 else if (p->type == bfd_section_reloc_link_order
4616 || p->type == bfd_symbol_reloc_link_order)
4618 if (! ecoff_reloc_link_order (abfd, info, o, p))
4619 return FALSE;
4621 else
4623 if (! _bfd_default_link_order (abfd, info, o, p))
4624 return FALSE;
4629 bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax;
4631 ecoff_data (abfd)->linker = TRUE;
4633 return TRUE;