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