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