projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Forward relocs to output if -Bshared
[deliverable/binutils-gdb.git] / bfd / ecoff.c
CommitLineData
dae31cf5 1/* Generic ECOFF (Extended-COFF) routines.
c40d9c77 2 Copyright 1990, 91, 92, 93, 94, 95, 1996 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
c40d9c77 265 return bfd_big_endian (abfd) ? big : little;
a7853216
ILT		 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
9675c281
ILT		 1816 /* Make sure we have the FDR's. */
1817 if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL, debug_info)
1818 || bfd_get_symcount (abfd) == 0)
1819 return false;
dae31cf5 1820
9675c281 1821 if (ecoff_data (abfd)->find_line_info == NULL)
dae31cf5 1822 {
9675c281
ILT		 1823 ecoff_data (abfd)->find_line_info =
1824 ((struct ecoff_find_line *)
1825 bfd_alloc (abfd, sizeof (struct ecoff_find_line)));
1826 if (ecoff_data (abfd)->find_line_info == NULL)
a9713b91 1827 return false;
194fc935
ILT		 1828 ecoff_data (abfd)->find_line_info->find_buffer = NULL;
1829 ecoff_data (abfd)->find_line_info->fdrtab_len = 0;
3a6eecd4 1830 ecoff_data (abfd)->find_line_info->fdrtab = NULL;
dae31cf5 1831 }
9675c281 1832 line_info = ecoff_data (abfd)->find_line_info;
7b18561f 1833
9675c281
ILT		 1834 return _bfd_ecoff_locate_line (abfd, section, offset, debug_info,
1835 debug_swap, line_info, filename_ptr,
1836 functionname_ptr, retline_ptr);
dae31cf5
ILT		 1837}
1838\f
1bb42b1f
ILT		 1839/* Copy private BFD data. This is called by objcopy and strip. We
1840 use it to copy the ECOFF debugging information from one BFD to the
1841 other. It would be theoretically possible to represent the ECOFF
1842 debugging information in the symbol table. However, it would be a
1843 lot of work, and there would be little gain (gas, gdb, and ld
1844 already access the ECOFF debugging information via the
1845 ecoff_debug_info structure, and that structure would have to be
1846 retained in order to support ECOFF debugging in MIPS ELF).
1847
1848 The debugging information for the ECOFF external symbols comes from
1849 the symbol table, so this function only handles the other debugging
1850 information. */
1851
1852boolean
75f3ef7a 1853_bfd_ecoff_bfd_copy_private_bfd_data (ibfd, obfd)
1bb42b1f
ILT		 1854 bfd *ibfd;
1855 bfd *obfd;
1856{
1857 struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info;
1858 struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info;
8e5090ce 1859 register int i;
1bb42b1f
ILT		 1860 asymbol **sym_ptr_ptr;
1861 size_t c;
1862 boolean local;
1863
30f34d07
ILT		 1864 /* This function is selected based on the input vector. We only
1865 want to copy information over if the output BFD also uses ECOFF
1866 format. */
1867 if (bfd_get_flavour (obfd) != bfd_target_ecoff_flavour)
1868 return true;
1bb42b1f 1869
8e5090ce
ILT		 1870 /* Copy the GP value and the register masks. */
1871 ecoff_data (obfd)->gp = ecoff_data (ibfd)->gp;
1872 ecoff_data (obfd)->gprmask = ecoff_data (ibfd)->gprmask;
1873 ecoff_data (obfd)->fprmask = ecoff_data (ibfd)->fprmask;
1874 for (i = 0; i < 3; i++)
1875 ecoff_data (obfd)->cprmask[i] = ecoff_data (ibfd)->cprmask[i];
1876
1877 /* Copy the version stamp. */
1bb42b1f
ILT		 1878 oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp;
1879
1880 /* If there are no symbols, don't copy any debugging information. */
1881 c = bfd_get_symcount (obfd);
1882 sym_ptr_ptr = bfd_get_outsymbols (obfd);
1883 if (c == 0 || sym_ptr_ptr == (asymbol **) NULL)
1884 return true;
1885
1886 /* See if there are any local symbols. */
1887 local = false;
1888 for (; c > 0; c--, sym_ptr_ptr++)
1889 {
1890 if (ecoffsymbol (*sym_ptr_ptr)->local)
1891 {
1892 local = true;
1893 break;
1894 }
1895 }
1896
1897 if (local)
1898 {
1899 /* There are some local symbols. We just bring over all the
1900 debugging information. FIXME: This is not quite the right
1901 thing to do. If the user has asked us to discard all
1902 debugging information, then we are probably going to wind up
1903 keeping it because there will probably be some local symbol
1904 which objcopy did not discard. We should actually break
1905 apart the debugging information and only keep that which
1906 applies to the symbols we want to keep. */
1907 oinfo->symbolic_header.ilineMax = iinfo->symbolic_header.ilineMax;
1908 oinfo->symbolic_header.cbLine = iinfo->symbolic_header.cbLine;
1909 oinfo->line = iinfo->line;
1910
1911 oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax;
1912 oinfo->external_dnr = iinfo->external_dnr;
1913
1914 oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax;
1915 oinfo->external_pdr = iinfo->external_pdr;
1916
1917 oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax;
1918 oinfo->external_sym = iinfo->external_sym;
1919
1920 oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax;
1921 oinfo->external_opt = iinfo->external_opt;
1922
1923 oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax;
1924 oinfo->external_aux = iinfo->external_aux;
1925
1926 oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax;
1927 oinfo->ss = iinfo->ss;
1928
1929 oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax;
1930 oinfo->external_fdr = iinfo->external_fdr;
1931
1932 oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd;
1933 oinfo->external_rfd = iinfo->external_rfd;
1934 }
1935 else
1936 {
1937 /* We are discarding all the local symbol information. Look
1938 through the external symbols and remove all references to FDR
1939 or aux information. */
1940 c = bfd_get_symcount (obfd);
1941 sym_ptr_ptr = bfd_get_outsymbols (obfd);
1942 for (; c > 0; c--, sym_ptr_ptr++)
1943 {
1944 EXTR esym;
1945
1946 (*(ecoff_backend (obfd)->debug_swap.swap_ext_in))
1947 (obfd, ecoffsymbol (*sym_ptr_ptr)->native, &esym);
1948 esym.ifd = ifdNil;
1949 esym.asym.index = indexNil;
1950 (*(ecoff_backend (obfd)->debug_swap.swap_ext_out))
1951 (obfd, &esym, ecoffsymbol (*sym_ptr_ptr)->native);
1952 }
1953 }
1954
1955 return true;
1956}
1957\f
dae31cf5
ILT		 1958/* Set the architecture. The supported architecture is stored in the
1959 backend pointer. We always set the architecture anyhow, since many
1960 callers ignore the return value. */
1961
1962boolean
75f3ef7a 1963_bfd_ecoff_set_arch_mach (abfd, arch, machine)
dae31cf5
ILT		 1964 bfd *abfd;
1965 enum bfd_architecture arch;
1966 unsigned long machine;
1967{
1968 bfd_default_set_arch_mach (abfd, arch, machine);
1969 return arch == ecoff_backend (abfd)->arch;
1970}
1971
8e5090ce 1972/* Get the size of the section headers. */
dae31cf5 1973
728472f1 1974/*ARGSUSED*/
dae31cf5 1975int
75f3ef7a 1976_bfd_ecoff_sizeof_headers (abfd, reloc)
dae31cf5
ILT		 1977 bfd *abfd;
1978 boolean reloc;
1979{
a7853216
ILT		 1980 asection *current;
1981 int c;
d6074cdd 1982 int ret;
a7853216
ILT		 1983
1984 c = 0;
1985 for (current = abfd->sections;
1986 current != (asection *)NULL;
1987 current = current->next)
8e5090ce 1988 ++c;
a7853216 1989
626f883f
ILT		 1990 ret = (bfd_coff_filhsz (abfd)
1991 + bfd_coff_aoutsz (abfd)
1992 + c * bfd_coff_scnhsz (abfd));
1993 return BFD_ALIGN (ret, 16);
a7853216
ILT		 1994}
1995
8e5090ce 1996/* Get the contents of a section. */
a7853216
ILT		 1997
1998boolean
75f3ef7a 1999_bfd_ecoff_get_section_contents (abfd, section, location, offset, count)
a7853216
ILT		 2000 bfd *abfd;
2001 asection *section;
2002 PTR location;
2003 file_ptr offset;
2004 bfd_size_type count;
2005{
8e5090ce
ILT		 2006 return _bfd_generic_get_section_contents (abfd, section, location,
2007 offset, count);
dae31cf5
ILT		 2008}
2009
aca73687
ILT		 2010/* Sort sections by VMA, but put SEC_ALLOC sections first. This is
2011 called via qsort. */
2012
2013static int
2014ecoff_sort_hdrs (arg1, arg2)
2015 const PTR arg1;
2016 const PTR arg2;
2017{
2018 const asection *hdr1 = *(const asection **) arg1;
2019 const asection *hdr2 = *(const asection **) arg2;
2020
2021 if ((hdr1->flags & SEC_ALLOC) != 0)
2022 {
2023 if ((hdr2->flags & SEC_ALLOC) == 0)
2024 return -1;
2025 }
2026 else
2027 {
2028 if ((hdr2->flags & SEC_ALLOC) != 0)
2029 return 1;
2030 }
2031 if (hdr1->vma < hdr2->vma)
2032 return -1;
2033 else if (hdr1->vma > hdr2->vma)
2034 return 1;
2035 else
2036 return 0;
2037}
2038
dae31cf5
ILT		 2039/* Calculate the file position for each section, and set
2040 reloc_filepos. */
2041
aca73687 2042static boolean
dae31cf5
ILT		 2043ecoff_compute_section_file_positions (abfd)
2044 bfd *abfd;
2045{
dae31cf5 2046 file_ptr sofar;
aca73687
ILT		 2047 asection **sorted_hdrs;
2048 asection *current;
2049 unsigned int i;
dae31cf5 2050 file_ptr old_sofar;
aca73687
ILT		 2051 boolean first_data, first_nonalloc;
2052 const bfd_vma round = ecoff_backend (abfd)->round;
dae31cf5 2053
75f3ef7a 2054 sofar = _bfd_ecoff_sizeof_headers (abfd, false);
dae31cf5 2055
aca73687 2056 /* Sort the sections by VMA. */
58142f10
ILT		 2057 sorted_hdrs = (asection **) bfd_malloc (abfd->section_count
2058 * sizeof (asection *));
aca73687 2059 if (sorted_hdrs == NULL)
58142f10 2060 return false;
aca73687
ILT		 2061 for (current = abfd->sections, i = 0;
2062 current != NULL;
2063 current = current->next, i++)
2064 sorted_hdrs[i] = current;
2065 BFD_ASSERT (i == abfd->section_count);
2066
2067 qsort (sorted_hdrs, abfd->section_count, sizeof (asection *),
2068 ecoff_sort_hdrs);
2069
dae31cf5 2070 first_data = true;
aca73687
ILT		 2071 first_nonalloc = true;
2072 for (i = 0; i < abfd->section_count; i++)
dae31cf5 2073 {
3f048f7f
ILT		 2074 unsigned int alignment_power;
2075
aca73687
ILT		 2076 current = sorted_hdrs[i];
2077
dae31cf5 2078 /* Only deal with sections which have contents */
8e5090ce 2079 if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) == 0)
dae31cf5
ILT		 2080 continue;
2081
3f048f7f
ILT		 2082 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2083 supposed to indicate the number of .pdata entries that are
2084 really in the section. Each entry is 8 bytes. We store this
2085 away in line_filepos before increasing the section size. */
2086 if (strcmp (current->name, _PDATA) != 0)
2087 alignment_power = current->alignment_power;
2088 else
2089 {
2090 current->line_filepos = current->_raw_size / 8;
2091 alignment_power = 4;
2092 }
2093
dae31cf5
ILT		 2094 /* On Ultrix, the data sections in an executable file must be
2095 aligned to a page boundary within the file. This does not
2096 affect the section size, though. FIXME: Does this work for
c9668c58
ILT		 2097 other platforms? It requires some modification for the
2098 Alpha, because .rdata on the Alpha goes with the text, not
2099 the data. */
dae31cf5
ILT		 2100 if ((abfd->flags & EXEC_P) != 0
2101 && (abfd->flags & D_PAGED) != 0
a877f591 2102 && ! first_data
c9668c58
ILT		 2103 && (current->flags & SEC_CODE) == 0
2104 && (! ecoff_backend (abfd)->rdata_in_text
2105 || strcmp (current->name, _RDATA) != 0)
a877f591
ILT		 2106 && strcmp (current->name, _PDATA) != 0
2107 && strcmp (current->name, _RCONST) != 0)
dae31cf5 2108 {
dae31cf5
ILT		 2109 sofar = (sofar + round - 1) &~ (round - 1);
2110 first_data = false;
2111 }
f8ee1ebb
ILT		 2112 else if (strcmp (current->name, _LIB) == 0)
2113 {
f8ee1ebb
ILT		 2114 /* On Irix 4, the location of contents of the .lib section
2115 from a shared library section is also rounded up to a
2116 page boundary. */
2117
2118 sofar = (sofar + round - 1) &~ (round - 1);
2119 }
aca73687
ILT		 2120 else if (first_nonalloc
2121 && (current->flags & SEC_ALLOC) == 0
2122 && (abfd->flags & D_PAGED) != 0)
2123 {
2124 /* Skip up to the next page for an unallocated section, such
2125 as the .comment section on the Alpha. This leaves room
2126 for the .bss section. */
2127 first_nonalloc = false;
2128 sofar = (sofar + round - 1) &~ (round - 1);
2129 }
dae31cf5
ILT		 2130
2131 /* Align the sections in the file to the same boundary on
2132 which they are aligned in virtual memory. */
2133 old_sofar = sofar;
3f048f7f 2134 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
dae31cf5 2135
aca73687
ILT		 2136 if ((abfd->flags & D_PAGED) != 0
2137 && (current->flags & SEC_ALLOC) != 0)
2138 sofar += (current->vma - sofar) % round;
2139
dae31cf5
ILT		 2140 current->filepos = sofar;
2141
2142 sofar += current->_raw_size;
2143
2144 /* make sure that this section is of the right size too */
2145 old_sofar = sofar;
3f048f7f 2146 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
dae31cf5
ILT		 2147 current->_raw_size += sofar - old_sofar;
2148 }
2149
aca73687
ILT		 2150 free (sorted_hdrs);
2151 sorted_hdrs = NULL;
2152
dae31cf5 2153 ecoff_data (abfd)->reloc_filepos = sofar;
aca73687
ILT		 2154
2155 return true;
dae31cf5
ILT		 2156}
2157
966e0a16 2158/* Determine the location of the relocs for all the sections in the
3f048f7f
ILT		 2159 output file, as well as the location of the symbolic debugging
2160 information. */
966e0a16
ILT		 2161
2162static bfd_size_type
2163ecoff_compute_reloc_file_positions (abfd)
2164 bfd *abfd;
2165{
2166 const bfd_size_type external_reloc_size =
2167 ecoff_backend (abfd)->external_reloc_size;
2168 file_ptr reloc_base;
2169 bfd_size_type reloc_size;
2170 asection *current;
3f048f7f 2171 file_ptr sym_base;
966e0a16
ILT		 2172
2173 if (! abfd->output_has_begun)
3f048f7f 2174 {
aca73687
ILT		 2175 if (! ecoff_compute_section_file_positions (abfd))
2176 abort ();
3f048f7f
ILT		 2177 abfd->output_has_begun = true;
2178 }
966e0a16
ILT		 2179
2180 reloc_base = ecoff_data (abfd)->reloc_filepos;
2181
2182 reloc_size = 0;
2183 for (current = abfd->sections;
2184 current != (asection *)NULL;
2185 current = current->next)
2186 {
966e0a16
ILT		 2187 if (current->reloc_count == 0)
2188 current->rel_filepos = 0;
2189 else
2190 {
2191 bfd_size_type relsize;
2192
2193 current->rel_filepos = reloc_base;
2194 relsize = current->reloc_count * external_reloc_size;
2195 reloc_size += relsize;
2196 reloc_base += relsize;
2197 }
2198 }
2199
3f048f7f
ILT		 2200 sym_base = ecoff_data (abfd)->reloc_filepos + reloc_size;
2201
2202 /* At least on Ultrix, the symbol table of an executable file must
2203 be aligned to a page boundary. FIXME: Is this true on other
2204 platforms? */
2205 if ((abfd->flags & EXEC_P) != 0
2206 && (abfd->flags & D_PAGED) != 0)
2207 sym_base = ((sym_base + ecoff_backend (abfd)->round - 1)
2208 &~ (ecoff_backend (abfd)->round - 1));
2209
2210 ecoff_data (abfd)->sym_filepos = sym_base;
2211
966e0a16
ILT		 2212 return reloc_size;
2213}
2214
8e5090ce 2215/* Set the contents of a section. */
dae31cf5
ILT		 2216
2217boolean
75f3ef7a 2218_bfd_ecoff_set_section_contents (abfd, section, location, offset, count)
dae31cf5
ILT		 2219 bfd *abfd;
2220 asection *section;
2221 PTR location;
2222 file_ptr offset;
2223 bfd_size_type count;
2224{
966e0a16
ILT		 2225 /* This must be done first, because bfd_set_section_contents is
2226 going to set output_has_begun to true. */
dae31cf5 2227 if (abfd->output_has_begun == false)
aca73687
ILT		 2228 {
2229 if (! ecoff_compute_section_file_positions (abfd))
2230 return false;
2231 }
dae31cf5 2232
f8ee1ebb
ILT		 2233 /* If this is a .lib section, bump the vma address so that it winds
2234 up being the number of .lib sections output. This is right for
2235 Irix 4. Ian Taylor <ian@cygnus.com>. */
2236 if (strcmp (section->name, _LIB) == 0)
2237 ++section->vma;
2238
966e0a16
ILT		 2239 if (count == 0)
2240 return true;
2241
8e5090ce
ILT		 2242 if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
2243 || bfd_write (location, 1, count, abfd) != count)
2244 return false;
2245
2246 return true;
2247}
2248
2249/* Get the GP value for an ECOFF file. This is a hook used by
2250 nlmconv. */
2251
2252bfd_vma
2253bfd_ecoff_get_gp_value (abfd)
2254 bfd *abfd;
2255{
2256 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2257 || bfd_get_format (abfd) != bfd_object)
a7853216 2258 {
8e5090ce
ILT		 2259 bfd_set_error (bfd_error_invalid_operation);
2260 return 0;
2261 }
2262
2263 return ecoff_data (abfd)->gp;
2264}
a7853216 2265
8e5090ce
ILT		 2266/* Set the GP value for an ECOFF file. This is a hook used by the
2267 assembler. */
2268
2269boolean
2270bfd_ecoff_set_gp_value (abfd, gp_value)
2271 bfd *abfd;
2272 bfd_vma gp_value;
2273{
2274 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2275 || bfd_get_format (abfd) != bfd_object)
2276 {
2277 bfd_set_error (bfd_error_invalid_operation);
2278 return false;
2279 }
a7853216 2280
8e5090ce 2281 ecoff_data (abfd)->gp = gp_value;
a7853216 2282
8e5090ce
ILT		 2283 return true;
2284}
a7853216 2285
8e5090ce
ILT		 2286/* Set the register masks for an ECOFF file. This is a hook used by
2287 the assembler. */
2288
2289boolean
2290bfd_ecoff_set_regmasks (abfd, gprmask, fprmask, cprmask)
2291 bfd *abfd;
2292 unsigned long gprmask;
2293 unsigned long fprmask;
2294 unsigned long *cprmask;
2295{
2296 ecoff_data_type *tdata;
2297
2298 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2299 || bfd_get_format (abfd) != bfd_object)
2300 {
2301 bfd_set_error (bfd_error_invalid_operation);
2302 return false;
a7853216
ILT		 2303 }
2304
8e5090ce
ILT		 2305 tdata = ecoff_data (abfd);
2306 tdata->gprmask = gprmask;
2307 tdata->fprmask = fprmask;
2308 if (cprmask != (unsigned long *) NULL)
2309 {
2310 register int i;
2311
2312 for (i = 0; i < 3; i++)
2313 tdata->cprmask[i] = cprmask[i];
2314 }
dae31cf5
ILT		 2315
2316 return true;
2317}
2318
966e0a16
ILT		 2319/* Get ECOFF EXTR information for an external symbol. This function
2320 is passed to bfd_ecoff_debug_externals. */
dae31cf5 2321
966e0a16
ILT		 2322static boolean
2323ecoff_get_extr (sym, esym)
2324 asymbol *sym;
2325 EXTR *esym;
dae31cf5 2326{
966e0a16
ILT		 2327 ecoff_symbol_type *ecoff_sym_ptr;
2328 bfd *input_bfd;
2329
966e0a16
ILT		 2330 if (bfd_asymbol_flavour (sym) != bfd_target_ecoff_flavour
2331 || ecoffsymbol (sym)->native == NULL)
2332 {
1bb42b1f
ILT		 2333 /* Don't include debugging, local, or section symbols. */
2334 if ((sym->flags & BSF_DEBUGGING) != 0
2335 || (sym->flags & BSF_LOCAL) != 0
2336 || (sym->flags & BSF_SECTION_SYM) != 0)
2337 return false;
2338
966e0a16
ILT		 2339 esym->jmptbl = 0;
2340 esym->cobol_main = 0;
0652d579 2341 esym->weakext = (sym->flags & BSF_WEAK) != 0;
966e0a16
ILT		 2342 esym->reserved = 0;
2343 esym->ifd = ifdNil;
2344 /* FIXME: we can do better than this for st and sc. */
2345 esym->asym.st = stGlobal;
2346 esym->asym.sc = scAbs;
2347 esym->asym.reserved = 0;
2348 esym->asym.index = indexNil;
2349 return true;
2350 }
2351
2352 ecoff_sym_ptr = ecoffsymbol (sym);
2353
2354 if (ecoff_sym_ptr->local)
1bb42b1f 2355 return false;
966e0a16
ILT		 2356
2357 input_bfd = bfd_asymbol_bfd (sym);
2358 (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in))
2359 (input_bfd, ecoff_sym_ptr->native, esym);
2360
2361 /* If the symbol was defined by the linker, then esym will be
2362 undefined but sym will not be. Get a better class for such a
2363 symbol. */
2364 if ((esym->asym.sc == scUndefined
2365 || esym->asym.sc == scSUndefined)
7b18561f 2366 && ! bfd_is_und_section (bfd_get_section (sym)))
966e0a16
ILT		 2367 esym->asym.sc = scAbs;
2368
2369 /* Adjust the FDR index for the symbol by that used for the input
2370 BFD. */
3f048f7f
ILT		 2371 if (esym->ifd != -1)
2372 {
2373 struct ecoff_debug_info *input_debug;
2374
2375 input_debug = &ecoff_data (input_bfd)->debug_info;
2376 BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax);
2377 if (input_debug->ifdmap != (RFDT *) NULL)
2378 esym->ifd = input_debug->ifdmap[esym->ifd];
2379 }
966e0a16
ILT		 2380
2381 return true;
2382}
2383
2384/* Set the external symbol index. This routine is passed to
2385 bfd_ecoff_debug_externals. */
2386
2387static void
2388ecoff_set_index (sym, indx)
2389 asymbol *sym;
2390 bfd_size_type indx;
2391{
2392 ecoff_set_sym_index (sym, indx);
2393}
2394
2395/* Write out an ECOFF file. */
2396
2397boolean
75f3ef7a 2398_bfd_ecoff_write_object_contents (abfd)
966e0a16
ILT		 2399 bfd *abfd;
2400{
2401 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
2402 const bfd_vma round = backend->round;
2403 const bfd_size_type filhsz = bfd_coff_filhsz (abfd);
2404 const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd);
2405 const bfd_size_type scnhsz = bfd_coff_scnhsz (abfd);
2406 const bfd_size_type external_hdr_size
2407 = backend->debug_swap.external_hdr_size;
2408 const bfd_size_type external_reloc_size = backend->external_reloc_size;
2409 void (* const adjust_reloc_out) PARAMS ((bfd *,
2410 const arelent *,
2411 struct internal_reloc *))
c9668c58 2412 = backend->adjust_reloc_out;
dae31cf5
ILT		 2413 void (* const swap_reloc_out) PARAMS ((bfd *,
2414 const struct internal_reloc *,
2415 PTR))
2416 = backend->swap_reloc_out;
8d12f138
ILT		 2417 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
2418 HDRR * const symhdr = &debug->symbolic_header;
dae31cf5
ILT		 2419 asection *current;
2420 unsigned int count;
966e0a16 2421 bfd_size_type reloc_size;
22a71fef
ILT		 2422 bfd_size_type text_size;
2423 bfd_vma text_start;
1788b1bd 2424 boolean set_text_start;
22a71fef
ILT		 2425 bfd_size_type data_size;
2426 bfd_vma data_start;
1788b1bd 2427 boolean set_data_start;
22a71fef 2428 bfd_size_type bss_size;
80425e6c
JK		 2429 PTR buff = NULL;
2430 PTR reloc_buff = NULL;
dae31cf5
ILT		 2431 struct internal_filehdr internal_f;
2432 struct internal_aouthdr internal_a;
2433 int i;
2434
966e0a16
ILT		 2435 /* Determine where the sections and relocs will go in the output
2436 file. */
2437 reloc_size = ecoff_compute_reloc_file_positions (abfd);
dae31cf5
ILT		 2438
2439 count = 1;
dae31cf5
ILT		 2440 for (current = abfd->sections;
2441 current != (asection *)NULL;
2442 current = current->next)
2443 {
dae31cf5
ILT		 2444 current->target_index = count;
2445 ++count;
dae31cf5
ILT		 2446 }
2447
dae31cf5 2448 if ((abfd->flags & D_PAGED) != 0)
75f3ef7a 2449 text_size = _bfd_ecoff_sizeof_headers (abfd, false);
dae31cf5
ILT		 2450 else
2451 text_size = 0;
2452 text_start = 0;
1788b1bd 2453 set_text_start = false;
dae31cf5
ILT		 2454 data_size = 0;
2455 data_start = 0;
1788b1bd 2456 set_data_start = false;
dae31cf5
ILT		 2457 bss_size = 0;
2458
2459 /* Write section headers to the file. */
2460
80425e6c
JK		 2461 /* Allocate buff big enough to hold a section header,
2462 file header, or a.out header. */
2463 {
2464 bfd_size_type siz;
2465 siz = scnhsz;
2466 if (siz < filhsz)
2467 siz = filhsz;
2468 if (siz < aoutsz)
2469 siz = aoutsz;
58142f10 2470 buff = (PTR) bfd_malloc ((size_t) siz);
80425e6c 2471 if (buff == NULL)
58142f10 2472 goto error_return;
80425e6c
JK		 2473 }
2474
dae31cf5
ILT		 2475 internal_f.f_nscns = 0;
2476 if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0)
80425e6c 2477 goto error_return;
dae31cf5
ILT		 2478 for (current = abfd->sections;
2479 current != (asection *) NULL;
2480 current = current->next)
2481 {
2482 struct internal_scnhdr section;
2483 bfd_vma vma;
2484
dae31cf5
ILT		 2485 ++internal_f.f_nscns;
2486
2487 strncpy (section.s_name, current->name, sizeof section.s_name);
2488
f8ee1ebb 2489 /* This seems to be correct for Irix 4 shared libraries. */
dae31cf5
ILT		 2490 vma = bfd_get_section_vma (abfd, current);
2491 if (strcmp (current->name, _LIB) == 0)
2492 section.s_vaddr = 0;
2493 else
2494 section.s_vaddr = vma;
2495
010a405a 2496 section.s_paddr = current->lma;
dae31cf5
ILT		 2497 section.s_size = bfd_get_section_size_before_reloc (current);
2498
e544ed4f
ILT		 2499 /* If this section is unloadable then the scnptr will be 0. */
2500 if ((current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
dae31cf5
ILT		 2501 section.s_scnptr = 0;
2502 else
2503 section.s_scnptr = current->filepos;
2504 section.s_relptr = current->rel_filepos;
2505
2506 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2507 object file produced by the assembler is supposed to point to
2508 information about how much room is required by objects of
2509 various different sizes. I think this only matters if we
2510 want the linker to compute the best size to use, or
2511 something. I don't know what happens if the information is
2512 not present. */
3f048f7f
ILT		 2513 if (strcmp (current->name, _PDATA) != 0)
2514 section.s_lnnoptr = 0;
2515 else
2516 {
2517 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2518 hold the number of entries in the section (each entry is
2519 8 bytes). We stored this in the line_filepos field in
2520 ecoff_compute_section_file_positions. */
2521 section.s_lnnoptr = current->line_filepos;
2522 }
dae31cf5
ILT		 2523
2524 section.s_nreloc = current->reloc_count;
2525 section.s_nlnno = 0;
2526 section.s_flags = ecoff_sec_to_styp_flags (current->name,
2527 current->flags);
2528
9675c281
ILT		 2529 if (bfd_coff_swap_scnhdr_out (abfd, (PTR) &section, buff) == 0
2530 || bfd_write (buff, 1, scnhsz, abfd) != scnhsz)
80425e6c 2531 goto error_return;
dae31cf5 2532
c9668c58
ILT		 2533 if ((section.s_flags & STYP_TEXT) != 0
2534 || ((section.s_flags & STYP_RDATA) != 0
2535 && backend->rdata_in_text)
aca73687
ILT		 2536 || section.s_flags == STYP_PDATA
2537 || (section.s_flags & STYP_DYNAMIC) != 0
2538 || (section.s_flags & STYP_LIBLIST) != 0
2539 || (section.s_flags & STYP_RELDYN) != 0
2540 || section.s_flags == STYP_CONFLIC
2541 || (section.s_flags & STYP_DYNSTR) != 0
2542 || (section.s_flags & STYP_DYNSYM) != 0
2543 || (section.s_flags & STYP_HASH) != 0
2544 || (section.s_flags & STYP_ECOFF_INIT) != 0
a877f591
ILT		 2545 || (section.s_flags & STYP_ECOFF_FINI) != 0
2546 || section.s_flags == STYP_RCONST)
dae31cf5
ILT		 2547 {
2548 text_size += bfd_get_section_size_before_reloc (current);
1788b1bd
ILT		 2549 if (! set_text_start || text_start > vma)
2550 {
2551 text_start = vma;
2552 set_text_start = true;
2553 }
dae31cf5
ILT		 2554 }
2555 else if ((section.s_flags & STYP_RDATA) != 0
2556 || (section.s_flags & STYP_DATA) != 0
c9668c58 2557 || (section.s_flags & STYP_LITA) != 0
dae31cf5
ILT		 2558 || (section.s_flags & STYP_LIT8) != 0
2559 || (section.s_flags & STYP_LIT4) != 0
966e0a16 2560 || (section.s_flags & STYP_SDATA) != 0
aca73687
ILT		 2561 || section.s_flags == STYP_XDATA
2562 || (section.s_flags & STYP_GOT) != 0)
dae31cf5
ILT		 2563 {
2564 data_size += bfd_get_section_size_before_reloc (current);
1788b1bd
ILT		 2565 if (! set_data_start || data_start > vma)
2566 {
2567 data_start = vma;
2568 set_data_start = true;
2569 }
dae31cf5
ILT		 2570 }
2571 else if ((section.s_flags & STYP_BSS) != 0
2572 || (section.s_flags & STYP_SBSS) != 0)
2573 bss_size += bfd_get_section_size_before_reloc (current);
aca73687
ILT		 2574 else if (section.s_flags == 0
2575 || (section.s_flags & STYP_ECOFF_LIB) != 0
2576 || section.s_flags == STYP_COMMENT)
f8ee1ebb 2577 /* Do nothing */ ;
966e0a16
ILT		 2578 else
2579 abort ();
dae31cf5
ILT		 2580 }
2581
2582 /* Set up the file header. */
2583
a7853216 2584 internal_f.f_magic = ecoff_get_magic (abfd);
dae31cf5
ILT		 2585
2586 /* We will NOT put a fucking timestamp in the header here. Every
2587 time you put it back, I will come in and take it out again. I'm
2588 sorry. This field does not belong here. We fill it with a 0 so
2589 it compares the same but is not a reasonable time. --
2590 gnu@cygnus.com. */
2591 internal_f.f_timdat = 0;
2592
2593 if (bfd_get_symcount (abfd) != 0)
2594 {
2595 /* The ECOFF f_nsyms field is not actually the number of
2596 symbols, it's the size of symbolic information header. */
2597 internal_f.f_nsyms = external_hdr_size;
3f048f7f 2598 internal_f.f_symptr = ecoff_data (abfd)->sym_filepos;
dae31cf5
ILT		 2599 }
2600 else
2601 {
2602 internal_f.f_nsyms = 0;
2603 internal_f.f_symptr = 0;
2604 }
2605
2606 internal_f.f_opthdr = aoutsz;
2607
2608 internal_f.f_flags = F_LNNO;
2609 if (reloc_size == 0)
2610 internal_f.f_flags |= F_RELFLG;
2611 if (bfd_get_symcount (abfd) == 0)
2612 internal_f.f_flags |= F_LSYMS;
2613 if (abfd->flags & EXEC_P)
2614 internal_f.f_flags |= F_EXEC;
2615
c40d9c77 2616 if (bfd_little_endian (abfd))
dae31cf5
ILT		 2617 internal_f.f_flags |= F_AR32WR;
2618 else
2619 internal_f.f_flags |= F_AR32W;
2620
2621 /* Set up the ``optional'' header. */
2622 if ((abfd->flags & D_PAGED) != 0)
2623 internal_a.magic = ECOFF_AOUT_ZMAGIC;
2624 else
2625 internal_a.magic = ECOFF_AOUT_OMAGIC;
2626
3f048f7f
ILT		 2627 /* FIXME: Is this really correct? */
2628 internal_a.vstamp = symhdr->vstamp;
dae31cf5
ILT		 2629
2630 /* At least on Ultrix, these have to be rounded to page boundaries.
2631 FIXME: Is this true on other platforms? */
2632 if ((abfd->flags & D_PAGED) != 0)
2633 {
2634 internal_a.tsize = (text_size + round - 1) &~ (round - 1);
2635 internal_a.text_start = text_start &~ (round - 1);
2636 internal_a.dsize = (data_size + round - 1) &~ (round - 1);
2637 internal_a.data_start = data_start &~ (round - 1);
2638 }
2639 else
2640 {
2641 internal_a.tsize = text_size;
2642 internal_a.text_start = text_start;
2643 internal_a.dsize = data_size;
2644 internal_a.data_start = data_start;
2645 }
2646
2647 /* On Ultrix, the initial portions of the .sbss and .bss segments
2648 are at the end of the data section. The bsize field in the
2649 optional header records how many bss bytes are required beyond
2650 those in the data section. The value is not rounded to a page
2651 boundary. */
2652 if (bss_size < internal_a.dsize - data_size)
2653 bss_size = 0;
2654 else
2655 bss_size -= internal_a.dsize - data_size;
2656 internal_a.bsize = bss_size;
2657 internal_a.bss_start = internal_a.data_start + internal_a.dsize;
2658
2659 internal_a.entry = bfd_get_start_address (abfd);
2660
2661 internal_a.gp_value = ecoff_data (abfd)->gp;
2662
2663 internal_a.gprmask = ecoff_data (abfd)->gprmask;
48edba81 2664 internal_a.fprmask = ecoff_data (abfd)->fprmask;
dae31cf5
ILT		 2665 for (i = 0; i < 4; i++)
2666 internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i];
2667
aca73687
ILT		 2668 /* Let the backend adjust the headers if necessary. */
2669 if (backend->adjust_headers)
2670 {
2671 if (! (*backend->adjust_headers) (abfd, &internal_f, &internal_a))
2672 goto error_return;
2673 }
2674
dae31cf5
ILT		 2675 /* Write out the file header and the optional header. */
2676
2677 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
80425e6c 2678 goto error_return;
dae31cf5 2679
dae31cf5
ILT		 2680 bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, buff);
2681 if (bfd_write (buff, 1, filhsz, abfd) != filhsz)
80425e6c 2682 goto error_return;
dae31cf5 2683
dae31cf5
ILT		 2684 bfd_coff_swap_aouthdr_out (abfd, (PTR) &internal_a, buff);
2685 if (bfd_write (buff, 1, aoutsz, abfd) != aoutsz)
80425e6c 2686 goto error_return;
dae31cf5 2687
8d12f138 2688 /* Build the external symbol information. This must be done before
469984d1
ILT		 2689 writing out the relocs so that we know the symbol indices. We
2690 don't do this if this BFD was created by the backend linker,
2691 since it will have already handled the symbols and relocs. */
2692 if (! ecoff_data (abfd)->linker)
dae31cf5 2693 {
966e0a16
ILT		 2694 symhdr->iextMax = 0;
2695 symhdr->issExtMax = 0;
2696 debug->external_ext = debug->external_ext_end = NULL;
2697 debug->ssext = debug->ssext_end = NULL;
2698 if (bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap,
2699 (((abfd->flags & EXEC_P) == 0)
2700 ? true : false),
2701 ecoff_get_extr, ecoff_set_index)
2702 == false)
80425e6c 2703 goto error_return;
dae31cf5 2704
966e0a16
ILT		 2705 /* Write out the relocs. */
2706 for (current = abfd->sections;
2707 current != (asection *) NULL;
2708 current = current->next)
dae31cf5 2709 {
966e0a16
ILT		 2710 arelent **reloc_ptr_ptr;
2711 arelent **reloc_end;
2712 char *out_ptr;
dae31cf5 2713
966e0a16
ILT		 2714 if (current->reloc_count == 0)
2715 continue;
dae31cf5 2716
80425e6c
JK		 2717 reloc_buff =
2718 bfd_alloc (abfd, current->reloc_count * external_reloc_size);
2719 if (reloc_buff == NULL)
a9713b91 2720 goto error_return;
966e0a16
ILT		 2721
2722 reloc_ptr_ptr = current->orelocation;
2723 reloc_end = reloc_ptr_ptr + current->reloc_count;
80425e6c 2724 out_ptr = (char *) reloc_buff;
966e0a16
ILT		 2725 for (;
2726 reloc_ptr_ptr < reloc_end;
2727 reloc_ptr_ptr++, out_ptr += external_reloc_size)
dae31cf5 2728 {
966e0a16
ILT		 2729 arelent *reloc;
2730 asymbol *sym;
2731 struct internal_reloc in;
2732
68241b2b 2733 memset ((PTR) &in, 0, sizeof in);
966e0a16
ILT		 2734
2735 reloc = *reloc_ptr_ptr;
2736 sym = *reloc->sym_ptr_ptr;
2737
2738 in.r_vaddr = (reloc->address
2739 + bfd_get_section_vma (abfd, current));
2740 in.r_type = reloc->howto->type;
2741
2742 if ((sym->flags & BSF_SECTION_SYM) == 0)
2743 {
2744 in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr);
2745 in.r_extern = 1;
2746 }
dae31cf5 2747 else
966e0a16
ILT		 2748 {
2749 CONST char *name;
2750
2751 name = bfd_get_section_name (abfd, bfd_get_section (sym));
2752 if (strcmp (name, ".text") == 0)
2753 in.r_symndx = RELOC_SECTION_TEXT;
2754 else if (strcmp (name, ".rdata") == 0)
2755 in.r_symndx = RELOC_SECTION_RDATA;
2756 else if (strcmp (name, ".data") == 0)
2757 in.r_symndx = RELOC_SECTION_DATA;
2758 else if (strcmp (name, ".sdata") == 0)
2759 in.r_symndx = RELOC_SECTION_SDATA;
2760 else if (strcmp (name, ".sbss") == 0)
2761 in.r_symndx = RELOC_SECTION_SBSS;
2762 else if (strcmp (name, ".bss") == 0)
2763 in.r_symndx = RELOC_SECTION_BSS;
2764 else if (strcmp (name, ".init") == 0)
2765 in.r_symndx = RELOC_SECTION_INIT;
2766 else if (strcmp (name, ".lit8") == 0)
2767 in.r_symndx = RELOC_SECTION_LIT8;
2768 else if (strcmp (name, ".lit4") == 0)
2769 in.r_symndx = RELOC_SECTION_LIT4;
2770 else if (strcmp (name, ".xdata") == 0)
2771 in.r_symndx = RELOC_SECTION_XDATA;
2772 else if (strcmp (name, ".pdata") == 0)
2773 in.r_symndx = RELOC_SECTION_PDATA;
2774 else if (strcmp (name, ".fini") == 0)
2775 in.r_symndx = RELOC_SECTION_FINI;
2776 else if (strcmp (name, ".lita") == 0)
2777 in.r_symndx = RELOC_SECTION_LITA;
2778 else if (strcmp (name, "*ABS*") == 0)
2779 in.r_symndx = RELOC_SECTION_ABS;
a877f591
ILT		 2780 else if (strcmp (name, ".rconst") == 0)
2781 in.r_symndx = RELOC_SECTION_RCONST;
966e0a16
ILT		 2782 else
2783 abort ();
2784 in.r_extern = 0;
2785 }
2786
2787 (*adjust_reloc_out) (abfd, reloc, &in);
2788
2789 (*swap_reloc_out) (abfd, &in, (PTR) out_ptr);
dae31cf5
ILT		 2790 }
2791
966e0a16 2792 if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0)
80425e6c
JK		 2793 goto error_return;
2794 if (bfd_write (reloc_buff,
2795 external_reloc_size, current->reloc_count, abfd)
966e0a16 2796 != external_reloc_size * current->reloc_count)
80425e6c
JK		 2797 goto error_return;
2798 bfd_release (abfd, reloc_buff);
2799 reloc_buff = NULL;
dae31cf5 2800 }
dae31cf5 2801
3f048f7f
ILT		 2802 /* Write out the symbolic debugging information. */
2803 if (bfd_get_symcount (abfd) > 0)
2804 {
2805 /* Write out the debugging information. */
2806 if (bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap,
2807 ecoff_data (abfd)->sym_filepos)
2808 == false)
80425e6c 2809 goto error_return;
3f048f7f 2810 }
626f883f 2811 }
dae31cf5 2812
626f883f
ILT		 2813 /* The .bss section of a demand paged executable must receive an
2814 entire page. If there are symbols, the symbols will start on the
2815 next page. If there are no symbols, we must fill out the page by
2816 hand. */
2817 if (bfd_get_symcount (abfd) == 0
2818 && (abfd->flags & EXEC_P) != 0
2819 && (abfd->flags & D_PAGED) != 0)
2820 {
2821 char c;
2822
2823 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2824 SEEK_SET) != 0)
80425e6c 2825 goto error_return;
626f883f
ILT		 2826 if (bfd_read (&c, 1, 1, abfd) == 0)
2827 c = 0;
2828 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2829 SEEK_SET) != 0)
80425e6c 2830 goto error_return;
626f883f 2831 if (bfd_write (&c, 1, 1, abfd) != 1)
80425e6c 2832 goto error_return;
dae31cf5
ILT		 2833 }
2834
80425e6c
JK		 2835 if (reloc_buff != NULL)
2836 bfd_release (abfd, reloc_buff);
2837 if (buff != NULL)
2838 free (buff);
dae31cf5 2839 return true;
80425e6c
JK		 2840 error_return:
2841 if (reloc_buff != NULL)
2842 bfd_release (abfd, reloc_buff);
2843 if (buff != NULL)
2844 free (buff);
2845 return false;
dae31cf5
ILT		 2846}
2847\f
2848/* Archive handling. ECOFF uses what appears to be a unique type of
b59f0276
ILT		 2849 archive header (armap). The byte ordering of the armap and the
2850 contents are encoded in the name of the armap itself. At least for
2851 now, we only support archives with the same byte ordering in the
2852 armap and the contents.
dae31cf5
ILT		 2853
2854 The first four bytes in the armap are the number of symbol
2855 definitions. This is always a power of two.
2856
2857 This is followed by the symbol definitions. Each symbol definition
2858 occupies 8 bytes. The first four bytes are the offset from the
2859 start of the armap strings to the null-terminated string naming
2860 this symbol. The second four bytes are the file offset to the
2861 archive member which defines this symbol. If the second four bytes
2862 are 0, then this is not actually a symbol definition, and it should
2863 be ignored.
2864
2865 The symbols are hashed into the armap with a closed hashing scheme.
2866 See the functions below for the details of the algorithm.
2867
dae31cf5
ILT		 2868 After the symbol definitions comes four bytes holding the size of
2869 the string table, followed by the string table itself. */
2870
2871/* The name of an archive headers looks like this:
2872 __________E[BL]E[BL]_ (with a trailing space).
2873 The trailing space is changed to an X if the archive is changed to
48edba81
ILT		 2874 indicate that the armap is out of date.
2875
2876 The Alpha seems to use ________64E[BL]E[BL]_. */
dae31cf5
ILT		 2877
2878#define ARMAP_BIG_ENDIAN 'B'
2879#define ARMAP_LITTLE_ENDIAN 'L'
2880#define ARMAP_MARKER 'E'
48edba81 2881#define ARMAP_START_LENGTH 10
dae31cf5
ILT		 2882#define ARMAP_HEADER_MARKER_INDEX 10
2883#define ARMAP_HEADER_ENDIAN_INDEX 11
2884#define ARMAP_OBJECT_MARKER_INDEX 12
2885#define ARMAP_OBJECT_ENDIAN_INDEX 13
2886#define ARMAP_END_INDEX 14
2887#define ARMAP_END "_ "
2888
2889/* This is a magic number used in the hashing algorithm. */
2890#define ARMAP_HASH_MAGIC 0x9dd68ab5
2891
2892/* This returns the hash value to use for a string. It also sets
2893 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2894 is the number of entries in the hash table, and HLOG is the log
2895 base 2 of SIZE. */
2896
2897static unsigned int
2898ecoff_armap_hash (s, rehash, size, hlog)
2899 CONST char *s;
2900 unsigned int *rehash;
2901 unsigned int size;
2902 unsigned int hlog;
2903{
2904 unsigned int hash;
2905
2906 hash = *s++;
2907 while (*s != '\0')
2908 hash = ((hash >> 27) | (hash << 5)) + *s++;
2909 hash *= ARMAP_HASH_MAGIC;
2910 *rehash = (hash & (size - 1)) | 1;
2911 return hash >> (32 - hlog);
2912}
2913
2914/* Read in the armap. */
2915
2916boolean
75f3ef7a 2917_bfd_ecoff_slurp_armap (abfd)
dae31cf5
ILT		 2918 bfd *abfd;
2919{
2920 char nextname[17];
2921 unsigned int i;
2922 struct areltdata *mapdata;
2923 bfd_size_type parsed_size;
2924 char *raw_armap;
2925 struct artdata *ardata;
2926 unsigned int count;
2927 char *raw_ptr;
2928 struct symdef *symdef_ptr;
2929 char *stringbase;
2930
2931 /* Get the name of the first element. */
2932 i = bfd_read ((PTR) nextname, 1, 16, abfd);
2933 if (i == 0)
2934 return true;
2935 if (i != 16)
2936 return false;
2937
4002f18a
ILT		 2938 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
2939 return false;
dae31cf5 2940
8c11363a
ILT		 2941 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2942 standard COFF armap. We could move the ECOFF armap stuff into
2943 bfd_slurp_armap, but that seems inappropriate since no other
2944 target uses this format. Instead, we check directly for a COFF
2945 armap. */
2946 if (strncmp (nextname, "/ ", 16) == 0)
2947 return bfd_slurp_armap (abfd);
2948
dae31cf5 2949 /* See if the first element is an armap. */
48edba81
ILT		 2950 if (strncmp (nextname, ecoff_backend (abfd)->armap_start,
2951 ARMAP_START_LENGTH) != 0
dae31cf5
ILT		 2952 || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER
2953 || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2954 && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2955 || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER
2956 || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2957 && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2958 || strncmp (nextname + ARMAP_END_INDEX,
2959 ARMAP_END, sizeof ARMAP_END - 1) != 0)
2960 {
2961 bfd_has_map (abfd) = false;
2962 return true;
2963 }
2964
2965 /* Make sure we have the right byte ordering. */
2966 if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
c40d9c77 2967 ^ (bfd_header_big_endian (abfd)))
dae31cf5 2968 || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
c40d9c77 2969 ^ (bfd_big_endian (abfd))))
dae31cf5 2970 {
d1ad85a6 2971 bfd_set_error (bfd_error_wrong_format);
dae31cf5
ILT		 2972 return false;
2973 }
2974
2975 /* Read in the armap. */
2976 ardata = bfd_ardata (abfd);
a877f591 2977 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
dae31cf5
ILT		 2978 if (mapdata == (struct areltdata *) NULL)
2979 return false;
2980 parsed_size = mapdata->parsed_size;
2981 bfd_release (abfd, (PTR) mapdata);
2982
2983 raw_armap = (char *) bfd_alloc (abfd, parsed_size);
2984 if (raw_armap == (char *) NULL)
a9713b91 2985 return false;
dae31cf5
ILT		 2986
2987 if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size)
2988 {
4002f18a
ILT		 2989 if (bfd_get_error () != bfd_error_system_call)
2990 bfd_set_error (bfd_error_malformed_archive);
dae31cf5
ILT		 2991 bfd_release (abfd, (PTR) raw_armap);
2992 return false;
2993 }
2994
b59f0276
ILT		 2995 ardata->tdata = (PTR) raw_armap;
2996
dae31cf5
ILT		 2997 count = bfd_h_get_32 (abfd, (PTR) raw_armap);
2998
2999 ardata->symdef_count = 0;
3000 ardata->cache = (struct ar_cache *) NULL;
3001
48edba81
ILT		 3002 /* This code used to overlay the symdefs over the raw archive data,
3003 but that doesn't work on a 64 bit host. */
3004
e544ed4f 3005 stringbase = raw_armap + count * 8 + 8;
dae31cf5
ILT		 3006
3007#ifdef CHECK_ARMAP_HASH
3008 {
3009 unsigned int hlog;
3010
3011 /* Double check that I have the hashing algorithm right by making
3012 sure that every symbol can be looked up successfully. */
3013 hlog = 0;
3014 for (i = 1; i < count; i <<= 1)
3015 hlog++;
3016 BFD_ASSERT (i == count);
3017
e544ed4f
ILT		 3018 raw_ptr = raw_armap + 4;
3019 for (i = 0; i < count; i++, raw_ptr += 8)
dae31cf5
ILT		 3020 {
3021 unsigned int name_offset, file_offset;
3022 unsigned int hash, rehash, srch;
3023
3024 name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
e544ed4f 3025 file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4));
dae31cf5
ILT		 3026 if (file_offset == 0)
3027 continue;
3028 hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count,
3029 hlog);
3030 if (hash == i)
3031 continue;
3032
3033 /* See if we can rehash to this location. */
3034 for (srch = (hash + rehash) & (count - 1);
3035 srch != hash && srch != i;
3036 srch = (srch + rehash) & (count - 1))
e544ed4f 3037 BFD_ASSERT (bfd_h_get_32 (abfd, (PTR) (raw_armap + 8 + srch * 8))
dae31cf5
ILT		 3038 != 0);
3039 BFD_ASSERT (srch == i);
3040 }
3041 }
3042
dae31cf5
ILT		 3043#endif /* CHECK_ARMAP_HASH */
3044
e544ed4f
ILT		 3045 raw_ptr = raw_armap + 4;
3046 for (i = 0; i < count; i++, raw_ptr += 8)
3047 if (bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4)) != 0)
48edba81
ILT		 3048 ++ardata->symdef_count;
3049
3050 symdef_ptr = ((struct symdef *)
3051 bfd_alloc (abfd,
3052 ardata->symdef_count * sizeof (struct symdef)));
9783e04a 3053 if (!symdef_ptr)
a9713b91 3054 return false;
9783e04a 3055
48edba81
ILT		 3056 ardata->symdefs = (carsym *) symdef_ptr;
3057
e544ed4f
ILT		 3058 raw_ptr = raw_armap + 4;
3059 for (i = 0; i < count; i++, raw_ptr += 8)
dae31cf5
ILT		 3060 {
3061 unsigned int name_offset, file_offset;
3062
e544ed4f 3063 file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4));
dae31cf5
ILT		 3064 if (file_offset == 0)
3065 continue;
48edba81 3066 name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
dae31cf5
ILT		 3067 symdef_ptr->s.name = stringbase + name_offset;
3068 symdef_ptr->file_offset = file_offset;
3069 ++symdef_ptr;
dae31cf5
ILT		 3070 }
3071
3072 ardata->first_file_filepos = bfd_tell (abfd);
3073 /* Pad to an even boundary. */
3074 ardata->first_file_filepos += ardata->first_file_filepos % 2;
3075
3076 bfd_has_map (abfd) = true;
3077
3078 return true;
3079}
3080
3081/* Write out an armap. */
3082
3083boolean
75f3ef7a 3084_bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx)
dae31cf5
ILT		 3085 bfd *abfd;
3086 unsigned int elength;
3087 struct orl *map;
3088 unsigned int orl_count;
3089 int stridx;
3090{
3091 unsigned int hashsize, hashlog;
3092 unsigned int symdefsize;
3093 int padit;
3094 unsigned int stringsize;
3095 unsigned int mapsize;
3096 file_ptr firstreal;
3097 struct ar_hdr hdr;
3098 struct stat statbuf;
3099 unsigned int i;
e544ed4f 3100 bfd_byte temp[4];
dae31cf5
ILT		 3101 bfd_byte *hashtable;
3102 bfd *current;
3103 bfd *last_elt;
3104
3105 /* Ultrix appears to use as a hash table size the least power of two
3106 greater than twice the number of entries. */
3107 for (hashlog = 0; (1 << hashlog) <= 2 * orl_count; hashlog++)
3108 ;
3109 hashsize = 1 << hashlog;
3110
e544ed4f 3111 symdefsize = hashsize * 8;
dae31cf5
ILT		 3112 padit = stridx % 2;
3113 stringsize = stridx + padit;
3114
3115 /* Include 8 bytes to store symdefsize and stringsize in output. */
e544ed4f 3116 mapsize = symdefsize + stringsize + 8;
dae31cf5
ILT		 3117
3118 firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength;
3119
3120 memset ((PTR) &hdr, 0, sizeof hdr);
3121
3122 /* Work out the ECOFF armap name. */
48edba81 3123 strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start);
dae31cf5
ILT		 3124 hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER;
3125 hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] =
c40d9c77 3126 (bfd_header_big_endian (abfd)
dae31cf5
ILT		 3127 ? ARMAP_BIG_ENDIAN
3128 : ARMAP_LITTLE_ENDIAN);
3129 hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER;
3130 hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] =
c40d9c77 3131 bfd_big_endian (abfd) ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN;
dae31cf5
ILT		 3132 memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1);
3133
3134 /* Write the timestamp of the archive header to be just a little bit
3135 later than the timestamp of the file, otherwise the linker will
3136 complain that the index is out of date. Actually, the Ultrix
3137 linker just checks the archive name; the GNU linker may check the
3138 date. */
3139 stat (abfd->filename, &statbuf);
3140 sprintf (hdr.ar_date, "%ld", (long) (statbuf.st_mtime + 60));
3141
3142 /* The DECstation uses zeroes for the uid, gid and mode of the
3143 armap. */
3144 hdr.ar_uid[0] = '0';
3145 hdr.ar_gid[0] = '0';
3146 hdr.ar_mode[0] = '0';
3147
3148 sprintf (hdr.ar_size, "%-10d", (int) mapsize);
3149
3150 hdr.ar_fmag[0] = '`';
9a793780 3151 hdr.ar_fmag[1] = '\012';
dae31cf5
ILT		 3152
3153 /* Turn all null bytes in the header into spaces. */
3154 for (i = 0; i < sizeof (struct ar_hdr); i++)
3155 if (((char *)(&hdr))[i] == '\0')
3156 (((char *)(&hdr))[i]) = ' ';
3157
3158 if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), abfd)
3159 != sizeof (struct ar_hdr))
3160 return false;
3161
4c3721d5 3162 bfd_h_put_32 (abfd, (bfd_vma) hashsize, temp);
728472f1 3163 if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
dae31cf5
ILT		 3164 return false;
3165
3166 hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize);
9783e04a 3167 if (!hashtable)
a9713b91 3168 return false;
dae31cf5
ILT		 3169
3170 current = abfd->archive_head;
3171 last_elt = current;
3172 for (i = 0; i < orl_count; i++)
3173 {
3174 unsigned int hash, rehash;
3175
3176 /* Advance firstreal to the file position of this archive
3177 element. */
3178 if (((bfd *) map[i].pos) != last_elt)
3179 {
3180 do
3181 {
3182 firstreal += arelt_size (current) + sizeof (struct ar_hdr);
3183 firstreal += firstreal % 2;
3184 current = current->next;
3185 }
3186 while (current != (bfd *) map[i].pos);
3187 }
3188
3189 last_elt = current;
3190
3191 hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog);
e544ed4f 3192 if (bfd_h_get_32 (abfd, (PTR) (hashtable + (hash * 8) + 4)) != 0)
dae31cf5
ILT		 3193 {
3194 unsigned int srch;
3195
3196 /* The desired slot is already taken. */
3197 for (srch = (hash + rehash) & (hashsize - 1);
3198 srch != hash;
3199 srch = (srch + rehash) & (hashsize - 1))
e544ed4f 3200 if (bfd_h_get_32 (abfd, (PTR) (hashtable + (srch * 8) + 4)) == 0)
dae31cf5
ILT		 3201 break;
3202
3203 BFD_ASSERT (srch != hash);
3204
3205 hash = srch;
3206 }
3207
4c3721d5
ILT		 3208 bfd_h_put_32 (abfd, (bfd_vma) map[i].namidx,
3209 (PTR) (hashtable + hash * 8));
3210 bfd_h_put_32 (abfd, (bfd_vma) firstreal,
3211 (PTR) (hashtable + hash * 8 + 4));
dae31cf5
ILT		 3212 }
3213
728472f1 3214 if (bfd_write ((PTR) hashtable, 1, symdefsize, abfd) != symdefsize)
dae31cf5
ILT		 3215 return false;
3216
3217 bfd_release (abfd, hashtable);
3218
3219 /* Now write the strings. */
4c3721d5 3220 bfd_h_put_32 (abfd, (bfd_vma) stringsize, temp);
728472f1 3221 if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
dae31cf5
ILT		 3222 return false;
3223 for (i = 0; i < orl_count; i++)
3224 {
3225 bfd_size_type len;
3226
3227 len = strlen (*map[i].name) + 1;
3228 if (bfd_write ((PTR) (*map[i].name), 1, len, abfd) != len)
3229 return false;
3230 }
3231
3232 /* The spec sez this should be a newline. But in order to be
3233 bug-compatible for DECstation ar we use a null. */
3234 if (padit)
3235 {
728472f1 3236 if (bfd_write ("", 1, 1, abfd) != 1)
dae31cf5
ILT		 3237 return false;
3238 }
3239
3240 return true;
3241}
3242
3243/* See whether this BFD is an archive. If it is, read in the armap
3244 and the extended name table. */
3245
2f3508ad 3246const bfd_target *
75f3ef7a 3247_bfd_ecoff_archive_p (abfd)
dae31cf5
ILT		 3248 bfd *abfd;
3249{
3250 char armag[SARMAG + 1];
3251
3252 if (bfd_read ((PTR) armag, 1, SARMAG, abfd) != SARMAG
3253 || strncmp (armag, ARMAG, SARMAG) != 0)
3254 {
4002f18a
ILT		 3255 if (bfd_get_error () != bfd_error_system_call)
3256 bfd_set_error (bfd_error_wrong_format);
2f3508ad 3257 return (const bfd_target *) NULL;
dae31cf5
ILT		 3258 }
3259
3260 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
3261 involves a cast, we can't do it as the left operand of
3262 assignment. */
3263 abfd->tdata.aout_ar_data =
3264 (struct artdata *) bfd_zalloc (abfd, sizeof (struct artdata));
3265
3266 if (bfd_ardata (abfd) == (struct artdata *) NULL)
a9713b91 3267 return (const bfd_target *) NULL;
dae31cf5
ILT		 3268
3269 bfd_ardata (abfd)->first_file_filepos = SARMAG;
b59f0276
ILT		 3270 bfd_ardata (abfd)->cache = NULL;
3271 bfd_ardata (abfd)->archive_head = NULL;
3272 bfd_ardata (abfd)->symdefs = NULL;
3273 bfd_ardata (abfd)->extended_names = NULL;
3274 bfd_ardata (abfd)->tdata = NULL;
dae31cf5 3275
75f3ef7a
ILT		 3276 if (_bfd_ecoff_slurp_armap (abfd) == false
3277 || _bfd_ecoff_slurp_extended_name_table (abfd) == false)
dae31cf5
ILT		 3278 {
3279 bfd_release (abfd, bfd_ardata (abfd));
3280 abfd->tdata.aout_ar_data = (struct artdata *) NULL;
2f3508ad 3281 return (const bfd_target *) NULL;
dae31cf5
ILT		 3282 }
3283
3284 return abfd->xvec;
3285}
966e0a16
ILT		 3286\f
3287/* ECOFF linker code. */
3288
3289static struct bfd_hash_entry *ecoff_link_hash_newfunc
3290 PARAMS ((struct bfd_hash_entry *entry,
3291 struct bfd_hash_table *table,
3292 const char *string));
3293static boolean ecoff_link_add_archive_symbols
3294 PARAMS ((bfd *, struct bfd_link_info *));
3295static boolean ecoff_link_check_archive_element
3296 PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
3297static boolean ecoff_link_add_object_symbols
3298 PARAMS ((bfd *, struct bfd_link_info *));
3299static boolean ecoff_link_add_externals
3300 PARAMS ((bfd *, struct bfd_link_info *, PTR, char *));
3301
3302/* Routine to create an entry in an ECOFF link hash table. */
3303
3304static struct bfd_hash_entry *
3305ecoff_link_hash_newfunc (entry, table, string)
3306 struct bfd_hash_entry *entry;
3307 struct bfd_hash_table *table;
3308 const char *string;
3309{
3310 struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry;
3311
3312 /* Allocate the structure if it has not already been allocated by a
3313 subclass. */
3314 if (ret == (struct ecoff_link_hash_entry *) NULL)
3315 ret = ((struct ecoff_link_hash_entry *)
3316 bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry)));
9783e04a 3317 if (ret == (struct ecoff_link_hash_entry *) NULL)
a9713b91 3318 return NULL;
966e0a16
ILT		 3319
3320 /* Call the allocation method of the superclass. */
3321 ret = ((struct ecoff_link_hash_entry *)
3322 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3323 table, string));
3324
9783e04a
DM		 3325 if (ret)
3326 {
3327 /* Set local fields. */
3328 ret->indx = -1;
3329 ret->abfd = NULL;
ac9ed096
ILT		 3330 ret->written = 0;
3331 ret->small = 0;
9783e04a 3332 }
68241b2b 3333 memset ((PTR) &ret->esym, 0, sizeof ret->esym);
966e0a16
ILT		 3334
3335 return (struct bfd_hash_entry *) ret;
3336}
3337
3338/* Create an ECOFF link hash table. */
3339
3340struct bfd_link_hash_table *
75f3ef7a 3341_bfd_ecoff_bfd_link_hash_table_create (abfd)
966e0a16
ILT		 3342 bfd *abfd;
3343{
3344 struct ecoff_link_hash_table *ret;
3345
3346 ret = ((struct ecoff_link_hash_table *)
ae115e51
ILT		 3347 bfd_alloc (abfd, sizeof (struct ecoff_link_hash_table)));
3348 if (ret == NULL)
a9713b91 3349 return NULL;
966e0a16
ILT		 3350 if (! _bfd_link_hash_table_init (&ret->root, abfd,
3351 ecoff_link_hash_newfunc))
3352 {
3353 free (ret);
3354 return (struct bfd_link_hash_table *) NULL;
3355 }
3356 return &ret->root;
3357}
3358
3359/* Look up an entry in an ECOFF link hash table. */
3360
3361#define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3362 ((struct ecoff_link_hash_entry *) \
3363 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3364
3365/* Traverse an ECOFF link hash table. */
3366
3367#define ecoff_link_hash_traverse(table, func, info) \
3368 (bfd_link_hash_traverse \
3369 (&(table)->root, \
3370 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
3371 (info)))
3372
3373/* Get the ECOFF link hash table from the info structure. This is
3374 just a cast. */
3375
3376#define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3377
3378/* Given an ECOFF BFD, add symbols to the global hash table as
3379 appropriate. */
3380
3381boolean
75f3ef7a 3382_bfd_ecoff_bfd_link_add_symbols (abfd, info)
966e0a16
ILT		 3383 bfd *abfd;
3384 struct bfd_link_info *info;
3385{
3386 switch (bfd_get_format (abfd))
3387 {
3388 case bfd_object:
3389 return ecoff_link_add_object_symbols (abfd, info);
3390 case bfd_archive:
3391 return ecoff_link_add_archive_symbols (abfd, info);
3392 default:
d1ad85a6 3393 bfd_set_error (bfd_error_wrong_format);
966e0a16
ILT		 3394 return false;
3395 }
3396}
3397
3398/* Add the symbols from an archive file to the global hash table.
3399 This looks through the undefined symbols, looks each one up in the
3400 archive hash table, and adds any associated object file. We do not
3401 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3402 already have a hash table, so there is no reason to construct
3403 another one. */
3404
3405static boolean
3406ecoff_link_add_archive_symbols (abfd, info)
3407 bfd *abfd;
3408 struct bfd_link_info *info;
3409{
3410 const bfd_byte *raw_armap;
3411 struct bfd_link_hash_entry **pundef;
3412 unsigned int armap_count;
3413 unsigned int armap_log;
3414 unsigned int i;
3415 const bfd_byte *hashtable;
3416 const char *stringbase;
3417
3418 if (! bfd_has_map (abfd))
3419 {
6c97aedf
ILT		 3420 /* An empty archive is a special case. */
3421 if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
3422 return true;
9675c281 3423 bfd_set_error (bfd_error_no_armap);
966e0a16
ILT		 3424 return false;
3425 }
3426
3427 /* If we don't have any raw data for this archive, as can happen on
3428 Irix 4.0.5F, we call the generic routine.
3429 FIXME: We should be more clever about this, since someday tdata
3430 may get to something for a generic archive. */
3431 raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata;
3432 if (raw_armap == (bfd_byte *) NULL)
3433 return (_bfd_generic_link_add_archive_symbols
3434 (abfd, info, ecoff_link_check_archive_element));
3435
3436 armap_count = bfd_h_get_32 (abfd, raw_armap);
3437
3438 armap_log = 0;
3439 for (i = 1; i < armap_count; i <<= 1)
3440 armap_log++;
3441 BFD_ASSERT (i == armap_count);
3442
3443 hashtable = raw_armap + 4;
3444 stringbase = (const char *) raw_armap + armap_count * 8 + 8;
3445
3446 /* Look through the list of undefined symbols. */
3447 pundef = &info->hash->undefs;
3448 while (*pundef != (struct bfd_link_hash_entry *) NULL)
3449 {
3450 struct bfd_link_hash_entry *h;
3451 unsigned int hash, rehash;
3452 unsigned int file_offset;
3453 const char *name;
3454 bfd *element;
3455
3456 h = *pundef;
3457
3458 /* When a symbol is defined, it is not necessarily removed from
3459 the list. */
3460 if (h->type != bfd_link_hash_undefined
3461 && h->type != bfd_link_hash_common)
3462 {
3463 /* Remove this entry from the list, for general cleanliness
3464 and because we are going to look through the list again
3465 if we search any more libraries. We can't remove the
3466 entry if it is the tail, because that would lose any
3467 entries we add to the list later on. */
3468 if (*pundef != info->hash->undefs_tail)
3469 *pundef = (*pundef)->next;
3470 else
3471 pundef = &(*pundef)->next;
3472 continue;
3473 }
3474
3475 /* Native ECOFF linkers do not pull in archive elements merely
3476 to satisfy common definitions, so neither do we. We leave
3477 them on the list, though, in case we are linking against some
3478 other object format. */
3479 if (h->type != bfd_link_hash_undefined)
3480 {
3481 pundef = &(*pundef)->next;
3482 continue;
3483 }
3484
3485 /* Look for this symbol in the archive hash table. */
3486 hash = ecoff_armap_hash (h->root.string, &rehash, armap_count,
3487 armap_log);
3488
3489 file_offset = bfd_h_get_32 (abfd, hashtable + (hash * 8) + 4);
3490 if (file_offset == 0)
3491 {
3492 /* Nothing in this slot. */
3493 pundef = &(*pundef)->next;
3494 continue;
3495 }
3496
3497 name = stringbase + bfd_h_get_32 (abfd, hashtable + (hash * 8));
3498 if (name[0] != h->root.string[0]
3499 || strcmp (name, h->root.string) != 0)
3500 {
3501 unsigned int srch;
3502 boolean found;
3503
3504 /* That was the wrong symbol. Try rehashing. */
3505 found = false;
3506 for (srch = (hash + rehash) & (armap_count - 1);
3507 srch != hash;
3508 srch = (srch + rehash) & (armap_count - 1))
3509 {
3510 file_offset = bfd_h_get_32 (abfd, hashtable + (srch * 8) + 4);
3511 if (file_offset == 0)
3512 break;
3513 name = stringbase + bfd_h_get_32 (abfd, hashtable + (srch * 8));
3514 if (name[0] == h->root.string[0]
3515 && strcmp (name, h->root.string) == 0)
3516 {
3517 found = true;
3518 break;
3519 }
3520 }
3521
3522 if (! found)
3523 {
3524 pundef = &(*pundef)->next;
3525 continue;
3526 }
3527
3528 hash = srch;
3529 }
3530
3531 element = _bfd_get_elt_at_filepos (abfd, file_offset);
3532 if (element == (bfd *) NULL)
3533 return false;
3534
3535 if (! bfd_check_format (element, bfd_object))
3536 return false;
3537
3538 /* Unlike the generic linker, we know that this element provides
3539 a definition for an undefined symbol and we know that we want
3540 to include it. We don't need to check anything. */
3541 if (! (*info->callbacks->add_archive_element) (info, element, name))
3542 return false;
3543 if (! ecoff_link_add_object_symbols (element, info))
3544 return false;
3545
3546 pundef = &(*pundef)->next;
3547 }
3548
3549 return true;
3550}
3551
3552/* This is called if we used _bfd_generic_link_add_archive_symbols
3553 because we were not dealing with an ECOFF archive. */
3554
3555static boolean
3556ecoff_link_check_archive_element (abfd, info, pneeded)
3557 bfd *abfd;
3558 struct bfd_link_info *info;
3559 boolean *pneeded;
3560{
3561 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3562 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
3563 = backend->debug_swap.swap_ext_in;
3564 HDRR *symhdr;
3565 bfd_size_type external_ext_size;
80425e6c 3566 PTR external_ext = NULL;
966e0a16 3567 size_t esize;
80425e6c 3568 char *ssext = NULL;
966e0a16
ILT		 3569 char *ext_ptr;
3570 char *ext_end;
3571
3572 *pneeded = false;
3573
3574 if (! ecoff_slurp_symbolic_header (abfd))
80425e6c 3575 goto error_return;
966e0a16
ILT		 3576
3577 /* If there are no symbols, we don't want it. */
3578 if (bfd_get_symcount (abfd) == 0)
80425e6c 3579 goto successful_return;
966e0a16
ILT		 3580
3581 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3582
3583 /* Read in the external symbols and external strings. */
3584 external_ext_size = backend->debug_swap.external_ext_size;
3585 esize = symhdr->iextMax * external_ext_size;
58142f10 3586 external_ext = (PTR) bfd_malloc (esize);
a3a33af3 3587 if (external_ext == NULL && esize != 0)
58142f10 3588 goto error_return;
80425e6c 3589
966e0a16
ILT		 3590 if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
3591 || bfd_read (external_ext, 1, esize, abfd) != esize)
80425e6c
JK		 3592 goto error_return;
3593
58142f10 3594 ssext = (char *) bfd_malloc (symhdr->issExtMax);
a3a33af3 3595 if (ssext == NULL && symhdr->issExtMax != 0)
58142f10 3596 goto error_return;
966e0a16 3597
966e0a16 3598 if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
ae115e51
ILT		 3599 || (bfd_read (ssext, 1, symhdr->issExtMax, abfd) !=
3600 (bfd_size_type) symhdr->issExtMax))
80425e6c 3601 goto error_return;
966e0a16
ILT		 3602
3603 /* Look through the external symbols to see if they define some
3604 symbol that is currently undefined. */
3605 ext_ptr = (char *) external_ext;
3606 ext_end = ext_ptr + esize;
3607 for (; ext_ptr < ext_end; ext_ptr += external_ext_size)
3608 {
3609 EXTR esym;
3610 boolean def;
3611 const char *name;
3612 struct bfd_link_hash_entry *h;
3613
3614 (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym);
3615
3616 /* See if this symbol defines something. */
3617 if (esym.asym.st != stGlobal
3618 && esym.asym.st != stLabel
3619 && esym.asym.st != stProc)
3620 continue;
3621
3622 switch (esym.asym.sc)
3623 {
3624 case scText:
3625 case scData:
3626 case scBss:
3627 case scAbs:
3628 case scSData:
3629 case scSBss:
3630 case scRData:
3631 case scCommon:
3632 case scSCommon:
3633 case scInit:
3634 case scFini:
a877f591 3635 case scRConst:
966e0a16
ILT		 3636 def = true;
3637 break;
3638 default:
3639 def = false;
3640 break;
3641 }
3642
3643 if (! def)
3644 continue;
3645
3646 name = ssext + esym.asym.iss;
3647 h = bfd_link_hash_lookup (info->hash, name, false, false, true);
3648
3649 /* Unlike the generic linker, we do not pull in elements because
3650 of common symbols. */
3651 if (h == (struct bfd_link_hash_entry *) NULL
3652 || h->type != bfd_link_hash_undefined)
3653 continue;
3654
3655 /* Include this element. */
3656 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
80425e6c 3657 goto error_return;
966e0a16 3658 if (! ecoff_link_add_externals (abfd, info, external_ext, ssext))
80425e6c 3659 goto error_return;
966e0a16
ILT		 3660
3661 *pneeded = true;
80425e6c 3662 goto successful_return;
966e0a16
ILT		 3663 }
3664
80425e6c
JK		 3665 successful_return:
3666 if (external_ext != NULL)
3667 free (external_ext);
3668 if (ssext != NULL)
3669 free (ssext);
966e0a16 3670 return true;
80425e6c
JK		 3671 error_return:
3672 if (external_ext != NULL)
3673 free (external_ext);
3674 if (ssext != NULL)
3675 free (ssext);
3676 return false;
966e0a16
ILT		 3677}
3678
3679/* Add symbols from an ECOFF object file to the global linker hash
3680 table. */
3681
3682static boolean
3683ecoff_link_add_object_symbols (abfd, info)
3684 bfd *abfd;
3685 struct bfd_link_info *info;
3686{
3687 HDRR *symhdr;
3688 bfd_size_type external_ext_size;
80425e6c 3689 PTR external_ext = NULL;
966e0a16 3690 size_t esize;
80425e6c
JK		 3691 char *ssext = NULL;
3692 boolean result;
966e0a16
ILT		 3693
3694 if (! ecoff_slurp_symbolic_header (abfd))
3695 return false;
3696
3697 /* If there are no symbols, we don't want it. */
3698 if (bfd_get_symcount (abfd) == 0)
3699 return true;
3700
3701 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3702
3703 /* Read in the external symbols and external strings. */
3704 external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size;
3705 esize = symhdr->iextMax * external_ext_size;
58142f10 3706 external_ext = (PTR) bfd_malloc (esize);
a3a33af3 3707 if (external_ext == NULL && esize != 0)
58142f10 3708 goto error_return;
80425e6c 3709
966e0a16
ILT		 3710 if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
3711 || bfd_read (external_ext, 1, esize, abfd) != esize)
80425e6c
JK		 3712 goto error_return;
3713
58142f10 3714 ssext = (char *) bfd_malloc (symhdr->issExtMax);
a3a33af3 3715 if (ssext == NULL && symhdr->issExtMax != 0)
58142f10 3716 goto error_return;
966e0a16 3717
966e0a16 3718 if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
ae115e51
ILT		 3719 || (bfd_read (ssext, 1, symhdr->issExtMax, abfd)
3720 != (bfd_size_type) symhdr->issExtMax))
80425e6c
JK		 3721 goto error_return;
3722
3723 result = ecoff_link_add_externals (abfd, info, external_ext, ssext);
3724
3725 if (ssext != NULL)
3726 free (ssext);
3727 if (external_ext != NULL)
3728 free (external_ext);
3729 return result;
3730
3731 error_return:
3732 if (ssext != NULL)
3733 free (ssext);
3734 if (external_ext != NULL)
3735 free (external_ext);
3736 return false;
966e0a16
ILT		 3737}
3738
3739/* Add the external symbols of an object file to the global linker
3740 hash table. The external symbols and strings we are passed are
3741 just allocated on the stack, and will be discarded. We must
3742 explicitly save any information we may need later on in the link.
3743 We do not want to read the external symbol information again. */
3744
3745static boolean
3746ecoff_link_add_externals (abfd, info, external_ext, ssext)
3747 bfd *abfd;
3748 struct bfd_link_info *info;
3749 PTR external_ext;
3750 char *ssext;
3751{
3752 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3753 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
3754 = backend->debug_swap.swap_ext_in;
3755 bfd_size_type external_ext_size = backend->debug_swap.external_ext_size;
3756 unsigned long ext_count;
3757 struct ecoff_link_hash_entry **sym_hash;
3758 char *ext_ptr;
3759 char *ext_end;
3760
3761 ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
3762
3763 sym_hash = ((struct ecoff_link_hash_entry **)
3764 bfd_alloc (abfd,
3765 ext_count * sizeof (struct bfd_link_hash_entry *)));
9783e04a 3766 if (!sym_hash)
a9713b91 3767 return false;
966e0a16
ILT		 3768 ecoff_data (abfd)->sym_hashes = sym_hash;
3769
3770 ext_ptr = (char *) external_ext;
3771 ext_end = ext_ptr + ext_count * external_ext_size;
3772 for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++)
3773 {
3774 EXTR esym;
3775 boolean skip;
3776 bfd_vma value;
3777 asection *section;
3778 const char *name;
3779 struct ecoff_link_hash_entry *h;
3780
3781 *sym_hash = NULL;
3782
3783 (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym);
3784
3785 /* Skip debugging symbols. */
3786 skip = false;
3787 switch (esym.asym.st)
3788 {
3789 case stGlobal:
3790 case stStatic:
3791 case stLabel:
3792 case stProc:
3793 case stStaticProc:
3794 break;
3795 default:
3796 skip = true;
3797 break;
3798 }
3799
3800 if (skip)
3801 continue;
3802
3803 /* Get the information for this symbol. */
3804 value = esym.asym.value;
3805 switch (esym.asym.sc)
3806 {
3807 default:
3808 case scNil:
3809 case scRegister:
3810 case scCdbLocal:
3811 case scBits:
3812 case scCdbSystem:
3813 case scRegImage:
3814 case scInfo:
3815 case scUserStruct:
3816 case scVar:
3817 case scVarRegister:
3818 case scVariant:
3819 case scBasedVar:
3820 case scXData:
3821 case scPData:
3822 section = NULL;
3823 break;
3824 case scText:
3825 section = bfd_make_section_old_way (abfd, ".text");
3826 value -= section->vma;
3827 break;
3828 case scData:
3829 section = bfd_make_section_old_way (abfd, ".data");
3830 value -= section->vma;
3831 break;
3832 case scBss:
3833 section = bfd_make_section_old_way (abfd, ".bss");
3834 value -= section->vma;
3835 break;
3836 case scAbs:
7b18561f 3837 section = bfd_abs_section_ptr;
966e0a16
ILT		 3838 break;
3839 case scUndefined:
7b18561f 3840 section = bfd_und_section_ptr;
966e0a16
ILT		 3841 break;
3842 case scSData:
3843 section = bfd_make_section_old_way (abfd, ".sdata");
3844 value -= section->vma;
3845 break;
3846 case scSBss:
3847 section = bfd_make_section_old_way (abfd, ".sbss");
3848 value -= section->vma;
3849 break;
3850 case scRData:
3851 section = bfd_make_section_old_way (abfd, ".rdata");
3852 value -= section->vma;
3853 break;
3854 case scCommon:
3855 if (value > ecoff_data (abfd)->gp_size)
3856 {
7b18561f 3857 section = bfd_com_section_ptr;
966e0a16
ILT		 3858 break;
3859 }
3860 /* Fall through. */
3861 case scSCommon:
3862 if (ecoff_scom_section.name == NULL)
3863 {
3864 /* Initialize the small common section. */
3865 ecoff_scom_section.name = SCOMMON;
3866 ecoff_scom_section.flags = SEC_IS_COMMON;
3867 ecoff_scom_section.output_section = &ecoff_scom_section;
3868 ecoff_scom_section.symbol = &ecoff_scom_symbol;
3869 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
3870 ecoff_scom_symbol.name = SCOMMON;
3871 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
3872 ecoff_scom_symbol.section = &ecoff_scom_section;
3873 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
3874 }
3875 section = &ecoff_scom_section;
3876 break;
3877 case scSUndefined:
7b18561f 3878 section = bfd_und_section_ptr;
966e0a16
ILT		 3879 break;
3880 case scInit:
3881 section = bfd_make_section_old_way (abfd, ".init");
3882 value -= section->vma;
3883 break;
3884 case scFini:
3885 section = bfd_make_section_old_way (abfd, ".fini");
3886 value -= section->vma;
3887 break;
a877f591
ILT		 3888 case scRConst:
3889 section = bfd_make_section_old_way (abfd, ".rconst");
3890 value -= section->vma;
3891 break;
966e0a16
ILT		 3892 }
3893
3894 if (section == (asection *) NULL)
3895 continue;
3896
3897 name = ssext + esym.asym.iss;
3898
8e5090ce 3899 h = NULL;
966e0a16 3900 if (! (_bfd_generic_link_add_one_symbol
0652d579
ILT		 3901 (info, abfd, name,
3902 esym.weakext ? BSF_WEAK : BSF_GLOBAL,
3903 section, value, (const char *) NULL, true, true,
966e0a16
ILT		 3904 (struct bfd_link_hash_entry **) &h)))
3905 return false;
3906
3907 *sym_hash = h;
3908
3909 /* If we are building an ECOFF hash table, save the external
3910 symbol information. */
3911 if (info->hash->creator->flavour == bfd_get_flavour (abfd))
3912 {
3913 if (h->abfd == (bfd *) NULL
7b18561f 3914 || (! bfd_is_und_section (section)
966e0a16 3915 && (! bfd_is_com_section (section)
6c97aedf
ILT		 3916 || (h->root.type != bfd_link_hash_defined
3917 && h->root.type != bfd_link_hash_defweak))))
966e0a16
ILT		 3918 {
3919 h->abfd = abfd;
3920 h->esym = esym;
3921 }
ac9ed096
ILT		 3922
3923 /* Remember whether this symbol was small undefined. */
3924 if (esym.asym.sc == scSUndefined)
3925 h->small = 1;
3926
3927 /* If this symbol was ever small undefined, it needs to wind
3928 up in a GP relative section. We can't control the
3929 section of a defined symbol, but we can control the
3930 section of a common symbol. This case is actually needed
3931 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3932 if (h->small
3933 && h->root.type == bfd_link_hash_common
9675c281 3934 && strcmp (h->root.u.c.p->section->name, SCOMMON) != 0)
ac9ed096 3935 {
9675c281
ILT		 3936 h->root.u.c.p->section = bfd_make_section_old_way (abfd,
3937 SCOMMON);
3938 h->root.u.c.p->section->flags = SEC_ALLOC;
ac9ed096
ILT		 3939 if (h->esym.asym.sc == scCommon)
3940 h->esym.asym.sc = scSCommon;
3941 }
966e0a16
ILT		 3942 }
3943 }
3944
3945 return true;
3946}
3947\f
3948/* ECOFF final link routines. */
3949
3950static boolean ecoff_final_link_debug_accumulate
3f048f7f
ILT		 3951 PARAMS ((bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *,
3952 PTR handle));
966e0a16
ILT		 3953static boolean ecoff_link_write_external
3954 PARAMS ((struct ecoff_link_hash_entry *, PTR));
3955static boolean ecoff_indirect_link_order
3956 PARAMS ((bfd *, struct bfd_link_info *, asection *,
3957 struct bfd_link_order *));
a3a33af3
ILT		 3958static boolean ecoff_reloc_link_order
3959 PARAMS ((bfd *, struct bfd_link_info *, asection *,
3960 struct bfd_link_order *));
966e0a16
ILT		 3961
3962/* ECOFF final link routine. This looks through all the input BFDs
3963 and gathers together all the debugging information, and then
3964 processes all the link order information. This may cause it to
3965 close and reopen some input BFDs; I'll see how bad this is. */
3966
3967boolean
75f3ef7a 3968_bfd_ecoff_bfd_final_link (abfd, info)
966e0a16
ILT		 3969 bfd *abfd;
3970 struct bfd_link_info *info;
3971{
3972 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3973 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
3974 HDRR *symhdr;
3f048f7f 3975 PTR handle;
966e0a16
ILT		 3976 register bfd *input_bfd;
3977 asection *o;
3978 struct bfd_link_order *p;
3979
3980 /* We accumulate the debugging information counts in the symbolic
3981 header. */
3982 symhdr = &debug->symbolic_header;
966e0a16
ILT		 3983 symhdr->vstamp = 0;
3984 symhdr->ilineMax = 0;
3985 symhdr->cbLine = 0;
3986 symhdr->idnMax = 0;
3987 symhdr->ipdMax = 0;
3988 symhdr->isymMax = 0;
3989 symhdr->ioptMax = 0;
3990 symhdr->iauxMax = 0;
3991 symhdr->issMax = 0;
3992 symhdr->issExtMax = 0;
3993 symhdr->ifdMax = 0;
3994 symhdr->crfd = 0;
3995 symhdr->iextMax = 0;
3996
3997 /* We accumulate the debugging information itself in the debug_info
3998 structure. */
3f048f7f
ILT		 3999 debug->line = NULL;
4000 debug->external_dnr = NULL;
4001 debug->external_pdr = NULL;
4002 debug->external_sym = NULL;
4003 debug->external_opt = NULL;
4004 debug->external_aux = NULL;
4005 debug->ss = NULL;
966e0a16 4006 debug->ssext = debug->ssext_end = NULL;
3f048f7f
ILT		 4007 debug->external_fdr = NULL;
4008 debug->external_rfd = NULL;
966e0a16
ILT		 4009 debug->external_ext = debug->external_ext_end = NULL;
4010
3f048f7f
ILT		 4011 handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info);
4012 if (handle == (PTR) NULL)
4013 return false;
4014
966e0a16
ILT		 4015 /* Accumulate the debugging symbols from each input BFD. */
4016 for (input_bfd = info->input_bfds;
4017 input_bfd != (bfd *) NULL;
4018 input_bfd = input_bfd->link_next)
4019 {
4020 boolean ret;
4021
966e0a16 4022 if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour)
3f048f7f
ILT		 4023 {
4024 /* Abitrarily set the symbolic header vstamp to the vstamp
4025 of the first object file in the link. */
4026 if (symhdr->vstamp == 0)
4027 symhdr->vstamp
4028 = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp;
4029 ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info,
4030 handle);
4031 }
966e0a16 4032 else
3f048f7f
ILT		 4033 ret = bfd_ecoff_debug_accumulate_other (handle, abfd,
4034 debug, &backend->debug_swap,
4035 input_bfd, info);
966e0a16
ILT		 4036 if (! ret)
4037 return false;
4038
4039 /* Combine the register masks. */
4040 ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask;
4041 ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask;
4042 ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0];
4043 ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1];
4044 ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2];
4045 ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3];
4046 }
4047
4048 /* Write out the external symbols. */
4049 ecoff_link_hash_traverse (ecoff_hash_table (info),
4050 ecoff_link_write_external,
4051 (PTR) abfd);
4052
4053 if (info->relocateable)
4054 {
4055 /* We need to make a pass over the link_orders to count up the
4056 number of relocations we will need to output, so that we know
4057 how much space they will take up. */
4058 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4059 {
4060 o->reloc_count = 0;
4061 for (p = o->link_order_head;
4062 p != (struct bfd_link_order *) NULL;
4063 p = p->next)
4064 if (p->type == bfd_indirect_link_order)
4065 o->reloc_count += p->u.indirect.section->reloc_count;
a3a33af3
ILT		 4066 else if (p->type == bfd_section_reloc_link_order
4067 || p->type == bfd_symbol_reloc_link_order)
4068 ++o->reloc_count;
966e0a16 4069 }
3f048f7f
ILT		 4070 }
4071
4072 /* Compute the reloc and symbol file positions. */
4073 ecoff_compute_reloc_file_positions (abfd);
4074
4075 /* Write out the debugging information. */
4076 if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug,
4077 &backend->debug_swap, info,
4078 ecoff_data (abfd)->sym_filepos))
4079 return false;
966e0a16 4080
3f048f7f 4081 bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info);
966e0a16 4082
3f048f7f
ILT		 4083 if (info->relocateable)
4084 {
966e0a16
ILT		 4085 /* Now reset the reloc_count field of the sections in the output
4086 BFD to 0, so that we can use them to keep track of how many
4087 relocs we have output thus far. */
4088 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4089 o->reloc_count = 0;
4090 }
4091
4092 /* Get a value for the GP register. */
4093 if (ecoff_data (abfd)->gp == 0)
4094 {
4095 struct bfd_link_hash_entry *h;
4096
4097 h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
4098 if (h != (struct bfd_link_hash_entry *) NULL
4099 && h->type == bfd_link_hash_defined)
4100 ecoff_data (abfd)->gp = (h->u.def.value
4101 + h->u.def.section->output_section->vma
4102 + h->u.def.section->output_offset);
4103 else if (info->relocateable)
4104 {
4105 bfd_vma lo;
4106
4107 /* Make up a value. */
4108 lo = (bfd_vma) -1;
4109 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4110 {
4111 if (o->vma < lo
4112 && (strcmp (o->name, _SBSS) == 0
4113 || strcmp (o->name, _SDATA) == 0
4114 || strcmp (o->name, _LIT4) == 0
4115 || strcmp (o->name, _LIT8) == 0
4116 || strcmp (o->name, _LITA) == 0))
4117 lo = o->vma;
4118 }
4119 ecoff_data (abfd)->gp = lo + 0x8000;
4120 }
4121 else
4122 {
4123 /* If the relocate_section function needs to do a reloc
4124 involving the GP value, it should make a reloc_dangerous
4125 callback to warn that GP is not defined. */
4126 }
4127 }
4128
4129 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4130 {
966e0a16
ILT		 4131 for (p = o->link_order_head;
4132 p != (struct bfd_link_order *) NULL;
4133 p = p->next)
4134 {
966e0a16
ILT		 4135 if (p->type == bfd_indirect_link_order
4136 && (bfd_get_flavour (p->u.indirect.section->owner)
4137 == bfd_target_ecoff_flavour))
4138 {
4139 if (! ecoff_indirect_link_order (abfd, info, o, p))
4140 return false;
4141 }
a3a33af3
ILT		 4142 else if (p->type == bfd_section_reloc_link_order
4143 || p->type == bfd_symbol_reloc_link_order)
4144 {
4145 if (! ecoff_reloc_link_order (abfd, info, o, p))
4146 return false;
4147 }
966e0a16
ILT		 4148 else
4149 {
4150 if (! _bfd_default_link_order (abfd, info, o, p))
4151 return false;
4152 }
4153 }
4154 }
4155
4156 bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax;
4157
469984d1
ILT		 4158 ecoff_data (abfd)->linker = true;
4159
966e0a16
ILT		 4160 return true;
4161}
4162
4163/* Accumulate the debugging information for an input BFD into the
4164 output BFD. This must read in the symbolic information of the
4165 input BFD. */
4166
4167static boolean
3f048f7f 4168ecoff_final_link_debug_accumulate (output_bfd, input_bfd, info, handle)
966e0a16
ILT		 4169 bfd *output_bfd;
4170 bfd *input_bfd;
4171 struct bfd_link_info *info;
3f048f7f 4172 PTR handle;
966e0a16
ILT		 4173{
4174 struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info;
4175 const struct ecoff_debug_swap * const swap =
4176 &ecoff_backend (input_bfd)->debug_swap;
4177 HDRR *symhdr = &debug->symbolic_header;
4178 boolean ret;
4179
4180#define READ(ptr, offset, count, size, type) \
4181 if (symhdr->count == 0) \
4182 debug->ptr = NULL; \
4183 else \
4184 { \
58142f10 4185 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
80425e6c
JK		 4186 if (debug->ptr == NULL) \
4187 { \
80425e6c
JK		 4188 ret = false; \
4189 goto return_something; \
4190 } \
966e0a16
ILT		 4191 if ((bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) \
4192 != 0) \
4193 || (bfd_read (debug->ptr, size, symhdr->count, \
4194 input_bfd) != size * symhdr->count)) \
80425e6c
JK		 4195 { \
4196 ret = false; \
4197 goto return_something; \
4198 } \
966e0a16
ILT		 4199 }
4200
a3a33af3 4201 /* If raw_syments is not NULL, then the data was already by read by
75f3ef7a 4202 _bfd_ecoff_slurp_symbolic_info. */
a3a33af3
ILT		 4203 if (ecoff_data (input_bfd)->raw_syments == NULL)
4204 {
4205 READ (line, cbLineOffset, cbLine, sizeof (unsigned char),
4206 unsigned char *);
4207 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
4208 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
4209 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
4210 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
4211 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
4212 union aux_ext *);
4213 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
4214 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
4215 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
4216 }
966e0a16
ILT		 4217#undef READ
4218
4219 /* We do not read the external strings or the external symbols. */
4220
4221 ret = (bfd_ecoff_debug_accumulate
3f048f7f 4222 (handle, output_bfd, &ecoff_data (output_bfd)->debug_info,
966e0a16 4223 &ecoff_backend (output_bfd)->debug_swap,
3f048f7f 4224 input_bfd, debug, swap, info));
966e0a16 4225
80425e6c 4226 return_something:
a3a33af3
ILT		 4227 if (ecoff_data (input_bfd)->raw_syments == NULL)
4228 {
4229 if (debug->line != NULL)
4230 free (debug->line);
4231 if (debug->external_dnr != NULL)
4232 free (debug->external_dnr);
4233 if (debug->external_pdr != NULL)
4234 free (debug->external_pdr);
4235 if (debug->external_sym != NULL)
4236 free (debug->external_sym);
4237 if (debug->external_opt != NULL)
4238 free (debug->external_opt);
4239 if (debug->external_aux != NULL)
4240 free (debug->external_aux);
4241 if (debug->ss != NULL)
4242 free (debug->ss);
4243 if (debug->external_fdr != NULL)
4244 free (debug->external_fdr);
4245 if (debug->external_rfd != NULL)
4246 free (debug->external_rfd);
4247
4248 /* Make sure we don't accidentally follow one of these pointers
4249 into freed memory. */
4250 debug->line = NULL;
4251 debug->external_dnr = NULL;
4252 debug->external_pdr = NULL;
4253 debug->external_sym = NULL;
4254 debug->external_opt = NULL;
4255 debug->external_aux = NULL;
4256 debug->ss = NULL;
4257 debug->external_fdr = NULL;
4258 debug->external_rfd = NULL;
4259 }
966e0a16
ILT		 4260
4261 return ret;
4262}
4263
4264/* Put out information for an external symbol. These come only from
4265 the hash table. */
4266
4267static boolean
4268ecoff_link_write_external (h, data)
4269 struct ecoff_link_hash_entry *h;
4270 PTR data;
4271{
4272 bfd *output_bfd = (bfd *) data;
4273
4274 /* FIXME: We should check if this symbol is being stripped. */
4275
ac9ed096 4276 if (h->written)
966e0a16
ILT		 4277 return true;
4278
4279 if (h->abfd == (bfd *) NULL)
4280 {
4281 h->esym.jmptbl = 0;
4282 h->esym.cobol_main = 0;
4283 h->esym.weakext = 0;
4284 h->esym.reserved = 0;
4285 h->esym.ifd = ifdNil;
4286 h->esym.asym.value = 0;
966e0a16 4287 h->esym.asym.st = stGlobal;
a3a33af3 4288
6c97aedf
ILT		 4289 if (h->root.type != bfd_link_hash_defined
4290 && h->root.type != bfd_link_hash_defweak)
a3a33af3
ILT		 4291 h->esym.asym.sc = scAbs;
4292 else
4293 {
4294 asection *output_section;
4295 const char *name;
4296
4297 output_section = h->root.u.def.section->output_section;
4298 name = bfd_section_name (output_section->owner, output_section);
4299
4300 if (strcmp (name, _TEXT) == 0)
4301 h->esym.asym.sc = scText;
4302 else if (strcmp (name, _DATA) == 0)
4303 h->esym.asym.sc = scData;
4304 else if (strcmp (name, _SDATA) == 0)
4305 h->esym.asym.sc = scSData;
4306 else if (strcmp (name, _RDATA) == 0)
4307 h->esym.asym.sc = scRData;
4308 else if (strcmp (name, _BSS) == 0)
4309 h->esym.asym.sc = scBss;
4310 else if (strcmp (name, _SBSS) == 0)
4311 h->esym.asym.sc = scSBss;
4312 else if (strcmp (name, _INIT) == 0)
4313 h->esym.asym.sc = scInit;
4314 else if (strcmp (name, _FINI) == 0)
4315 h->esym.asym.sc = scFini;
4316 else if (strcmp (name, _PDATA) == 0)
4317 h->esym.asym.sc = scPData;
4318 else if (strcmp (name, _XDATA) == 0)
4319 h->esym.asym.sc = scXData;
a877f591
ILT		 4320 else if (strcmp (name, _RCONST) == 0)
4321 h->esym.asym.sc = scRConst;
a3a33af3
ILT		 4322 else
4323 h->esym.asym.sc = scAbs;
4324 }
4325
966e0a16
ILT		 4326 h->esym.asym.reserved = 0;
4327 h->esym.asym.index = indexNil;
4328 }
3f048f7f 4329 else if (h->esym.ifd != -1)
966e0a16 4330 {
3f048f7f
ILT		 4331 struct ecoff_debug_info *debug;
4332
966e0a16
ILT		 4333 /* Adjust the FDR index for the symbol by that used for the
4334 input BFD. */
3f048f7f
ILT		 4335 debug = &ecoff_data (h->abfd)->debug_info;
4336 BFD_ASSERT (h->esym.ifd >= 0
4337 && h->esym.ifd < debug->symbolic_header.ifdMax);
4338 h->esym.ifd = debug->ifdmap[h->esym.ifd];
966e0a16
ILT		 4339 }
4340
4341 switch (h->root.type)
4342 {
4343 default:
4344 case bfd_link_hash_new:
4345 abort ();
4346 case bfd_link_hash_undefined:
6c97aedf 4347 case bfd_link_hash_undefweak:
a3a33af3
ILT		 4348 if (h->esym.asym.sc != scUndefined
4349 && h->esym.asym.sc != scSUndefined)
4350 h->esym.asym.sc = scUndefined;
966e0a16
ILT		 4351 break;
4352 case bfd_link_hash_defined:
6c97aedf 4353 case bfd_link_hash_defweak:
966e0a16
ILT		 4354 if (h->esym.asym.sc == scUndefined
4355 || h->esym.asym.sc == scSUndefined)
4356 h->esym.asym.sc = scAbs;
4357 else if (h->esym.asym.sc == scCommon)
4358 h->esym.asym.sc = scBss;
4359 else if (h->esym.asym.sc == scSCommon)
4360 h->esym.asym.sc = scSBss;
4361 h->esym.asym.value = (h->root.u.def.value
4362 + h->root.u.def.section->output_section->vma
4363 + h->root.u.def.section->output_offset);
4364 break;
4365 case bfd_link_hash_common:
4366 if (h->esym.asym.sc != scCommon
4367 && h->esym.asym.sc != scSCommon)
4368 h->esym.asym.sc = scCommon;
4369 h->esym.asym.value = h->root.u.c.size;
4370 break;
4371 case bfd_link_hash_indirect:
4372 case bfd_link_hash_warning:
4373 /* FIXME: Ignore these for now. The circumstances under which
4374 they should be written out are not clear to me. */
4375 return true;
4376 }
4377
4378 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4379 symbol number. */
4380 h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax;
ac9ed096 4381 h->written = 1;
966e0a16
ILT		 4382
4383 return (bfd_ecoff_debug_one_external
4384 (output_bfd, &ecoff_data (output_bfd)->debug_info,
4385 &ecoff_backend (output_bfd)->debug_swap, h->root.root.string,
4386 &h->esym));
4387}
4388
4389/* Relocate and write an ECOFF section into an ECOFF output file. */
4390
4391static boolean
4392ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
4393 bfd *output_bfd;
4394 struct bfd_link_info *info;
4395 asection *output_section;
4396 struct bfd_link_order *link_order;
4397{
4398 asection *input_section;
4399 bfd *input_bfd;
a3a33af3
ILT		 4400 struct ecoff_section_tdata *section_tdata;
4401 bfd_size_type raw_size;
4402 bfd_size_type cooked_size;
80425e6c 4403 bfd_byte *contents = NULL;
966e0a16
ILT		 4404 bfd_size_type external_reloc_size;
4405 bfd_size_type external_relocs_size;
80425e6c 4406 PTR external_relocs = NULL;
966e0a16
ILT		 4407
4408 BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
4409
4410 if (link_order->size == 0)
4411 return true;
4412
4413 input_section = link_order->u.indirect.section;
4414 input_bfd = input_section->owner;
a3a33af3
ILT		 4415 section_tdata = ecoff_section_data (input_bfd, input_section);
4416
4417 raw_size = input_section->_raw_size;
4418 cooked_size = input_section->_cooked_size;
4419 if (cooked_size == 0)
4420 cooked_size = raw_size;
966e0a16
ILT		 4421
4422 BFD_ASSERT (input_section->output_section == output_section);
4423 BFD_ASSERT (input_section->output_offset == link_order->offset);
a3a33af3
ILT		 4424 BFD_ASSERT (cooked_size == link_order->size);
4425
4426 /* Get the section contents. We allocate memory for the larger of
4427 the size before relocating and the size after relocating. */
58142f10
ILT		 4428 contents = (bfd_byte *) bfd_malloc (raw_size >= cooked_size
4429 ? (size_t) raw_size
4430 : (size_t) cooked_size);
a3a33af3 4431 if (contents == NULL && raw_size != 0)
58142f10 4432 goto error_return;
966e0a16 4433
a3a33af3
ILT		 4434 /* If we are relaxing, the contents may have already been read into
4435 memory, in which case we copy them into our new buffer. We don't
4436 simply reuse the old buffer in case cooked_size > raw_size. */
4437 if (section_tdata != (struct ecoff_section_tdata *) NULL
4438 && section_tdata->contents != (bfd_byte *) NULL)
ae115e51 4439 memcpy (contents, section_tdata->contents, (size_t) raw_size);
a3a33af3
ILT		 4440 else
4441 {
4442 if (! bfd_get_section_contents (input_bfd, input_section,
4443 (PTR) contents,
4444 (file_ptr) 0, raw_size))
4445 goto error_return;
4446 }
4447
4448 /* Get the relocs. If we are relaxing MIPS code, they will already
4449 have been read in. Otherwise, we read them in now. */
966e0a16
ILT		 4450 external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size;
4451 external_relocs_size = external_reloc_size * input_section->reloc_count;
a3a33af3 4452
0652d579
ILT		 4453 if (section_tdata != (struct ecoff_section_tdata *) NULL
4454 && section_tdata->external_relocs != NULL)
a3a33af3
ILT		 4455 external_relocs = section_tdata->external_relocs;
4456 else
80425e6c 4457 {
58142f10 4458 external_relocs = (PTR) bfd_malloc ((size_t) external_relocs_size);
a3a33af3 4459 if (external_relocs == NULL && external_relocs_size != 0)
58142f10 4460 goto error_return;
80425e6c 4461
a3a33af3
ILT		 4462 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4463 || (bfd_read (external_relocs, 1, external_relocs_size, input_bfd)
4464 != external_relocs_size))
4465 goto error_return;
4466 }
966e0a16
ILT		 4467
4468 /* Relocate the section contents. */
4469 if (! ((*ecoff_backend (input_bfd)->relocate_section)
4470 (output_bfd, info, input_bfd, input_section, contents,
4471 external_relocs)))
80425e6c 4472 goto error_return;
966e0a16
ILT		 4473
4474 /* Write out the relocated section. */
4475 if (! bfd_set_section_contents (output_bfd,
4476 output_section,
4477 (PTR) contents,
4478 input_section->output_offset,
a3a33af3 4479 cooked_size))
80425e6c 4480 goto error_return;
966e0a16
ILT		 4481
4482 /* If we are producing relocateable output, the relocs were
4483 modified, and we write them out now. We use the reloc_count
4484 field of output_section to keep track of the number of relocs we
4485 have output so far. */
4486 if (info->relocateable)
4487 {
4488 if (bfd_seek (output_bfd,
4489 (output_section->rel_filepos +
4490 output_section->reloc_count * external_reloc_size),
4491 SEEK_SET) != 0
4492 || (bfd_write (external_relocs, 1, external_relocs_size, output_bfd)
4493 != external_relocs_size))
80425e6c 4494 goto error_return;
966e0a16
ILT		 4495 output_section->reloc_count += input_section->reloc_count;
4496 }
4497
80425e6c
JK		 4498 if (contents != NULL)
4499 free (contents);
a3a33af3 4500 if (external_relocs != NULL && section_tdata == NULL)
80425e6c 4501 free (external_relocs);
966e0a16 4502 return true;
80425e6c
JK		 4503
4504 error_return:
4505 if (contents != NULL)
4506 free (contents);
a3a33af3 4507 if (external_relocs != NULL && section_tdata == NULL)
80425e6c
JK		 4508 free (external_relocs);
4509 return false;
966e0a16 4510}
a3a33af3
ILT		 4511
4512/* Generate a reloc when linking an ECOFF file. This is a reloc
4513 requested by the linker, and does come from any input file. This
4514 is used to build constructor and destructor tables when linking
4515 with -Ur. */
4516
4517static boolean
4518ecoff_reloc_link_order (output_bfd, info, output_section, link_order)
4519 bfd *output_bfd;
4520 struct bfd_link_info *info;
4521 asection *output_section;
4522 struct bfd_link_order *link_order;
4523{
a877f591
ILT		 4524 enum bfd_link_order_type type;
4525 asection *section;
4526 bfd_vma addend;
a3a33af3
ILT		 4527 arelent rel;
4528 struct internal_reloc in;
4529 bfd_size_type external_reloc_size;
4530 bfd_byte *rbuf;
4531 boolean ok;
4532
a877f591
ILT		 4533 type = link_order->type;
4534 section = NULL;
4535 addend = link_order->u.reloc.p->addend;
4536
a3a33af3
ILT		 4537 /* We set up an arelent to pass to the backend adjust_reloc_out
4538 routine. */
4539 rel.address = link_order->offset;
4540
4541 rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
6c97aedf 4542 if (rel.howto == 0)
a3a33af3
ILT		 4543 {
4544 bfd_set_error (bfd_error_bad_value);
4545 return false;
4546 }
4547
a877f591
ILT		 4548 if (type == bfd_section_reloc_link_order)
4549 {
4550 section = link_order->u.reloc.p->u.section;
4551 rel.sym_ptr_ptr = section->symbol_ptr_ptr;
4552 }
a3a33af3
ILT		 4553 else
4554 {
a877f591
ILT		 4555 struct bfd_link_hash_entry *h;
4556
4557 /* Treat a reloc against a defined symbol as though it were
4558 actually against the section. */
4559 h = bfd_link_hash_lookup (info->hash, link_order->u.reloc.p->u.name,
4560 false, false, false);
4561 if (h != NULL
4562 && (h->type == bfd_link_hash_defined
4563 || h->type == bfd_link_hash_defweak))
4564 {
4565 type = bfd_section_reloc_link_order;
4566 section = h->u.def.section->output_section;
4567 /* It seems that we ought to add the symbol value to the
4568 addend here, but in practice it has already been added
4569 because it was passed to constructor_callback. */
4570 addend += section->vma + h->u.def.section->output_offset;
4571 }
4572 else
4573 {
4574 /* We can't set up a reloc against a symbol correctly,
4575 because we have no asymbol structure. Currently no
4576 adjust_reloc_out routine cares. */
4577 rel.sym_ptr_ptr = (asymbol **) NULL;
4578 }
a3a33af3
ILT		 4579 }
4580
4581 /* All ECOFF relocs are in-place. Put the addend into the object
4582 file. */
4583
4584 BFD_ASSERT (rel.howto->partial_inplace);
a877f591 4585 if (addend != 0)
a3a33af3
ILT		 4586 {
4587 bfd_size_type size;
4588 bfd_reloc_status_type rstat;
4589 bfd_byte *buf;
4590 boolean ok;
4591
4592 size = bfd_get_reloc_size (rel.howto);
4593 buf = (bfd_byte *) bfd_zmalloc (size);
4594 if (buf == (bfd_byte *) NULL)
a9713b91 4595 return false;
a877f591 4596 rstat = _bfd_relocate_contents (rel.howto, output_bfd, addend, buf);
a3a33af3
ILT		 4597 switch (rstat)
4598 {
4599 case bfd_reloc_ok:
4600 break;
4601 default:
4602 case bfd_reloc_outofrange:
4603 abort ();
4604 case bfd_reloc_overflow:
4605 if (! ((*info->callbacks->reloc_overflow)
4606 (info,
4607 (link_order->type == bfd_section_reloc_link_order
a877f591 4608 ? bfd_section_name (output_bfd, section)
a3a33af3 4609 : link_order->u.reloc.p->u.name),
a877f591
ILT		 4610 rel.howto->name, addend, (bfd *) NULL,
4611 (asection *) NULL, (bfd_vma) 0)))
a3a33af3
ILT		 4612 {
4613 free (buf);
4614 return false;
4615 }
4616 break;
4617 }
4618 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
4619 (file_ptr) link_order->offset, size);
4620 free (buf);
4621 if (! ok)
4622 return false;
4623 }
4624
4625 rel.addend = 0;
4626
4627 /* Move the information into a internal_reloc structure. */
4628 in.r_vaddr = (rel.address
4629 + bfd_get_section_vma (output_bfd, output_section));
4630 in.r_type = rel.howto->type;
4631
a877f591 4632 if (type == bfd_symbol_reloc_link_order)
a3a33af3
ILT		 4633 {
4634 struct ecoff_link_hash_entry *h;
4635
4636 h = ecoff_link_hash_lookup (ecoff_hash_table (info),
4637 link_order->u.reloc.p->u.name,
4638 false, false, true);
4639 if (h != (struct ecoff_link_hash_entry *) NULL
4640 && h->indx != -1)
4641 in.r_symndx = h->indx;
4642 else
4643 {
4644 if (! ((*info->callbacks->unattached_reloc)
4645 (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
4646 (asection *) NULL, (bfd_vma) 0)))
4647 return false;
4648 in.r_symndx = 0;
4649 }
4650 in.r_extern = 1;
4651 }
4652 else
4653 {
4654 CONST char *name;
4655
a877f591 4656 name = bfd_get_section_name (output_bfd, section);
a3a33af3
ILT		 4657 if (strcmp (name, ".text") == 0)
4658 in.r_symndx = RELOC_SECTION_TEXT;
4659 else if (strcmp (name, ".rdata") == 0)
4660 in.r_symndx = RELOC_SECTION_RDATA;
4661 else if (strcmp (name, ".data") == 0)
4662 in.r_symndx = RELOC_SECTION_DATA;
4663 else if (strcmp (name, ".sdata") == 0)
4664 in.r_symndx = RELOC_SECTION_SDATA;
4665 else if (strcmp (name, ".sbss") == 0)
4666 in.r_symndx = RELOC_SECTION_SBSS;
4667 else if (strcmp (name, ".bss") == 0)
4668 in.r_symndx = RELOC_SECTION_BSS;
4669 else if (strcmp (name, ".init") == 0)
4670 in.r_symndx = RELOC_SECTION_INIT;
4671 else if (strcmp (name, ".lit8") == 0)
4672 in.r_symndx = RELOC_SECTION_LIT8;
4673 else if (strcmp (name, ".lit4") == 0)
4674 in.r_symndx = RELOC_SECTION_LIT4;
4675 else if (strcmp (name, ".xdata") == 0)
4676 in.r_symndx = RELOC_SECTION_XDATA;
4677 else if (strcmp (name, ".pdata") == 0)
4678 in.r_symndx = RELOC_SECTION_PDATA;
4679 else if (strcmp (name, ".fini") == 0)
4680 in.r_symndx = RELOC_SECTION_FINI;
4681 else if (strcmp (name, ".lita") == 0)
4682 in.r_symndx = RELOC_SECTION_LITA;
4683 else if (strcmp (name, "*ABS*") == 0)
4684 in.r_symndx = RELOC_SECTION_ABS;
a877f591
ILT		 4685 else if (strcmp (name, ".rconst") == 0)
4686 in.r_symndx = RELOC_SECTION_RCONST;
a3a33af3
ILT		 4687 else
4688 abort ();
4689 in.r_extern = 0;
4690 }
4691
4692 /* Let the BFD backend adjust the reloc. */
4693 (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in);
4694
4695 /* Get some memory and swap out the reloc. */
4696 external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
58142f10 4697 rbuf = (bfd_byte *) bfd_malloc ((size_t) external_reloc_size);
a3a33af3 4698 if (rbuf == (bfd_byte *) NULL)
58142f10 4699 return false;
a3a33af3
ILT		 4700
4701 (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (PTR) rbuf);
4702
4703 ok = (bfd_seek (output_bfd,
4704 (output_section->rel_filepos +
4705 output_section->reloc_count * external_reloc_size),
4706 SEEK_SET) == 0
4707 && (bfd_write ((PTR) rbuf, 1, external_reloc_size, output_bfd)
4708 == external_reloc_size));
4709
4710 if (ok)
4711 ++output_section->reloc_count;
4712
4713 free (rbuf);
4714
4715 return ok;
4716}
GDB Binutils - Deliverables
This page took 0.341469 seconds and 4 git commands to generate.