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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [bfd/] [ecoff.c] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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