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