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