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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [bfd/] [ecoff.c] - Blame information for rev 818

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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