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