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