OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [ecoff.c] - Blame information for rev 179

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.