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

Subversion Repositories or1k

[/] [or1k/] [tags/] [start/] [gdb-5.0/] [bfd/] [coff-alpha.c] - Blame information for rev 1778

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

Line No. Rev Author Line
1 104 markom
/* BFD back-end for ALPHA Extended-Coff files.
2
   Copyright 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
3
   Modified from coff-mips.c by Steve Chamberlain <sac@cygnus.com> and
4
   Ian Lance Taylor <ian@cygnus.com>.
5
 
6
This file is part of BFD, the Binary File Descriptor library.
7
 
8
This program is free software; you can redistribute it and/or modify
9
it under the terms of the GNU General Public License as published by
10
the Free Software Foundation; either version 2 of the License, or
11
(at your option) any later version.
12
 
13
This program is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
GNU General Public License for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with this program; if not, write to the Free Software
20
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
21
 
22
#include "bfd.h"
23
#include "sysdep.h"
24
#include "bfdlink.h"
25
#include "libbfd.h"
26
#include "coff/internal.h"
27
#include "coff/sym.h"
28
#include "coff/symconst.h"
29
#include "coff/ecoff.h"
30
#include "coff/alpha.h"
31
#include "aout/ar.h"
32
#include "libcoff.h"
33
#include "libecoff.h"
34
 
35
/* Prototypes for static functions.  */
36
 
37
static const bfd_target *alpha_ecoff_object_p PARAMS ((bfd *));
38
static boolean alpha_ecoff_bad_format_hook PARAMS ((bfd *abfd, PTR filehdr));
39
static PTR alpha_ecoff_mkobject_hook PARAMS ((bfd *, PTR filehdr, PTR aouthdr));
40
static void alpha_ecoff_swap_reloc_in PARAMS ((bfd *, PTR,
41
                                              struct internal_reloc *));
42
static void alpha_ecoff_swap_reloc_out PARAMS ((bfd *,
43
                                               const struct internal_reloc *,
44
                                               PTR));
45
static void alpha_adjust_reloc_in PARAMS ((bfd *,
46
                                           const struct internal_reloc *,
47
                                           arelent *));
48
static void alpha_adjust_reloc_out PARAMS ((bfd *, const arelent *,
49
                                            struct internal_reloc *));
50
static reloc_howto_type *alpha_bfd_reloc_type_lookup
51
 PARAMS ((bfd *, bfd_reloc_code_real_type));
52
static bfd_byte *alpha_ecoff_get_relocated_section_contents
53
  PARAMS ((bfd *abfd, struct bfd_link_info *, struct bfd_link_order *,
54
           bfd_byte *data, boolean relocateable, asymbol **symbols));
55
static bfd_vma alpha_convert_external_reloc
56
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, struct external_reloc *,
57
           struct ecoff_link_hash_entry *));
58
static boolean alpha_relocate_section PARAMS ((bfd *, struct bfd_link_info *,
59
                                               bfd *, asection *,
60
                                               bfd_byte *, PTR));
61
static boolean alpha_adjust_headers
62
  PARAMS ((bfd *, struct internal_filehdr *, struct internal_aouthdr *));
63
static PTR alpha_ecoff_read_ar_hdr PARAMS ((bfd *));
64
static bfd *alpha_ecoff_get_elt_at_filepos PARAMS ((bfd *, file_ptr));
65
static bfd *alpha_ecoff_openr_next_archived_file PARAMS ((bfd *, bfd *));
66
static bfd *alpha_ecoff_get_elt_at_index PARAMS ((bfd *, symindex));
67
 
68
/* ECOFF has COFF sections, but the debugging information is stored in
69
   a completely different format.  ECOFF targets use some of the
70
   swapping routines from coffswap.h, and some of the generic COFF
71
   routines in coffgen.c, but, unlike the real COFF targets, do not
72
   use coffcode.h itself.
73
 
74
   Get the generic COFF swapping routines, except for the reloc,
75
   symbol, and lineno ones.  Give them ecoff names.  Define some
76
   accessor macros for the large sizes used for Alpha ECOFF.  */
77
 
78
#define GET_FILEHDR_SYMPTR bfd_h_get_64
79
#define PUT_FILEHDR_SYMPTR bfd_h_put_64
80
#define GET_AOUTHDR_TSIZE bfd_h_get_64
81
#define PUT_AOUTHDR_TSIZE bfd_h_put_64
82
#define GET_AOUTHDR_DSIZE bfd_h_get_64
83
#define PUT_AOUTHDR_DSIZE bfd_h_put_64
84
#define GET_AOUTHDR_BSIZE bfd_h_get_64
85
#define PUT_AOUTHDR_BSIZE bfd_h_put_64
86
#define GET_AOUTHDR_ENTRY bfd_h_get_64
87
#define PUT_AOUTHDR_ENTRY bfd_h_put_64
88
#define GET_AOUTHDR_TEXT_START bfd_h_get_64
89
#define PUT_AOUTHDR_TEXT_START bfd_h_put_64
90
#define GET_AOUTHDR_DATA_START bfd_h_get_64
91
#define PUT_AOUTHDR_DATA_START bfd_h_put_64
92
#define GET_SCNHDR_PADDR bfd_h_get_64
93
#define PUT_SCNHDR_PADDR bfd_h_put_64
94
#define GET_SCNHDR_VADDR bfd_h_get_64
95
#define PUT_SCNHDR_VADDR bfd_h_put_64
96
#define GET_SCNHDR_SIZE bfd_h_get_64
97
#define PUT_SCNHDR_SIZE bfd_h_put_64
98
#define GET_SCNHDR_SCNPTR bfd_h_get_64
99
#define PUT_SCNHDR_SCNPTR bfd_h_put_64
100
#define GET_SCNHDR_RELPTR bfd_h_get_64
101
#define PUT_SCNHDR_RELPTR bfd_h_put_64
102
#define GET_SCNHDR_LNNOPTR bfd_h_get_64
103
#define PUT_SCNHDR_LNNOPTR bfd_h_put_64
104
 
105
#define ALPHAECOFF
106
 
107
#define NO_COFF_RELOCS
108
#define NO_COFF_SYMBOLS
109
#define NO_COFF_LINENOS
110
#define coff_swap_filehdr_in alpha_ecoff_swap_filehdr_in
111
#define coff_swap_filehdr_out alpha_ecoff_swap_filehdr_out
112
#define coff_swap_aouthdr_in alpha_ecoff_swap_aouthdr_in
113
#define coff_swap_aouthdr_out alpha_ecoff_swap_aouthdr_out
114
#define coff_swap_scnhdr_in alpha_ecoff_swap_scnhdr_in
115
#define coff_swap_scnhdr_out alpha_ecoff_swap_scnhdr_out
116
#include "coffswap.h"
117
 
118
/* Get the ECOFF swapping routines.  */
119
#define ECOFF_64
120
#include "ecoffswap.h"
121
 
122
/* How to process the various reloc types.  */
123
 
124
static bfd_reloc_status_type
125
reloc_nil PARAMS ((bfd *, arelent *, asymbol *, PTR,
126
                   asection *, bfd *, char **));
127
 
128
static bfd_reloc_status_type
129
reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
130
     bfd *abfd;
131
     arelent *reloc;
132
     asymbol *sym;
133
     PTR data;
134
     asection *sec;
135
     bfd *output_bfd;
136
     char **error_message;
137
{
138
  return bfd_reloc_ok;
139
}
140
 
141
/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
142
   from smaller values.  Start with zero, widen, *then* decrement.  */
143
#define MINUS_ONE       (((bfd_vma)0) - 1)
144
 
145
static reloc_howto_type alpha_howto_table[] =
146
{
147
  /* Reloc type 0 is ignored by itself.  However, it appears after a
148
     GPDISP reloc to identify the location where the low order 16 bits
149
     of the gp register are loaded.  */
150
  HOWTO (ALPHA_R_IGNORE,        /* type */
151
         0,                      /* rightshift */
152
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
153
         8,                     /* bitsize */
154
         true,                  /* pc_relative */
155
         0,                      /* bitpos */
156
         complain_overflow_dont, /* complain_on_overflow */
157
         reloc_nil,             /* special_function */
158
         "IGNORE",              /* name */
159
         true,                  /* partial_inplace */
160
         0,                      /* src_mask */
161
         0,                      /* dst_mask */
162
         true),                 /* pcrel_offset */
163
 
164
  /* A 32 bit reference to a symbol.  */
165
  HOWTO (ALPHA_R_REFLONG,       /* type */
166
         0,                      /* rightshift */
167
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
168
         32,                    /* bitsize */
169
         false,                 /* pc_relative */
170
         0,                      /* bitpos */
171
         complain_overflow_bitfield, /* complain_on_overflow */
172
         0,                      /* special_function */
173
         "REFLONG",             /* name */
174
         true,                  /* partial_inplace */
175
         0xffffffff,            /* src_mask */
176
         0xffffffff,            /* dst_mask */
177
         false),                /* pcrel_offset */
178
 
179
  /* A 64 bit reference to a symbol.  */
180
  HOWTO (ALPHA_R_REFQUAD,       /* type */
181
         0,                      /* rightshift */
182
         4,                     /* size (0 = byte, 1 = short, 2 = long) */
183
         64,                    /* bitsize */
184
         false,                 /* pc_relative */
185
         0,                      /* bitpos */
186
         complain_overflow_bitfield, /* complain_on_overflow */
187
         0,                      /* special_function */
188
         "REFQUAD",             /* name */
189
         true,                  /* partial_inplace */
190
         MINUS_ONE,             /* src_mask */
191
         MINUS_ONE,             /* dst_mask */
192
         false),                /* pcrel_offset */
193
 
194
  /* A 32 bit GP relative offset.  This is just like REFLONG except
195
     that when the value is used the value of the gp register will be
196
     added in.  */
197
  HOWTO (ALPHA_R_GPREL32,       /* type */
198
         0,                      /* rightshift */
199
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
200
         32,                    /* bitsize */
201
         false,                 /* pc_relative */
202
         0,                      /* bitpos */
203
         complain_overflow_bitfield, /* complain_on_overflow */
204
         0,                      /* special_function */
205
         "GPREL32",             /* name */
206
         true,                  /* partial_inplace */
207
         0xffffffff,            /* src_mask */
208
         0xffffffff,            /* dst_mask */
209
         false),                /* pcrel_offset */
210
 
211
  /* Used for an instruction that refers to memory off the GP
212
     register.  The offset is 16 bits of the 32 bit instruction.  This
213
     reloc always seems to be against the .lita section.  */
214
  HOWTO (ALPHA_R_LITERAL,       /* type */
215
         0,                      /* rightshift */
216
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
217
         16,                    /* bitsize */
218
         false,                 /* pc_relative */
219
         0,                      /* bitpos */
220
         complain_overflow_signed, /* complain_on_overflow */
221
         0,                      /* special_function */
222
         "LITERAL",             /* name */
223
         true,                  /* partial_inplace */
224
         0xffff,                /* src_mask */
225
         0xffff,                /* dst_mask */
226
         false),                /* pcrel_offset */
227
 
228
  /* This reloc only appears immediately following a LITERAL reloc.
229
     It identifies a use of the literal.  It seems that the linker can
230
     use this to eliminate a portion of the .lita section.  The symbol
231
     index is special: 1 means the literal address is in the base
232
     register of a memory format instruction; 2 means the literal
233
     address is in the byte offset register of a byte-manipulation
234
     instruction; 3 means the literal address is in the target
235
     register of a jsr instruction.  This does not actually do any
236
     relocation.  */
237
  HOWTO (ALPHA_R_LITUSE,        /* type */
238
         0,                      /* rightshift */
239
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
240
         32,                    /* bitsize */
241
         false,                 /* pc_relative */
242
         0,                      /* bitpos */
243
         complain_overflow_dont, /* complain_on_overflow */
244
         reloc_nil,             /* special_function */
245
         "LITUSE",              /* name */
246
         false,                 /* partial_inplace */
247
         0,                      /* src_mask */
248
         0,                      /* dst_mask */
249
         false),                /* pcrel_offset */
250
 
251
  /* Load the gp register.  This is always used for a ldah instruction
252
     which loads the upper 16 bits of the gp register.  The next reloc
253
     will be an IGNORE reloc which identifies the location of the lda
254
     instruction which loads the lower 16 bits.  The symbol index of
255
     the GPDISP instruction appears to actually be the number of bytes
256
     between the ldah and lda instructions.  This gives two different
257
     ways to determine where the lda instruction is; I don't know why
258
     both are used.  The value to use for the relocation is the
259
     difference between the GP value and the current location; the
260
     load will always be done against a register holding the current
261
     address.  */
262
  HOWTO (ALPHA_R_GPDISP,        /* type */
263
         16,                    /* rightshift */
264
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
265
         16,                    /* bitsize */
266
         true,                  /* pc_relative */
267
         0,                      /* bitpos */
268
         complain_overflow_dont, /* complain_on_overflow */
269
         reloc_nil,             /* special_function */
270
         "GPDISP",              /* name */
271
         true,                  /* partial_inplace */
272
         0xffff,                /* src_mask */
273
         0xffff,                /* dst_mask */
274
         true),                 /* pcrel_offset */
275
 
276
  /* A 21 bit branch.  The native assembler generates these for
277
     branches within the text segment, and also fills in the PC
278
     relative offset in the instruction.  */
279
  HOWTO (ALPHA_R_BRADDR,        /* type */
280
         2,                     /* rightshift */
281
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
282
         21,                    /* bitsize */
283
         true,                  /* pc_relative */
284
         0,                      /* bitpos */
285
         complain_overflow_signed, /* complain_on_overflow */
286
         0,                      /* special_function */
287
         "BRADDR",              /* name */
288
         true,                  /* partial_inplace */
289
         0x1fffff,              /* src_mask */
290
         0x1fffff,              /* dst_mask */
291
         false),                /* pcrel_offset */
292
 
293
  /* A hint for a jump to a register.  */
294
  HOWTO (ALPHA_R_HINT,          /* type */
295
         2,                     /* rightshift */
296
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
297
         14,                    /* bitsize */
298
         true,                  /* pc_relative */
299
         0,                      /* bitpos */
300
         complain_overflow_dont, /* complain_on_overflow */
301
         0,                      /* special_function */
302
         "HINT",                /* name */
303
         true,                  /* partial_inplace */
304
         0x3fff,                /* src_mask */
305
         0x3fff,                /* dst_mask */
306
         false),                /* pcrel_offset */
307
 
308
  /* 16 bit PC relative offset.  */
309
  HOWTO (ALPHA_R_SREL16,        /* type */
310
         0,                      /* rightshift */
311
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
312
         16,                    /* bitsize */
313
         true,                  /* pc_relative */
314
         0,                      /* bitpos */
315
         complain_overflow_signed, /* complain_on_overflow */
316
         0,                      /* special_function */
317
         "SREL16",              /* name */
318
         true,                  /* partial_inplace */
319
         0xffff,                /* src_mask */
320
         0xffff,                /* dst_mask */
321
         false),                /* pcrel_offset */
322
 
323
  /* 32 bit PC relative offset.  */
324
  HOWTO (ALPHA_R_SREL32,        /* type */
325
         0,                      /* rightshift */
326
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
327
         32,                    /* bitsize */
328
         true,                  /* pc_relative */
329
         0,                      /* bitpos */
330
         complain_overflow_signed, /* complain_on_overflow */
331
         0,                      /* special_function */
332
         "SREL32",              /* name */
333
         true,                  /* partial_inplace */
334
         0xffffffff,            /* src_mask */
335
         0xffffffff,            /* dst_mask */
336
         false),                /* pcrel_offset */
337
 
338
  /* A 64 bit PC relative offset.  */
339
  HOWTO (ALPHA_R_SREL64,        /* type */
340
         0,                      /* rightshift */
341
         4,                     /* size (0 = byte, 1 = short, 2 = long) */
342
         64,                    /* bitsize */
343
         true,                  /* pc_relative */
344
         0,                      /* bitpos */
345
         complain_overflow_signed, /* complain_on_overflow */
346
         0,                      /* special_function */
347
         "SREL64",              /* name */
348
         true,                  /* partial_inplace */
349
         MINUS_ONE,             /* src_mask */
350
         MINUS_ONE,             /* dst_mask */
351
         false),                /* pcrel_offset */
352
 
353
  /* Push a value on the reloc evaluation stack.  */
354
  HOWTO (ALPHA_R_OP_PUSH,       /* type */
355
         0,                      /* rightshift */
356
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
357
         0,                      /* bitsize */
358
         false,                 /* pc_relative */
359
         0,                      /* bitpos */
360
         complain_overflow_dont, /* complain_on_overflow */
361
         0,                      /* special_function */
362
         "OP_PUSH",             /* name */
363
         false,                 /* partial_inplace */
364
         0,                      /* src_mask */
365
         0,                      /* dst_mask */
366
         false),                /* pcrel_offset */
367
 
368
  /* Store the value from the stack at the given address.  Store it in
369
     a bitfield of size r_size starting at bit position r_offset.  */
370
  HOWTO (ALPHA_R_OP_STORE,      /* type */
371
         0,                      /* rightshift */
372
         4,                     /* size (0 = byte, 1 = short, 2 = long) */
373
         64,                    /* bitsize */
374
         false,                 /* pc_relative */
375
         0,                      /* bitpos */
376
         complain_overflow_dont, /* complain_on_overflow */
377
         0,                      /* special_function */
378
         "OP_STORE",            /* name */
379
         false,                 /* partial_inplace */
380
         0,                      /* src_mask */
381
         MINUS_ONE,             /* dst_mask */
382
         false),                /* pcrel_offset */
383
 
384
  /* Subtract the reloc address from the value on the top of the
385
     relocation stack.  */
386
  HOWTO (ALPHA_R_OP_PSUB,       /* type */
387
         0,                      /* rightshift */
388
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
389
         0,                      /* bitsize */
390
         false,                 /* pc_relative */
391
         0,                      /* bitpos */
392
         complain_overflow_dont, /* complain_on_overflow */
393
         0,                      /* special_function */
394
         "OP_PSUB",             /* name */
395
         false,                 /* partial_inplace */
396
         0,                      /* src_mask */
397
         0,                      /* dst_mask */
398
         false),                /* pcrel_offset */
399
 
400
  /* Shift the value on the top of the relocation stack right by the
401
     given value.  */
402
  HOWTO (ALPHA_R_OP_PRSHIFT,    /* type */
403
         0,                      /* rightshift */
404
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
405
         0,                      /* bitsize */
406
         false,                 /* pc_relative */
407
         0,                      /* bitpos */
408
         complain_overflow_dont, /* complain_on_overflow */
409
         0,                      /* special_function */
410
         "OP_PRSHIFT",          /* name */
411
         false,                 /* partial_inplace */
412
         0,                      /* src_mask */
413
         0,                      /* dst_mask */
414
         false),                /* pcrel_offset */
415
 
416
  /* Adjust the GP value for a new range in the object file.  */
417
  HOWTO (ALPHA_R_GPVALUE,       /* type */
418
         0,                      /* rightshift */
419
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
420
         0,                      /* bitsize */
421
         false,                 /* pc_relative */
422
         0,                      /* bitpos */
423
         complain_overflow_dont, /* complain_on_overflow */
424
         0,                      /* special_function */
425
         "GPVALUE",             /* name */
426
         false,                 /* partial_inplace */
427
         0,                      /* src_mask */
428
         0,                      /* dst_mask */
429
         false)                 /* pcrel_offset */
430
};
431
 
432
/* Recognize an Alpha ECOFF file.  */
433
 
434
static const bfd_target *
435
alpha_ecoff_object_p (abfd)
436
     bfd *abfd;
437
{
438
  static const bfd_target *ret;
439
 
440
  ret = coff_object_p (abfd);
441
 
442
  if (ret != NULL)
443
    {
444
      asection *sec;
445
 
446
      /* Alpha ECOFF has a .pdata section.  The lnnoptr field of the
447
         .pdata section is the number of entries it contains.  Each
448
         entry takes up 8 bytes.  The number of entries is required
449
         since the section is aligned to a 16 byte boundary.  When we
450
         link .pdata sections together, we do not want to include the
451
         alignment bytes.  We handle this on input by faking the size
452
         of the .pdata section to remove the unwanted alignment bytes.
453
         On output we will set the lnnoptr field and force the
454
         alignment.  */
455
      sec = bfd_get_section_by_name (abfd, _PDATA);
456
      if (sec != (asection *) NULL)
457
        {
458
          bfd_size_type size;
459
 
460
          size = sec->line_filepos * 8;
461
          BFD_ASSERT (size == bfd_section_size (abfd, sec)
462
                      || size + 8 == bfd_section_size (abfd, sec));
463
          if (! bfd_set_section_size (abfd, sec, size))
464
            return NULL;
465
        }
466
    }
467
 
468
  return ret;
469
}
470
 
471
/* See whether the magic number matches.  */
472
 
473
static boolean
474
alpha_ecoff_bad_format_hook (abfd, filehdr)
475
     bfd *abfd;
476
     PTR filehdr;
477
{
478
  struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
479
 
480
  if (ALPHA_ECOFF_BADMAG (*internal_f))
481
    return false;
482
 
483
  return true;
484
}
485
 
486
/* This is a hook called by coff_real_object_p to create any backend
487
   specific information.  */
488
 
489
static PTR
490
alpha_ecoff_mkobject_hook (abfd, filehdr, aouthdr)
491
     bfd *abfd;
492
     PTR filehdr;
493
     PTR aouthdr;
494
{
495
  PTR ecoff;
496
 
497
  ecoff = _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr);
498
 
499
  if (ecoff != NULL)
500
    {
501
      struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
502
 
503
      /* Set additional BFD flags according to the object type from the
504
         machine specific file header flags.  */
505
      switch (internal_f->f_flags & F_ALPHA_OBJECT_TYPE_MASK)
506
        {
507
        case F_ALPHA_SHARABLE:
508
          abfd->flags |= DYNAMIC;
509
          break;
510
        case F_ALPHA_CALL_SHARED:
511
          /* Always executable if using shared libraries as the run time
512
             loader might resolve undefined references.  */
513
          abfd->flags |= (DYNAMIC | EXEC_P);
514
          break;
515
        }
516
    }
517
  return ecoff;
518
}
519
 
520
/* Reloc handling.  */
521
 
522
/* Swap a reloc in.  */
523
 
524
static void
525
alpha_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
526
     bfd *abfd;
527
     PTR ext_ptr;
528
     struct internal_reloc *intern;
529
{
530
  const RELOC *ext = (RELOC *) ext_ptr;
531
 
532
  intern->r_vaddr = bfd_h_get_64 (abfd, (bfd_byte *) ext->r_vaddr);
533
  intern->r_symndx = bfd_h_get_32 (abfd, (bfd_byte *) ext->r_symndx);
534
 
535
  BFD_ASSERT (bfd_header_little_endian (abfd));
536
 
537
  intern->r_type = ((ext->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
538
                    >> RELOC_BITS0_TYPE_SH_LITTLE);
539
  intern->r_extern = (ext->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
540
  intern->r_offset = ((ext->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
541
                      >> RELOC_BITS1_OFFSET_SH_LITTLE);
542
  /* Ignored the reserved bits.  */
543
  intern->r_size = ((ext->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
544
                    >> RELOC_BITS3_SIZE_SH_LITTLE);
545
 
546
  if (intern->r_type == ALPHA_R_LITUSE
547
      || intern->r_type == ALPHA_R_GPDISP)
548
    {
549
      /* Handle the LITUSE and GPDISP relocs specially.  Its symndx
550
         value is not actually a symbol index, but is instead a
551
         special code.  We put the code in the r_size field, and
552
         clobber the symndx.  */
553
      if (intern->r_size != 0)
554
        abort ();
555
      intern->r_size = intern->r_symndx;
556
      intern->r_symndx = RELOC_SECTION_NONE;
557
    }
558
  else if (intern->r_type == ALPHA_R_IGNORE)
559
    {
560
      /* The IGNORE reloc generally follows a GPDISP reloc, and is
561
         against the .lita section.  The section is irrelevant.  */
562
      if (! intern->r_extern &&
563
          intern->r_symndx == RELOC_SECTION_ABS)
564
        abort ();
565
      if (! intern->r_extern && intern->r_symndx == RELOC_SECTION_LITA)
566
        intern->r_symndx = RELOC_SECTION_ABS;
567
    }
568
}
569
 
570
/* Swap a reloc out.  */
571
 
572
static void
573
alpha_ecoff_swap_reloc_out (abfd, intern, dst)
574
     bfd *abfd;
575
     const struct internal_reloc *intern;
576
     PTR dst;
577
{
578
  RELOC *ext = (RELOC *) dst;
579
  long symndx;
580
  unsigned char size;
581
 
582
  /* Undo the hackery done in swap_reloc_in.  */
583
  if (intern->r_type == ALPHA_R_LITUSE
584
      || intern->r_type == ALPHA_R_GPDISP)
585
    {
586
      symndx = intern->r_size;
587
      size = 0;
588
    }
589
  else if (intern->r_type == ALPHA_R_IGNORE
590
           && ! intern->r_extern
591
           && intern->r_symndx == RELOC_SECTION_ABS)
592
    {
593
      symndx = RELOC_SECTION_LITA;
594
      size = intern->r_size;
595
    }
596
  else
597
    {
598
      symndx = intern->r_symndx;
599
      size = intern->r_size;
600
    }
601
 
602
  BFD_ASSERT (intern->r_extern
603
              || (intern->r_symndx >= 0 && intern->r_symndx <= 14));
604
 
605
  bfd_h_put_64 (abfd, intern->r_vaddr, (bfd_byte *) ext->r_vaddr);
606
  bfd_h_put_32 (abfd, symndx, (bfd_byte *) ext->r_symndx);
607
 
608
  BFD_ASSERT (bfd_header_little_endian (abfd));
609
 
610
  ext->r_bits[0] = ((intern->r_type << RELOC_BITS0_TYPE_SH_LITTLE)
611
                    & RELOC_BITS0_TYPE_LITTLE);
612
  ext->r_bits[1] = ((intern->r_extern ? RELOC_BITS1_EXTERN_LITTLE : 0)
613
                    | ((intern->r_offset << RELOC_BITS1_OFFSET_SH_LITTLE)
614
                       & RELOC_BITS1_OFFSET_LITTLE));
615
  ext->r_bits[2] = 0;
616
  ext->r_bits[3] = ((size << RELOC_BITS3_SIZE_SH_LITTLE)
617
                    & RELOC_BITS3_SIZE_LITTLE);
618
}
619
 
620
/* Finish canonicalizing a reloc.  Part of this is generic to all
621
   ECOFF targets, and that part is in ecoff.c.  The rest is done in
622
   this backend routine.  It must fill in the howto field.  */
623
 
624
static void
625
alpha_adjust_reloc_in (abfd, intern, rptr)
626
     bfd *abfd;
627
     const struct internal_reloc *intern;
628
     arelent *rptr;
629
{
630
  if (intern->r_type > ALPHA_R_GPVALUE)
631
    abort ();
632
 
633
  switch (intern->r_type)
634
    {
635
    case ALPHA_R_BRADDR:
636
    case ALPHA_R_SREL16:
637
    case ALPHA_R_SREL32:
638
    case ALPHA_R_SREL64:
639
      /* This relocs appear to be fully resolved when they are against
640
         internal symbols.  Against external symbols, BRADDR at least
641
         appears to be resolved against the next instruction.  */
642
      if (! intern->r_extern)
643
        rptr->addend = 0;
644
      else
645
        rptr->addend = - (intern->r_vaddr + 4);
646
      break;
647
 
648
    case ALPHA_R_GPREL32:
649
    case ALPHA_R_LITERAL:
650
      /* Copy the gp value for this object file into the addend, to
651
         ensure that we are not confused by the linker.  */
652
      if (! intern->r_extern)
653
        rptr->addend += ecoff_data (abfd)->gp;
654
      break;
655
 
656
    case ALPHA_R_LITUSE:
657
    case ALPHA_R_GPDISP:
658
      /* The LITUSE and GPDISP relocs do not use a symbol, or an
659
         addend, but they do use a special code.  Put this code in the
660
         addend field.  */
661
      rptr->addend = intern->r_size;
662
      break;
663
 
664
    case ALPHA_R_OP_STORE:
665
      /* The STORE reloc needs the size and offset fields.  We store
666
         them in the addend.  */
667
      BFD_ASSERT (intern->r_offset <= 256 && intern->r_size <= 256);
668
      rptr->addend = (intern->r_offset << 8) + intern->r_size;
669
      break;
670
 
671
    case ALPHA_R_OP_PUSH:
672
    case ALPHA_R_OP_PSUB:
673
    case ALPHA_R_OP_PRSHIFT:
674
      /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
675
         address.  I believe that the address supplied is really an
676
         addend.  */
677
      rptr->addend = intern->r_vaddr;
678
      break;
679
 
680
    case ALPHA_R_GPVALUE:
681
      /* Set the addend field to the new GP value.  */
682
      rptr->addend = intern->r_symndx + ecoff_data (abfd)->gp;
683
      break;
684
 
685
    case ALPHA_R_IGNORE:
686
      /* If the type is ALPHA_R_IGNORE, make sure this is a reference
687
         to the absolute section so that the reloc is ignored.  For
688
         some reason the address of this reloc type is not adjusted by
689
         the section vma.  We record the gp value for this object file
690
         here, for convenience when doing the GPDISP relocation.  */
691
      rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
692
      rptr->address = intern->r_vaddr;
693
      rptr->addend = ecoff_data (abfd)->gp;
694
      break;
695
 
696
    default:
697
      break;
698
    }
699
 
700
  rptr->howto = &alpha_howto_table[intern->r_type];
701
}
702
 
703
/* When writing out a reloc we need to pull some values back out of
704
   the addend field into the reloc.  This is roughly the reverse of
705
   alpha_adjust_reloc_in, except that there are several changes we do
706
   not need to undo.  */
707
 
708
static void
709
alpha_adjust_reloc_out (abfd, rel, intern)
710
     bfd *abfd;
711
     const arelent *rel;
712
     struct internal_reloc *intern;
713
{
714
  switch (intern->r_type)
715
    {
716
    case ALPHA_R_LITUSE:
717
    case ALPHA_R_GPDISP:
718
      intern->r_size = rel->addend;
719
      break;
720
 
721
    case ALPHA_R_OP_STORE:
722
      intern->r_size = rel->addend & 0xff;
723
      intern->r_offset = (rel->addend >> 8) & 0xff;
724
      break;
725
 
726
    case ALPHA_R_OP_PUSH:
727
    case ALPHA_R_OP_PSUB:
728
    case ALPHA_R_OP_PRSHIFT:
729
      intern->r_vaddr = rel->addend;
730
      break;
731
 
732
    case ALPHA_R_IGNORE:
733
      intern->r_vaddr = rel->address;
734
      break;
735
 
736
    default:
737
      break;
738
    }
739
}
740
 
741
/* The size of the stack for the relocation evaluator.  */
742
#define RELOC_STACKSIZE (10)
743
 
744
/* Alpha ECOFF relocs have a built in expression evaluator as well as
745
   other interdependencies.  Rather than use a bunch of special
746
   functions and global variables, we use a single routine to do all
747
   the relocation for a section.  I haven't yet worked out how the
748
   assembler is going to handle this.  */
749
 
750
static bfd_byte *
751
alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order,
752
                                            data, relocateable, symbols)
753
     bfd *abfd;
754
     struct bfd_link_info *link_info;
755
     struct bfd_link_order *link_order;
756
     bfd_byte *data;
757
     boolean relocateable;
758
     asymbol **symbols;
759
{
760
  bfd *input_bfd = link_order->u.indirect.section->owner;
761
  asection *input_section = link_order->u.indirect.section;
762
  long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
763
  arelent **reloc_vector = NULL;
764
  long reloc_count;
765
  bfd *output_bfd = relocateable ? abfd : (bfd *) NULL;
766
  bfd_vma gp;
767
  boolean gp_undefined;
768
  bfd_vma stack[RELOC_STACKSIZE];
769
  int tos = 0;
770
 
771
  if (reloc_size < 0)
772
    goto error_return;
773
  reloc_vector = (arelent **) bfd_malloc (reloc_size);
774
  if (reloc_vector == NULL && reloc_size != 0)
775
    goto error_return;
776
 
777
  if (! bfd_get_section_contents (input_bfd, input_section, data,
778
                                  (file_ptr) 0, input_section->_raw_size))
779
    goto error_return;
780
 
781
  /* The section size is not going to change.  */
782
  input_section->_cooked_size = input_section->_raw_size;
783
  input_section->reloc_done = true;
784
 
785
  reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
786
                                        reloc_vector, symbols);
787
  if (reloc_count < 0)
788
    goto error_return;
789
  if (reloc_count == 0)
790
    goto successful_return;
791
 
792
  /* Get the GP value for the output BFD.  */
793
  gp_undefined = false;
794
  gp = _bfd_get_gp_value (abfd);
795
  if (gp == 0)
796
    {
797
      if (relocateable != false)
798
        {
799
          asection *sec;
800
          bfd_vma lo;
801
 
802
          /* Make up a value.  */
803
          lo = (bfd_vma) -1;
804
          for (sec = abfd->sections; sec != NULL; sec = sec->next)
805
            {
806
              if (sec->vma < lo
807
                  && (strcmp (sec->name, ".sbss") == 0
808
                      || strcmp (sec->name, ".sdata") == 0
809
                      || strcmp (sec->name, ".lit4") == 0
810
                      || strcmp (sec->name, ".lit8") == 0
811
                      || strcmp (sec->name, ".lita") == 0))
812
                lo = sec->vma;
813
            }
814
          gp = lo + 0x8000;
815
          _bfd_set_gp_value (abfd, gp);
816
        }
817
      else
818
        {
819
          struct bfd_link_hash_entry *h;
820
 
821
          h = bfd_link_hash_lookup (link_info->hash, "_gp", false, false,
822
                                    true);
823
          if (h == (struct bfd_link_hash_entry *) NULL
824
              || h->type != bfd_link_hash_defined)
825
            gp_undefined = true;
826
          else
827
            {
828
              gp = (h->u.def.value
829
                    + h->u.def.section->output_section->vma
830
                    + h->u.def.section->output_offset);
831
              _bfd_set_gp_value (abfd, gp);
832
            }
833
        }
834
    }
835
 
836
  for (; *reloc_vector != (arelent *) NULL; reloc_vector++)
837
    {
838
      arelent *rel;
839
      bfd_reloc_status_type r;
840
      char *err;
841
 
842
      rel = *reloc_vector;
843
      r = bfd_reloc_ok;
844
      switch (rel->howto->type)
845
        {
846
        case ALPHA_R_IGNORE:
847
          rel->address += input_section->output_offset;
848
          break;
849
 
850
        case ALPHA_R_REFLONG:
851
        case ALPHA_R_REFQUAD:
852
        case ALPHA_R_BRADDR:
853
        case ALPHA_R_HINT:
854
        case ALPHA_R_SREL16:
855
        case ALPHA_R_SREL32:
856
        case ALPHA_R_SREL64:
857
          if (relocateable
858
              && ((*rel->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
859
            {
860
              rel->address += input_section->output_offset;
861
              break;
862
            }
863
          r = bfd_perform_relocation (input_bfd, rel, data, input_section,
864
                                      output_bfd, &err);
865
          break;
866
 
867
        case ALPHA_R_GPREL32:
868
          /* This relocation is used in a switch table.  It is a 32
869
             bit offset from the current GP value.  We must adjust it
870
             by the different between the original GP value and the
871
             current GP value.  The original GP value is stored in the
872
             addend.  We adjust the addend and let
873
             bfd_perform_relocation finish the job.  */
874
          rel->addend -= gp;
875
          r = bfd_perform_relocation (input_bfd, rel, data, input_section,
876
                                      output_bfd, &err);
877
          if (r == bfd_reloc_ok && gp_undefined)
878
            {
879
              r = bfd_reloc_dangerous;
880
              err = (char *) _("GP relative relocation used when GP not defined");
881
            }
882
          break;
883
 
884
        case ALPHA_R_LITERAL:
885
          /* This is a reference to a literal value, generally
886
             (always?) in the .lita section.  This is a 16 bit GP
887
             relative relocation.  Sometimes the subsequent reloc is a
888
             LITUSE reloc, which indicates how this reloc is used.
889
             This sometimes permits rewriting the two instructions
890
             referred to by the LITERAL and the LITUSE into different
891
             instructions which do not refer to .lita.  This can save
892
             a memory reference, and permits removing a value from
893
             .lita thus saving GP relative space.
894
 
895
             We do not these optimizations.  To do them we would need
896
             to arrange to link the .lita section first, so that by
897
             the time we got here we would know the final values to
898
             use.  This would not be particularly difficult, but it is
899
             not currently implemented.  */
900
 
901
          {
902
            unsigned long insn;
903
 
904
            /* I believe that the LITERAL reloc will only apply to a
905
               ldq or ldl instruction, so check my assumption.  */
906
            insn = bfd_get_32 (input_bfd, data + rel->address);
907
            BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
908
                        || ((insn >> 26) & 0x3f) == 0x28);
909
 
910
            rel->addend -= gp;
911
            r = bfd_perform_relocation (input_bfd, rel, data, input_section,
912
                                        output_bfd, &err);
913
            if (r == bfd_reloc_ok && gp_undefined)
914
              {
915
                r = bfd_reloc_dangerous;
916
                err =
917
                  (char *) _("GP relative relocation used when GP not defined");
918
              }
919
          }
920
          break;
921
 
922
        case ALPHA_R_LITUSE:
923
          /* See ALPHA_R_LITERAL above for the uses of this reloc.  It
924
             does not cause anything to happen, itself.  */
925
          rel->address += input_section->output_offset;
926
          break;
927
 
928
        case ALPHA_R_GPDISP:
929
          /* This marks the ldah of an ldah/lda pair which loads the
930
             gp register with the difference of the gp value and the
931
             current location.  The second of the pair is r_size bytes
932
             ahead; it used to be marked with an ALPHA_R_IGNORE reloc,
933
             but that no longer happens in OSF/1 3.2.  */
934
          {
935
            unsigned long insn1, insn2;
936
            bfd_vma addend;
937
 
938
            /* Get the two instructions.  */
939
            insn1 = bfd_get_32 (input_bfd, data + rel->address);
940
            insn2 = bfd_get_32 (input_bfd, data + rel->address + rel->addend);
941
 
942
            BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
943
            BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
944
 
945
            /* Get the existing addend.  We must account for the sign
946
               extension done by lda and ldah.  */
947
            addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
948
            if (insn1 & 0x8000)
949
              {
950
                addend -= 0x80000000;
951
                addend -= 0x80000000;
952
              }
953
            if (insn2 & 0x8000)
954
              addend -= 0x10000;
955
 
956
            /* The existing addend includes the different between the
957
               gp of the input BFD and the address in the input BFD.
958
               Subtract this out.  */
959
            addend -= (ecoff_data (input_bfd)->gp
960
                       - (input_section->vma + rel->address));
961
 
962
            /* Now add in the final gp value, and subtract out the
963
               final address.  */
964
            addend += (gp
965
                       - (input_section->output_section->vma
966
                          + input_section->output_offset
967
                          + rel->address));
968
 
969
            /* Change the instructions, accounting for the sign
970
               extension, and write them out.  */
971
            if (addend & 0x8000)
972
              addend += 0x10000;
973
            insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
974
            insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
975
 
976
            bfd_put_32 (input_bfd, (bfd_vma) insn1, data + rel->address);
977
            bfd_put_32 (input_bfd, (bfd_vma) insn2,
978
                        data + rel->address + rel->addend);
979
 
980
            rel->address += input_section->output_offset;
981
          }
982
          break;
983
 
984
        case ALPHA_R_OP_PUSH:
985
          /* Push a value on the reloc evaluation stack.  */
986
          {
987
            asymbol *symbol;
988
            bfd_vma relocation;
989
 
990
            if (relocateable)
991
              {
992
                rel->address += input_section->output_offset;
993
                break;
994
              }
995
 
996
            /* Figure out the relocation of this symbol.  */
997
            symbol = *rel->sym_ptr_ptr;
998
 
999
            if (bfd_is_und_section (symbol->section))
1000
              r = bfd_reloc_undefined;
1001
 
1002
            if (bfd_is_com_section (symbol->section))
1003
              relocation = 0;
1004
            else
1005
              relocation = symbol->value;
1006
            relocation += symbol->section->output_section->vma;
1007
            relocation += symbol->section->output_offset;
1008
            relocation += rel->addend;
1009
 
1010
            if (tos >= RELOC_STACKSIZE)
1011
              abort ();
1012
 
1013
            stack[tos++] = relocation;
1014
          }
1015
          break;
1016
 
1017
        case ALPHA_R_OP_STORE:
1018
          /* Store a value from the reloc stack into a bitfield.  */
1019
          {
1020
            bfd_vma val;
1021
            int offset, size;
1022
 
1023
            if (relocateable)
1024
              {
1025
                rel->address += input_section->output_offset;
1026
                break;
1027
              }
1028
 
1029
            if (tos == 0)
1030
              abort ();
1031
 
1032
            /* The offset and size for this reloc are encoded into the
1033
               addend field by alpha_adjust_reloc_in.  */
1034
            offset = (rel->addend >> 8) & 0xff;
1035
            size = rel->addend & 0xff;
1036
 
1037
            val = bfd_get_64 (abfd, data + rel->address);
1038
            val &=~ (((1 << size) - 1) << offset);
1039
            val |= (stack[--tos] & ((1 << size) - 1)) << offset;
1040
            bfd_put_64 (abfd, val, data + rel->address);
1041
          }
1042
          break;
1043
 
1044
        case ALPHA_R_OP_PSUB:
1045
          /* Subtract a value from the top of the stack.  */
1046
          {
1047
            asymbol *symbol;
1048
            bfd_vma relocation;
1049
 
1050
            if (relocateable)
1051
              {
1052
                rel->address += input_section->output_offset;
1053
                break;
1054
              }
1055
 
1056
            /* Figure out the relocation of this symbol.  */
1057
            symbol = *rel->sym_ptr_ptr;
1058
 
1059
            if (bfd_is_und_section (symbol->section))
1060
              r = bfd_reloc_undefined;
1061
 
1062
            if (bfd_is_com_section (symbol->section))
1063
              relocation = 0;
1064
            else
1065
              relocation = symbol->value;
1066
            relocation += symbol->section->output_section->vma;
1067
            relocation += symbol->section->output_offset;
1068
            relocation += rel->addend;
1069
 
1070
            if (tos == 0)
1071
              abort ();
1072
 
1073
            stack[tos - 1] -= relocation;
1074
          }
1075
          break;
1076
 
1077
        case ALPHA_R_OP_PRSHIFT:
1078
          /* Shift the value on the top of the stack.  */
1079
          {
1080
            asymbol *symbol;
1081
            bfd_vma relocation;
1082
 
1083
            if (relocateable)
1084
              {
1085
                rel->address += input_section->output_offset;
1086
                break;
1087
              }
1088
 
1089
            /* Figure out the relocation of this symbol.  */
1090
            symbol = *rel->sym_ptr_ptr;
1091
 
1092
            if (bfd_is_und_section (symbol->section))
1093
              r = bfd_reloc_undefined;
1094
 
1095
            if (bfd_is_com_section (symbol->section))
1096
              relocation = 0;
1097
            else
1098
              relocation = symbol->value;
1099
            relocation += symbol->section->output_section->vma;
1100
            relocation += symbol->section->output_offset;
1101
            relocation += rel->addend;
1102
 
1103
            if (tos == 0)
1104
              abort ();
1105
 
1106
            stack[tos - 1] >>= relocation;
1107
          }
1108
          break;
1109
 
1110
        case ALPHA_R_GPVALUE:
1111
          /* I really don't know if this does the right thing.  */
1112
          gp = rel->addend;
1113
          gp_undefined = false;
1114
          break;
1115
 
1116
        default:
1117
          abort ();
1118
        }
1119
 
1120
      if (relocateable)
1121
        {
1122
          asection *os = input_section->output_section;
1123
 
1124
          /* A partial link, so keep the relocs.  */
1125
          os->orelocation[os->reloc_count] = rel;
1126
          os->reloc_count++;
1127
        }
1128
 
1129
      if (r != bfd_reloc_ok)
1130
        {
1131
          switch (r)
1132
            {
1133
            case bfd_reloc_undefined:
1134
              if (! ((*link_info->callbacks->undefined_symbol)
1135
                     (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1136
                      input_bfd, input_section, rel->address, true)))
1137
                goto error_return;
1138
              break;
1139
            case bfd_reloc_dangerous:
1140
              if (! ((*link_info->callbacks->reloc_dangerous)
1141
                     (link_info, err, input_bfd, input_section,
1142
                      rel->address)))
1143
                goto error_return;
1144
              break;
1145
            case bfd_reloc_overflow:
1146
              if (! ((*link_info->callbacks->reloc_overflow)
1147
                     (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1148
                      rel->howto->name, rel->addend, input_bfd,
1149
                      input_section, rel->address)))
1150
                goto error_return;
1151
              break;
1152
            case bfd_reloc_outofrange:
1153
            default:
1154
              abort ();
1155
              break;
1156
            }
1157
        }
1158
    }
1159
 
1160
  if (tos != 0)
1161
    abort ();
1162
 
1163
 successful_return:
1164
  if (reloc_vector != NULL)
1165
    free (reloc_vector);
1166
  return data;
1167
 
1168
 error_return:
1169
  if (reloc_vector != NULL)
1170
    free (reloc_vector);
1171
  return NULL;
1172
}
1173
 
1174
/* Get the howto structure for a generic reloc type.  */
1175
 
1176
static reloc_howto_type *
1177
alpha_bfd_reloc_type_lookup (abfd, code)
1178
     bfd *abfd;
1179
     bfd_reloc_code_real_type code;
1180
{
1181
  int alpha_type;
1182
 
1183
  switch (code)
1184
    {
1185
    case BFD_RELOC_32:
1186
      alpha_type = ALPHA_R_REFLONG;
1187
      break;
1188
    case BFD_RELOC_64:
1189
    case BFD_RELOC_CTOR:
1190
      alpha_type = ALPHA_R_REFQUAD;
1191
      break;
1192
    case BFD_RELOC_GPREL32:
1193
      alpha_type = ALPHA_R_GPREL32;
1194
      break;
1195
    case BFD_RELOC_ALPHA_LITERAL:
1196
      alpha_type = ALPHA_R_LITERAL;
1197
      break;
1198
    case BFD_RELOC_ALPHA_LITUSE:
1199
      alpha_type = ALPHA_R_LITUSE;
1200
      break;
1201
    case BFD_RELOC_ALPHA_GPDISP_HI16:
1202
      alpha_type = ALPHA_R_GPDISP;
1203
      break;
1204
    case BFD_RELOC_ALPHA_GPDISP_LO16:
1205
      alpha_type = ALPHA_R_IGNORE;
1206
      break;
1207
    case BFD_RELOC_23_PCREL_S2:
1208
      alpha_type = ALPHA_R_BRADDR;
1209
      break;
1210
    case BFD_RELOC_ALPHA_HINT:
1211
      alpha_type = ALPHA_R_HINT;
1212
      break;
1213
    case BFD_RELOC_16_PCREL:
1214
      alpha_type = ALPHA_R_SREL16;
1215
      break;
1216
    case BFD_RELOC_32_PCREL:
1217
      alpha_type = ALPHA_R_SREL32;
1218
      break;
1219
    case BFD_RELOC_64_PCREL:
1220
      alpha_type = ALPHA_R_SREL64;
1221
      break;
1222
#if 0
1223
    case ???:
1224
      alpha_type = ALPHA_R_OP_PUSH;
1225
      break;
1226
    case ???:
1227
      alpha_type = ALPHA_R_OP_STORE;
1228
      break;
1229
    case ???:
1230
      alpha_type = ALPHA_R_OP_PSUB;
1231
      break;
1232
    case ???:
1233
      alpha_type = ALPHA_R_OP_PRSHIFT;
1234
      break;
1235
    case ???:
1236
      alpha_type = ALPHA_R_GPVALUE;
1237
      break;
1238
#endif
1239
    default:
1240
      return (reloc_howto_type *) NULL;
1241
    }
1242
 
1243
  return &alpha_howto_table[alpha_type];
1244
}
1245
 
1246
/* A helper routine for alpha_relocate_section which converts an
1247
   external reloc when generating relocateable output.  Returns the
1248
   relocation amount.  */
1249
 
1250
static bfd_vma
1251
alpha_convert_external_reloc (output_bfd, info, input_bfd, ext_rel, h)
1252
     bfd *output_bfd;
1253
     struct bfd_link_info *info;
1254
     bfd *input_bfd;
1255
     struct external_reloc *ext_rel;
1256
     struct ecoff_link_hash_entry *h;
1257
{
1258
  unsigned long r_symndx;
1259
  bfd_vma relocation;
1260
 
1261
  BFD_ASSERT (info->relocateable);
1262
 
1263
  if (h->root.type == bfd_link_hash_defined
1264
      || h->root.type == bfd_link_hash_defweak)
1265
    {
1266
      asection *hsec;
1267
      const char *name;
1268
 
1269
      /* This symbol is defined in the output.  Convert the reloc from
1270
         being against the symbol to being against the section.  */
1271
 
1272
      /* Clear the r_extern bit.  */
1273
      ext_rel->r_bits[1] &=~ RELOC_BITS1_EXTERN_LITTLE;
1274
 
1275
      /* Compute a new r_symndx value.  */
1276
      hsec = h->root.u.def.section;
1277
      name = bfd_get_section_name (output_bfd, hsec->output_section);
1278
 
1279
      r_symndx = -1;
1280
      switch (name[1])
1281
        {
1282
        case 'A':
1283
          if (strcmp (name, "*ABS*") == 0)
1284
            r_symndx = RELOC_SECTION_ABS;
1285
          break;
1286
        case 'b':
1287
          if (strcmp (name, ".bss") == 0)
1288
            r_symndx = RELOC_SECTION_BSS;
1289
          break;
1290
        case 'd':
1291
          if (strcmp (name, ".data") == 0)
1292
            r_symndx = RELOC_SECTION_DATA;
1293
          break;
1294
        case 'f':
1295
          if (strcmp (name, ".fini") == 0)
1296
            r_symndx = RELOC_SECTION_FINI;
1297
          break;
1298
        case 'i':
1299
          if (strcmp (name, ".init") == 0)
1300
            r_symndx = RELOC_SECTION_INIT;
1301
          break;
1302
        case 'l':
1303
          if (strcmp (name, ".lita") == 0)
1304
            r_symndx = RELOC_SECTION_LITA;
1305
          else if (strcmp (name, ".lit8") == 0)
1306
            r_symndx = RELOC_SECTION_LIT8;
1307
          else if (strcmp (name, ".lit4") == 0)
1308
            r_symndx = RELOC_SECTION_LIT4;
1309
          break;
1310
        case 'p':
1311
          if (strcmp (name, ".pdata") == 0)
1312
            r_symndx = RELOC_SECTION_PDATA;
1313
          break;
1314
        case 'r':
1315
          if (strcmp (name, ".rdata") == 0)
1316
            r_symndx = RELOC_SECTION_RDATA;
1317
          else if (strcmp (name, ".rconst") == 0)
1318
            r_symndx = RELOC_SECTION_RCONST;
1319
          break;
1320
        case 's':
1321
          if (strcmp (name, ".sdata") == 0)
1322
            r_symndx = RELOC_SECTION_SDATA;
1323
          else if (strcmp (name, ".sbss") == 0)
1324
            r_symndx = RELOC_SECTION_SBSS;
1325
          break;
1326
        case 't':
1327
          if (strcmp (name, ".text") == 0)
1328
            r_symndx = RELOC_SECTION_TEXT;
1329
          break;
1330
        case 'x':
1331
          if (strcmp (name, ".xdata") == 0)
1332
            r_symndx = RELOC_SECTION_XDATA;
1333
          break;
1334
        }
1335
 
1336
      if (r_symndx == -1)
1337
        abort ();
1338
 
1339
      /* Add the section VMA and the symbol value.  */
1340
      relocation = (h->root.u.def.value
1341
                    + hsec->output_section->vma
1342
                    + hsec->output_offset);
1343
    }
1344
  else
1345
    {
1346
      /* Change the symndx value to the right one for
1347
         the output BFD.  */
1348
      r_symndx = h->indx;
1349
      if (r_symndx == -1)
1350
        {
1351
          /* Caller must give an error.  */
1352
          r_symndx = 0;
1353
        }
1354
      relocation = 0;
1355
    }
1356
 
1357
  /* Write out the new r_symndx value.  */
1358
  bfd_h_put_32 (input_bfd, (bfd_vma) r_symndx,
1359
                (bfd_byte *) ext_rel->r_symndx);
1360
 
1361
  return relocation;
1362
}
1363
 
1364
/* Relocate a section while linking an Alpha ECOFF file.  This is
1365
   quite similar to get_relocated_section_contents.  Perhaps they
1366
   could be combined somehow.  */
1367
 
1368
static boolean
1369
alpha_relocate_section (output_bfd, info, input_bfd, input_section,
1370
                        contents, external_relocs)
1371
     bfd *output_bfd;
1372
     struct bfd_link_info *info;
1373
     bfd *input_bfd;
1374
     asection *input_section;
1375
     bfd_byte *contents;
1376
     PTR external_relocs;
1377
{
1378
  asection **symndx_to_section, *lita_sec;
1379
  struct ecoff_link_hash_entry **sym_hashes;
1380
  bfd_vma gp;
1381
  boolean gp_undefined;
1382
  bfd_vma stack[RELOC_STACKSIZE];
1383
  int tos = 0;
1384
  struct external_reloc *ext_rel;
1385
  struct external_reloc *ext_rel_end;
1386
 
1387
  /* We keep a table mapping the symndx found in an internal reloc to
1388
     the appropriate section.  This is faster than looking up the
1389
     section by name each time.  */
1390
  symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1391
  if (symndx_to_section == (asection **) NULL)
1392
    {
1393
      symndx_to_section = ((asection **)
1394
                           bfd_alloc (input_bfd,
1395
                                      (NUM_RELOC_SECTIONS
1396
                                       * sizeof (asection *))));
1397
      if (!symndx_to_section)
1398
        return false;
1399
 
1400
      symndx_to_section[RELOC_SECTION_NONE] = NULL;
1401
      symndx_to_section[RELOC_SECTION_TEXT] =
1402
        bfd_get_section_by_name (input_bfd, ".text");
1403
      symndx_to_section[RELOC_SECTION_RDATA] =
1404
        bfd_get_section_by_name (input_bfd, ".rdata");
1405
      symndx_to_section[RELOC_SECTION_DATA] =
1406
        bfd_get_section_by_name (input_bfd, ".data");
1407
      symndx_to_section[RELOC_SECTION_SDATA] =
1408
        bfd_get_section_by_name (input_bfd, ".sdata");
1409
      symndx_to_section[RELOC_SECTION_SBSS] =
1410
        bfd_get_section_by_name (input_bfd, ".sbss");
1411
      symndx_to_section[RELOC_SECTION_BSS] =
1412
        bfd_get_section_by_name (input_bfd, ".bss");
1413
      symndx_to_section[RELOC_SECTION_INIT] =
1414
        bfd_get_section_by_name (input_bfd, ".init");
1415
      symndx_to_section[RELOC_SECTION_LIT8] =
1416
        bfd_get_section_by_name (input_bfd, ".lit8");
1417
      symndx_to_section[RELOC_SECTION_LIT4] =
1418
        bfd_get_section_by_name (input_bfd, ".lit4");
1419
      symndx_to_section[RELOC_SECTION_XDATA] =
1420
        bfd_get_section_by_name (input_bfd, ".xdata");
1421
      symndx_to_section[RELOC_SECTION_PDATA] =
1422
        bfd_get_section_by_name (input_bfd, ".pdata");
1423
      symndx_to_section[RELOC_SECTION_FINI] =
1424
        bfd_get_section_by_name (input_bfd, ".fini");
1425
      symndx_to_section[RELOC_SECTION_LITA] =
1426
        bfd_get_section_by_name (input_bfd, ".lita");
1427
      symndx_to_section[RELOC_SECTION_ABS] = bfd_abs_section_ptr;
1428
      symndx_to_section[RELOC_SECTION_RCONST] =
1429
        bfd_get_section_by_name (input_bfd, ".rconst");
1430
 
1431
      ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1432
    }
1433
 
1434
  sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1435
 
1436
  /* On the Alpha, the .lita section must be addressable by the global
1437
     pointer.  To support large programs, we need to allow multiple
1438
     global pointers.  This works as long as each input .lita section
1439
     is <64KB big.  This implies that when producing relocatable
1440
     output, the .lita section is limited to 64KB. . */
1441
 
1442
  lita_sec = symndx_to_section[RELOC_SECTION_LITA];
1443
  gp = _bfd_get_gp_value (output_bfd);
1444
  if (! info->relocateable && lita_sec != NULL)
1445
    {
1446
      struct ecoff_section_tdata *lita_sec_data;
1447
 
1448
      /* Make sure we have a section data structure to which we can
1449
         hang on to the gp value we pick for the section.  */
1450
      lita_sec_data = ecoff_section_data (input_bfd, lita_sec);
1451
      if (lita_sec_data == NULL)
1452
        {
1453
          lita_sec_data = ((struct ecoff_section_tdata *)
1454
                           bfd_zalloc (input_bfd,
1455
                                       sizeof (struct ecoff_section_tdata)));
1456
          ecoff_section_data (input_bfd, lita_sec) = lita_sec_data;
1457
        }
1458
 
1459
      if (lita_sec_data->gp != 0)
1460
        {
1461
          /* If we already assigned a gp to this section, we better
1462
             stick with that value.  */
1463
          gp = lita_sec_data->gp;
1464
        }
1465
      else
1466
        {
1467
          bfd_vma lita_vma;
1468
          bfd_size_type lita_size;
1469
 
1470
          lita_vma = lita_sec->output_offset + lita_sec->output_section->vma;
1471
          lita_size = lita_sec->_cooked_size;
1472
          if (lita_size == 0)
1473
            lita_size = lita_sec->_raw_size;
1474
 
1475
          if (gp == 0
1476
              || lita_vma <  gp - 0x8000
1477
              || lita_vma + lita_size >= gp + 0x8000)
1478
            {
1479
              /* Either gp hasn't been set at all or the current gp
1480
                 cannot address this .lita section.  In both cases we
1481
                 reset the gp to point into the "middle" of the
1482
                 current input .lita section.  */
1483
              if (gp && !ecoff_data (output_bfd)->issued_multiple_gp_warning)
1484
                {
1485
                  (*info->callbacks->warning) (info,
1486
                                               _("using multiple gp values"),
1487
                                               (char *) NULL, output_bfd,
1488
                                               (asection *) NULL, (bfd_vma) 0);
1489
                  ecoff_data (output_bfd)->issued_multiple_gp_warning = true;
1490
                }
1491
              if (lita_vma < gp - 0x8000)
1492
                gp = lita_vma + lita_size - 0x8000;
1493
              else
1494
                gp = lita_vma + 0x8000;
1495
 
1496
            }
1497
 
1498
          lita_sec_data->gp = gp;
1499
        }
1500
 
1501
      _bfd_set_gp_value (output_bfd, gp);
1502
    }
1503
 
1504
  gp_undefined = (gp == 0);
1505
 
1506
  BFD_ASSERT (bfd_header_little_endian (output_bfd));
1507
  BFD_ASSERT (bfd_header_little_endian (input_bfd));
1508
 
1509
  ext_rel = (struct external_reloc *) external_relocs;
1510
  ext_rel_end = ext_rel + input_section->reloc_count;
1511
  for (; ext_rel < ext_rel_end; ext_rel++)
1512
    {
1513
      bfd_vma r_vaddr;
1514
      unsigned long r_symndx;
1515
      int r_type;
1516
      int r_extern;
1517
      int r_offset;
1518
      int r_size;
1519
      boolean relocatep;
1520
      boolean adjust_addrp;
1521
      boolean gp_usedp;
1522
      bfd_vma addend;
1523
 
1524
      r_vaddr = bfd_h_get_64 (input_bfd, (bfd_byte *) ext_rel->r_vaddr);
1525
      r_symndx = bfd_h_get_32 (input_bfd, (bfd_byte *) ext_rel->r_symndx);
1526
 
1527
      r_type = ((ext_rel->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
1528
                >> RELOC_BITS0_TYPE_SH_LITTLE);
1529
      r_extern = (ext_rel->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
1530
      r_offset = ((ext_rel->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
1531
                  >> RELOC_BITS1_OFFSET_SH_LITTLE);
1532
      /* Ignored the reserved bits.  */
1533
      r_size = ((ext_rel->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
1534
                >> RELOC_BITS3_SIZE_SH_LITTLE);
1535
 
1536
      relocatep = false;
1537
      adjust_addrp = true;
1538
      gp_usedp = false;
1539
      addend = 0;
1540
 
1541
      switch (r_type)
1542
        {
1543
        default:
1544
          abort ();
1545
 
1546
        case ALPHA_R_IGNORE:
1547
          /* This reloc appears after a GPDISP reloc.  On earlier
1548
             versions of OSF/1, It marked the position of the second
1549
             instruction to be altered by the GPDISP reloc, but it is
1550
             not otherwise used for anything.  For some reason, the
1551
             address of the relocation does not appear to include the
1552
             section VMA, unlike the other relocation types.  */
1553
          if (info->relocateable)
1554
            bfd_h_put_64 (input_bfd,
1555
                          input_section->output_offset + r_vaddr,
1556
                          (bfd_byte *) ext_rel->r_vaddr);
1557
          adjust_addrp = false;
1558
          break;
1559
 
1560
        case ALPHA_R_REFLONG:
1561
        case ALPHA_R_REFQUAD:
1562
        case ALPHA_R_HINT:
1563
          relocatep = true;
1564
          break;
1565
 
1566
        case ALPHA_R_BRADDR:
1567
        case ALPHA_R_SREL16:
1568
        case ALPHA_R_SREL32:
1569
        case ALPHA_R_SREL64:
1570
          if (r_extern)
1571
            addend += - (r_vaddr + 4);
1572
          relocatep = true;
1573
          break;
1574
 
1575
        case ALPHA_R_GPREL32:
1576
          /* This relocation is used in a switch table.  It is a 32
1577
             bit offset from the current GP value.  We must adjust it
1578
             by the different between the original GP value and the
1579
             current GP value.  */
1580
          relocatep = true;
1581
          addend = ecoff_data (input_bfd)->gp - gp;
1582
          gp_usedp = true;
1583
          break;
1584
 
1585
        case ALPHA_R_LITERAL:
1586
          /* This is a reference to a literal value, generally
1587
             (always?) in the .lita section.  This is a 16 bit GP
1588
             relative relocation.  Sometimes the subsequent reloc is a
1589
             LITUSE reloc, which indicates how this reloc is used.
1590
             This sometimes permits rewriting the two instructions
1591
             referred to by the LITERAL and the LITUSE into different
1592
             instructions which do not refer to .lita.  This can save
1593
             a memory reference, and permits removing a value from
1594
             .lita thus saving GP relative space.
1595
 
1596
             We do not these optimizations.  To do them we would need
1597
             to arrange to link the .lita section first, so that by
1598
             the time we got here we would know the final values to
1599
             use.  This would not be particularly difficult, but it is
1600
             not currently implemented.  */
1601
 
1602
          /* I believe that the LITERAL reloc will only apply to a ldq
1603
             or ldl instruction, so check my assumption.  */
1604
          {
1605
            unsigned long insn;
1606
 
1607
            insn = bfd_get_32 (input_bfd,
1608
                               contents + r_vaddr - input_section->vma);
1609
            BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
1610
                        || ((insn >> 26) & 0x3f) == 0x28);
1611
          }
1612
 
1613
          relocatep = true;
1614
          addend = ecoff_data (input_bfd)->gp - gp;
1615
          gp_usedp = true;
1616
          break;
1617
 
1618
        case ALPHA_R_LITUSE:
1619
          /* See ALPHA_R_LITERAL above for the uses of this reloc.  It
1620
             does not cause anything to happen, itself.  */
1621
          break;
1622
 
1623
        case ALPHA_R_GPDISP:
1624
          /* This marks the ldah of an ldah/lda pair which loads the
1625
             gp register with the difference of the gp value and the
1626
             current location.  The second of the pair is r_symndx
1627
             bytes ahead.  It used to be marked with an ALPHA_R_IGNORE
1628
             reloc, but OSF/1 3.2 no longer does that.  */
1629
          {
1630
            unsigned long insn1, insn2;
1631
 
1632
            /* Get the two instructions.  */
1633
            insn1 = bfd_get_32 (input_bfd,
1634
                                contents + r_vaddr - input_section->vma);
1635
            insn2 = bfd_get_32 (input_bfd,
1636
                                (contents
1637
                                 + r_vaddr
1638
                                 - input_section->vma
1639
                                 + r_symndx));
1640
 
1641
            BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
1642
            BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
1643
 
1644
            /* Get the existing addend.  We must account for the sign
1645
               extension done by lda and ldah.  */
1646
            addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
1647
            if (insn1 & 0x8000)
1648
              {
1649
                /* This is addend -= 0x100000000 without causing an
1650
                   integer overflow on a 32 bit host.  */
1651
                addend -= 0x80000000;
1652
                addend -= 0x80000000;
1653
              }
1654
            if (insn2 & 0x8000)
1655
              addend -= 0x10000;
1656
 
1657
            /* The existing addend includes the difference between the
1658
               gp of the input BFD and the address in the input BFD.
1659
               We want to change this to the difference between the
1660
               final GP and the final address.  */
1661
            addend += (gp
1662
                       - ecoff_data (input_bfd)->gp
1663
                       + input_section->vma
1664
                       - (input_section->output_section->vma
1665
                          + input_section->output_offset));
1666
 
1667
            /* Change the instructions, accounting for the sign
1668
               extension, and write them out.  */
1669
            if (addend & 0x8000)
1670
              addend += 0x10000;
1671
            insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
1672
            insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
1673
 
1674
            bfd_put_32 (input_bfd, (bfd_vma) insn1,
1675
                        contents + r_vaddr - input_section->vma);
1676
            bfd_put_32 (input_bfd, (bfd_vma) insn2,
1677
                        contents + r_vaddr - input_section->vma + r_symndx);
1678
 
1679
            gp_usedp = true;
1680
          }
1681
          break;
1682
 
1683
        case ALPHA_R_OP_PUSH:
1684
        case ALPHA_R_OP_PSUB:
1685
        case ALPHA_R_OP_PRSHIFT:
1686
          /* Manipulate values on the reloc evaluation stack.  The
1687
             r_vaddr field is not an address in input_section, it is
1688
             the current value (including any addend) of the object
1689
             being used.  */
1690
          if (! r_extern)
1691
            {
1692
              asection *s;
1693
 
1694
              s = symndx_to_section[r_symndx];
1695
              if (s == (asection *) NULL)
1696
                abort ();
1697
              addend = s->output_section->vma + s->output_offset - s->vma;
1698
            }
1699
          else
1700
            {
1701
              struct ecoff_link_hash_entry *h;
1702
 
1703
              h = sym_hashes[r_symndx];
1704
              if (h == (struct ecoff_link_hash_entry *) NULL)
1705
                abort ();
1706
 
1707
              if (! info->relocateable)
1708
                {
1709
                  if (h->root.type == bfd_link_hash_defined
1710
                      || h->root.type == bfd_link_hash_defweak)
1711
                    addend = (h->root.u.def.value
1712
                              + h->root.u.def.section->output_section->vma
1713
                              + h->root.u.def.section->output_offset);
1714
                  else
1715
                    {
1716
                      /* Note that we pass the address as 0, since we
1717
                         do not have a meaningful number for the
1718
                         location within the section that is being
1719
                         relocated.  */
1720
                      if (! ((*info->callbacks->undefined_symbol)
1721
                             (info, h->root.root.string, input_bfd,
1722
                              input_section, (bfd_vma) 0, true)))
1723
                        return false;
1724
                      addend = 0;
1725
                    }
1726
                }
1727
              else
1728
                {
1729
                  if (h->root.type != bfd_link_hash_defined
1730
                      && h->root.type != bfd_link_hash_defweak
1731
                      && h->indx == -1)
1732
                    {
1733
                      /* This symbol is not being written out.  Pass
1734
                         the address as 0, as with undefined_symbol,
1735
                         above.  */
1736
                      if (! ((*info->callbacks->unattached_reloc)
1737
                             (info, h->root.root.string, input_bfd,
1738
                              input_section, (bfd_vma) 0)))
1739
                        return false;
1740
                    }
1741
 
1742
                  addend = alpha_convert_external_reloc (output_bfd, info,
1743
                                                         input_bfd,
1744
                                                         ext_rel, h);
1745
                }
1746
            }
1747
 
1748
          addend += r_vaddr;
1749
 
1750
          if (info->relocateable)
1751
            {
1752
              /* Adjust r_vaddr by the addend.  */
1753
              bfd_h_put_64 (input_bfd, addend,
1754
                            (bfd_byte *) ext_rel->r_vaddr);
1755
            }
1756
          else
1757
            {
1758
              switch (r_type)
1759
                {
1760
                case ALPHA_R_OP_PUSH:
1761
                  if (tos >= RELOC_STACKSIZE)
1762
                    abort ();
1763
                  stack[tos++] = addend;
1764
                  break;
1765
 
1766
                case ALPHA_R_OP_PSUB:
1767
                  if (tos == 0)
1768
                    abort ();
1769
                  stack[tos - 1] -= addend;
1770
                  break;
1771
 
1772
                case ALPHA_R_OP_PRSHIFT:
1773
                  if (tos == 0)
1774
                    abort ();
1775
                  stack[tos - 1] >>= addend;
1776
                  break;
1777
                }
1778
            }
1779
 
1780
          adjust_addrp = false;
1781
          break;
1782
 
1783
        case ALPHA_R_OP_STORE:
1784
          /* Store a value from the reloc stack into a bitfield.  If
1785
             we are generating relocateable output, all we do is
1786
             adjust the address of the reloc.  */
1787
          if (! info->relocateable)
1788
            {
1789
              bfd_vma mask;
1790
              bfd_vma val;
1791
 
1792
              if (tos == 0)
1793
                abort ();
1794
 
1795
              /* Get the relocation mask.  The separate steps and the
1796
                 casts to bfd_vma are attempts to avoid a bug in the
1797
                 Alpha OSF 1.3 C compiler.  See reloc.c for more
1798
                 details.  */
1799
              mask = 1;
1800
              mask <<= (bfd_vma) r_size;
1801
              mask -= 1;
1802
 
1803
              /* FIXME: I don't know what kind of overflow checking,
1804
                 if any, should be done here.  */
1805
              val = bfd_get_64 (input_bfd,
1806
                                contents + r_vaddr - input_section->vma);
1807
              val &=~ mask << (bfd_vma) r_offset;
1808
              val |= (stack[--tos] & mask) << (bfd_vma) r_offset;
1809
              bfd_put_64 (input_bfd, val,
1810
                          contents + r_vaddr - input_section->vma);
1811
            }
1812
          break;
1813
 
1814
        case ALPHA_R_GPVALUE:
1815
          /* I really don't know if this does the right thing.  */
1816
          gp = ecoff_data (input_bfd)->gp + r_symndx;
1817
          gp_undefined = false;
1818
          break;
1819
        }
1820
 
1821
      if (relocatep)
1822
        {
1823
          reloc_howto_type *howto;
1824
          struct ecoff_link_hash_entry *h = NULL;
1825
          asection *s = NULL;
1826
          bfd_vma relocation;
1827
          bfd_reloc_status_type r;
1828
 
1829
          /* Perform a relocation.  */
1830
 
1831
          howto = &alpha_howto_table[r_type];
1832
 
1833
          if (r_extern)
1834
            {
1835
              h = sym_hashes[r_symndx];
1836
              /* If h is NULL, that means that there is a reloc
1837
                 against an external symbol which we thought was just
1838
                 a debugging symbol.  This should not happen.  */
1839
              if (h == (struct ecoff_link_hash_entry *) NULL)
1840
                abort ();
1841
            }
1842
          else
1843
            {
1844
              if (r_symndx >= NUM_RELOC_SECTIONS)
1845
                s = NULL;
1846
              else
1847
                s = symndx_to_section[r_symndx];
1848
 
1849
              if (s == (asection *) NULL)
1850
                abort ();
1851
            }
1852
 
1853
          if (info->relocateable)
1854
            {
1855
              /* We are generating relocateable output, and must
1856
                 convert the existing reloc.  */
1857
              if (r_extern)
1858
                {
1859
                  if (h->root.type != bfd_link_hash_defined
1860
                      && h->root.type != bfd_link_hash_defweak
1861
                      && h->indx == -1)
1862
                    {
1863
                      /* This symbol is not being written out.  */
1864
                      if (! ((*info->callbacks->unattached_reloc)
1865
                             (info, h->root.root.string, input_bfd,
1866
                              input_section, r_vaddr - input_section->vma)))
1867
                        return false;
1868
                    }
1869
 
1870
                  relocation = alpha_convert_external_reloc (output_bfd,
1871
                                                             info,
1872
                                                             input_bfd,
1873
                                                             ext_rel,
1874
                                                             h);
1875
                }
1876
              else
1877
                {
1878
                  /* This is a relocation against a section.  Adjust
1879
                     the value by the amount the section moved.  */
1880
                  relocation = (s->output_section->vma
1881
                                + s->output_offset
1882
                                - s->vma);
1883
                }
1884
 
1885
              /* If this is PC relative, the existing object file
1886
                 appears to already have the reloc worked out.  We
1887
                 must subtract out the old value and add in the new
1888
                 one.  */
1889
              if (howto->pc_relative)
1890
                relocation -= (input_section->output_section->vma
1891
                               + input_section->output_offset
1892
                               - input_section->vma);
1893
 
1894
              /* Put in any addend.  */
1895
              relocation += addend;
1896
 
1897
              /* Adjust the contents.  */
1898
              r = _bfd_relocate_contents (howto, input_bfd, relocation,
1899
                                          (contents
1900
                                           + r_vaddr
1901
                                           - input_section->vma));
1902
            }
1903
          else
1904
            {
1905
              /* We are producing a final executable.  */
1906
              if (r_extern)
1907
                {
1908
                  /* This is a reloc against a symbol.  */
1909
                  if (h->root.type == bfd_link_hash_defined
1910
                      || h->root.type == bfd_link_hash_defweak)
1911
                    {
1912
                      asection *hsec;
1913
 
1914
                      hsec = h->root.u.def.section;
1915
                      relocation = (h->root.u.def.value
1916
                                    + hsec->output_section->vma
1917
                                    + hsec->output_offset);
1918
                    }
1919
                  else
1920
                    {
1921
                      if (! ((*info->callbacks->undefined_symbol)
1922
                             (info, h->root.root.string, input_bfd,
1923
                              input_section,
1924
                              r_vaddr - input_section->vma, true)))
1925
                        return false;
1926
                      relocation = 0;
1927
                    }
1928
                }
1929
              else
1930
                {
1931
                  /* This is a reloc against a section.  */
1932
                  relocation = (s->output_section->vma
1933
                                + s->output_offset
1934
                                - s->vma);
1935
 
1936
                  /* Adjust a PC relative relocation by removing the
1937
                     reference to the original source section.  */
1938
                  if (howto->pc_relative)
1939
                    relocation += input_section->vma;
1940
                }
1941
 
1942
              r = _bfd_final_link_relocate (howto,
1943
                                            input_bfd,
1944
                                            input_section,
1945
                                            contents,
1946
                                            r_vaddr - input_section->vma,
1947
                                            relocation,
1948
                                            addend);
1949
            }
1950
 
1951
          if (r != bfd_reloc_ok)
1952
            {
1953
              switch (r)
1954
                {
1955
                default:
1956
                case bfd_reloc_outofrange:
1957
                  abort ();
1958
                case bfd_reloc_overflow:
1959
                  {
1960
                    const char *name;
1961
 
1962
                    if (r_extern)
1963
                      name = sym_hashes[r_symndx]->root.root.string;
1964
                    else
1965
                      name = bfd_section_name (input_bfd,
1966
                                               symndx_to_section[r_symndx]);
1967
                    if (! ((*info->callbacks->reloc_overflow)
1968
                           (info, name, alpha_howto_table[r_type].name,
1969
                            (bfd_vma) 0, input_bfd, input_section,
1970
                            r_vaddr - input_section->vma)))
1971
                      return false;
1972
                  }
1973
                  break;
1974
                }
1975
            }
1976
        }
1977
 
1978
      if (info->relocateable && adjust_addrp)
1979
        {
1980
          /* Change the address of the relocation.  */
1981
          bfd_h_put_64 (input_bfd,
1982
                        (input_section->output_section->vma
1983
                         + input_section->output_offset
1984
                         - input_section->vma
1985
                         + r_vaddr),
1986
                        (bfd_byte *) ext_rel->r_vaddr);
1987
        }
1988
 
1989
      if (gp_usedp && gp_undefined)
1990
        {
1991
          if (! ((*info->callbacks->reloc_dangerous)
1992
                 (info, _("GP relative relocation when GP not defined"),
1993
                  input_bfd, input_section, r_vaddr - input_section->vma)))
1994
            return false;
1995
          /* Only give the error once per link.  */
1996
          gp = 4;
1997
          _bfd_set_gp_value (output_bfd, gp);
1998
          gp_undefined = false;
1999
        }
2000
    }
2001
 
2002
  if (tos != 0)
2003
    abort ();
2004
 
2005
  return true;
2006
}
2007
 
2008
/* Do final adjustments to the filehdr and the aouthdr.  This routine
2009
   sets the dynamic bits in the file header.  */
2010
 
2011
/*ARGSUSED*/
2012
static boolean
2013
alpha_adjust_headers (abfd, fhdr, ahdr)
2014
     bfd *abfd;
2015
     struct internal_filehdr *fhdr;
2016
     struct internal_aouthdr *ahdr;
2017
{
2018
  if ((abfd->flags & (DYNAMIC | EXEC_P)) == (DYNAMIC | EXEC_P))
2019
    fhdr->f_flags |= F_ALPHA_CALL_SHARED;
2020
  else if ((abfd->flags & DYNAMIC) != 0)
2021
    fhdr->f_flags |= F_ALPHA_SHARABLE;
2022
  return true;
2023
}
2024
 
2025
/* Archive handling.  In OSF/1 (or Digital Unix) v3.2, Digital
2026
   introduced archive packing, in which the elements in an archive are
2027
   optionally compressed using a simple dictionary scheme.  We know
2028
   how to read such archives, but we don't write them.  */
2029
 
2030
#define alpha_ecoff_slurp_armap _bfd_ecoff_slurp_armap
2031
#define alpha_ecoff_slurp_extended_name_table \
2032
  _bfd_ecoff_slurp_extended_name_table
2033
#define alpha_ecoff_construct_extended_name_table \
2034
  _bfd_ecoff_construct_extended_name_table
2035
#define alpha_ecoff_truncate_arname _bfd_ecoff_truncate_arname
2036
#define alpha_ecoff_write_armap _bfd_ecoff_write_armap
2037
#define alpha_ecoff_generic_stat_arch_elt _bfd_ecoff_generic_stat_arch_elt
2038
#define alpha_ecoff_update_armap_timestamp _bfd_ecoff_update_armap_timestamp
2039
 
2040
/* A compressed file uses this instead of ARFMAG.  */
2041
 
2042
#define ARFZMAG "Z\012"
2043
 
2044
/* Read an archive header.  This is like the standard routine, but it
2045
   also accepts ARFZMAG.  */
2046
 
2047
static PTR
2048
alpha_ecoff_read_ar_hdr (abfd)
2049
     bfd *abfd;
2050
{
2051
  struct areltdata *ret;
2052
  struct ar_hdr *h;
2053
 
2054
  ret = (struct areltdata *) _bfd_generic_read_ar_hdr_mag (abfd, ARFZMAG);
2055
  if (ret == NULL)
2056
    return NULL;
2057
 
2058
  h = (struct ar_hdr *) ret->arch_header;
2059
  if (strncmp (h->ar_fmag, ARFZMAG, 2) == 0)
2060
    {
2061
      bfd_byte ab[8];
2062
 
2063
      /* This is a compressed file.  We must set the size correctly.
2064
         The size is the eight bytes after the dummy file header.  */
2065
      if (bfd_seek (abfd, FILHSZ, SEEK_CUR) != 0
2066
          || bfd_read (ab, 1, 8, abfd) != 8
2067
          || bfd_seek (abfd, - (FILHSZ + 8), SEEK_CUR) != 0)
2068
        return NULL;
2069
 
2070
      ret->parsed_size = bfd_h_get_64 (abfd, ab);
2071
    }
2072
 
2073
  return (PTR) ret;
2074
}
2075
 
2076
/* Get an archive element at a specified file position.  This is where
2077
   we uncompress the archive element if necessary.  */
2078
 
2079
static bfd *
2080
alpha_ecoff_get_elt_at_filepos (archive, filepos)
2081
     bfd *archive;
2082
     file_ptr filepos;
2083
{
2084
  bfd *nbfd = NULL;
2085
  struct areltdata *tdata;
2086
  struct ar_hdr *hdr;
2087
  bfd_byte ab[8];
2088
  bfd_size_type size;
2089
  bfd_byte *buf, *p;
2090
  struct bfd_in_memory *bim;
2091
 
2092
  nbfd = _bfd_get_elt_at_filepos (archive, filepos);
2093
  if (nbfd == NULL)
2094
    goto error_return;
2095
 
2096
  if ((nbfd->flags & BFD_IN_MEMORY) != 0)
2097
    {
2098
      /* We have already expanded this BFD.  */
2099
      return nbfd;
2100
    }
2101
 
2102
  tdata = (struct areltdata *) nbfd->arelt_data;
2103
  hdr = (struct ar_hdr *) tdata->arch_header;
2104
  if (strncmp (hdr->ar_fmag, ARFZMAG, 2) != 0)
2105
    return nbfd;
2106
 
2107
  /* We must uncompress this element.  We do this by copying it into a
2108
     memory buffer, and making bfd_read and bfd_seek use that buffer.
2109
     This can use a lot of memory, but it's simpler than getting a
2110
     temporary file, making that work with the file descriptor caching
2111
     code, and making sure that it is deleted at all appropriate
2112
     times.  It can be changed if it ever becomes important.  */
2113
 
2114
  /* The compressed file starts with a dummy ECOFF file header.  */
2115
  if (bfd_seek (nbfd, FILHSZ, SEEK_SET) != 0)
2116
    goto error_return;
2117
 
2118
  /* The next eight bytes are the real file size.  */
2119
  if (bfd_read (ab, 1, 8, nbfd) != 8)
2120
    goto error_return;
2121
  size = bfd_h_get_64 (nbfd, ab);
2122
 
2123
  if (size == 0)
2124
    buf = NULL;
2125
  else
2126
    {
2127
      bfd_size_type left;
2128
      bfd_byte dict[4096];
2129
      unsigned int h;
2130
      bfd_byte b;
2131
 
2132
      buf = (bfd_byte *) bfd_alloc (nbfd, size);
2133
      if (buf == NULL)
2134
        goto error_return;
2135
      p = buf;
2136
 
2137
      left = size;
2138
 
2139
      /* I don't know what the next eight bytes are for. */
2140
      if (bfd_read (ab, 1, 8, nbfd) != 8)
2141
        goto error_return;
2142
 
2143
      /* This is the uncompression algorithm.  It's a simple
2144
         dictionary based scheme in which each character is predicted
2145
         by a hash of the previous three characters.  A control byte
2146
         indicates whether the character is predicted or whether it
2147
         appears in the input stream; each control byte manages the
2148
         next eight bytes in the output stream.  */
2149
      memset (dict, 0, sizeof dict);
2150
      h = 0;
2151
      while (bfd_read (&b, 1, 1, nbfd) == 1)
2152
        {
2153
          unsigned int i;
2154
 
2155
          for (i = 0; i < 8; i++, b >>= 1)
2156
            {
2157
              bfd_byte n;
2158
 
2159
              if ((b & 1) == 0)
2160
                n = dict[h];
2161
              else
2162
                {
2163
                  if (! bfd_read (&n, 1, 1, nbfd))
2164
                    goto error_return;
2165
                  dict[h] = n;
2166
                }
2167
 
2168
              *p++ = n;
2169
 
2170
              --left;
2171
              if (left == 0)
2172
                break;
2173
 
2174
              h <<= 4;
2175
              h ^= n;
2176
              h &= sizeof dict - 1;
2177
            }
2178
 
2179
          if (left == 0)
2180
            break;
2181
        }
2182
    }
2183
 
2184
  /* Now the uncompressed file contents are in buf.  */
2185
  bim = ((struct bfd_in_memory *)
2186
         bfd_alloc (nbfd, sizeof (struct bfd_in_memory)));
2187
  if (bim == NULL)
2188
    goto error_return;
2189
  bim->size = size;
2190
  bim->buffer = buf;
2191
 
2192
  nbfd->mtime_set = true;
2193
  nbfd->mtime = strtol (hdr->ar_date, (char **) NULL, 10);
2194
 
2195
  nbfd->flags |= BFD_IN_MEMORY;
2196
  nbfd->iostream = (PTR) bim;
2197
  BFD_ASSERT (! nbfd->cacheable);
2198
 
2199
  return nbfd;
2200
 
2201
 error_return:
2202
  if (nbfd != NULL)
2203
    bfd_close (nbfd);
2204
  return NULL;
2205
}
2206
 
2207
/* Open the next archived file.  */
2208
 
2209
static bfd *
2210
alpha_ecoff_openr_next_archived_file (archive, last_file)
2211
     bfd *archive;
2212
     bfd *last_file;
2213
{
2214
  file_ptr filestart;
2215
 
2216
  if (last_file == NULL)
2217
    filestart = bfd_ardata (archive)->first_file_filepos;
2218
  else
2219
    {
2220
      struct areltdata *t;
2221
      struct ar_hdr *h;
2222
      bfd_size_type size;
2223
 
2224
      /* We can't use arelt_size here, because that uses parsed_size,
2225
         which is the uncompressed size.  We need the compressed size.  */
2226
      t = (struct areltdata *) last_file->arelt_data;
2227
      h = (struct ar_hdr *) t->arch_header;
2228
      size = strtol (h->ar_size, (char **) NULL, 10);
2229
 
2230
      /* Pad to an even boundary...
2231
         Note that last_file->origin can be odd in the case of
2232
         BSD-4.4-style element with a long odd size. */
2233
      filestart = last_file->origin + size;
2234
      filestart += filestart % 2;
2235
    }
2236
 
2237
  return alpha_ecoff_get_elt_at_filepos (archive, filestart);
2238
}
2239
 
2240
/* Open the archive file given an index into the armap.  */
2241
 
2242
static bfd *
2243
alpha_ecoff_get_elt_at_index (abfd, index)
2244
     bfd *abfd;
2245
     symindex index;
2246
{
2247
  carsym *entry;
2248
 
2249
  entry = bfd_ardata (abfd)->symdefs + index;
2250
  return alpha_ecoff_get_elt_at_filepos (abfd, entry->file_offset);
2251
}
2252
 
2253
/* This is the ECOFF backend structure.  The backend field of the
2254
   target vector points to this.  */
2255
 
2256
static const struct ecoff_backend_data alpha_ecoff_backend_data =
2257
{
2258
  /* COFF backend structure.  */
2259
  {
2260
    (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
2261
    (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
2262
    (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
2263
    (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
2264
    (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
2265
    (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
2266
    (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
2267
    alpha_ecoff_swap_filehdr_out, alpha_ecoff_swap_aouthdr_out,
2268
    alpha_ecoff_swap_scnhdr_out,
2269
    FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, true, false, 4,
2270
    alpha_ecoff_swap_filehdr_in, alpha_ecoff_swap_aouthdr_in,
2271
    alpha_ecoff_swap_scnhdr_in, NULL,
2272
    alpha_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
2273
    alpha_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
2274
    _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
2275
    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2276
    NULL, NULL, NULL
2277
  },
2278
  /* Supported architecture.  */
2279
  bfd_arch_alpha,
2280
  /* Initial portion of armap string.  */
2281
  "________64",
2282
  /* The page boundary used to align sections in a demand-paged
2283
     executable file.  E.g., 0x1000.  */
2284
  0x2000,
2285
  /* True if the .rdata section is part of the text segment, as on the
2286
     Alpha.  False if .rdata is part of the data segment, as on the
2287
     MIPS.  */
2288
  true,
2289
  /* Bitsize of constructor entries.  */
2290
  64,
2291
  /* Reloc to use for constructor entries.  */
2292
  &alpha_howto_table[ALPHA_R_REFQUAD],
2293
  {
2294
    /* Symbol table magic number.  */
2295
    magicSym2,
2296
    /* Alignment of debugging information.  E.g., 4.  */
2297
    8,
2298
    /* Sizes of external symbolic information.  */
2299
    sizeof (struct hdr_ext),
2300
    sizeof (struct dnr_ext),
2301
    sizeof (struct pdr_ext),
2302
    sizeof (struct sym_ext),
2303
    sizeof (struct opt_ext),
2304
    sizeof (struct fdr_ext),
2305
    sizeof (struct rfd_ext),
2306
    sizeof (struct ext_ext),
2307
    /* Functions to swap in external symbolic data.  */
2308
    ecoff_swap_hdr_in,
2309
    ecoff_swap_dnr_in,
2310
    ecoff_swap_pdr_in,
2311
    ecoff_swap_sym_in,
2312
    ecoff_swap_opt_in,
2313
    ecoff_swap_fdr_in,
2314
    ecoff_swap_rfd_in,
2315
    ecoff_swap_ext_in,
2316
    _bfd_ecoff_swap_tir_in,
2317
    _bfd_ecoff_swap_rndx_in,
2318
    /* Functions to swap out external symbolic data.  */
2319
    ecoff_swap_hdr_out,
2320
    ecoff_swap_dnr_out,
2321
    ecoff_swap_pdr_out,
2322
    ecoff_swap_sym_out,
2323
    ecoff_swap_opt_out,
2324
    ecoff_swap_fdr_out,
2325
    ecoff_swap_rfd_out,
2326
    ecoff_swap_ext_out,
2327
    _bfd_ecoff_swap_tir_out,
2328
    _bfd_ecoff_swap_rndx_out,
2329
    /* Function to read in symbolic data.  */
2330
    _bfd_ecoff_slurp_symbolic_info
2331
  },
2332
  /* External reloc size.  */
2333
  RELSZ,
2334
  /* Reloc swapping functions.  */
2335
  alpha_ecoff_swap_reloc_in,
2336
  alpha_ecoff_swap_reloc_out,
2337
  /* Backend reloc tweaking.  */
2338
  alpha_adjust_reloc_in,
2339
  alpha_adjust_reloc_out,
2340
  /* Relocate section contents while linking.  */
2341
  alpha_relocate_section,
2342
  /* Do final adjustments to filehdr and aouthdr.  */
2343
  alpha_adjust_headers,
2344
  /* Read an element from an archive at a given file position.  */
2345
  alpha_ecoff_get_elt_at_filepos
2346
};
2347
 
2348
/* Looking up a reloc type is Alpha specific.  */
2349
#define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup
2350
 
2351
/* So is getting relocated section contents.  */
2352
#define _bfd_ecoff_bfd_get_relocated_section_contents \
2353
  alpha_ecoff_get_relocated_section_contents
2354
 
2355
/* Handling file windows is generic.  */
2356
#define _bfd_ecoff_get_section_contents_in_window \
2357
  _bfd_generic_get_section_contents_in_window
2358
 
2359
/* Relaxing sections is generic.  */
2360
#define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
2361
#define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
2362
 
2363
const bfd_target ecoffalpha_little_vec =
2364
{
2365
  "ecoff-littlealpha",          /* name */
2366
  bfd_target_ecoff_flavour,
2367
  BFD_ENDIAN_LITTLE,            /* data byte order is little */
2368
  BFD_ENDIAN_LITTLE,            /* header byte order is little */
2369
 
2370
  (HAS_RELOC | EXEC_P |         /* object flags */
2371
   HAS_LINENO | HAS_DEBUG |
2372
   HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2373
 
2374
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2375
  0,                             /* leading underscore */
2376
  ' ',                          /* ar_pad_char */
2377
  15,                           /* ar_max_namelen */
2378
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2379
     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2380
     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2381
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2382
     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2383
     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2384
 
2385
  {_bfd_dummy_target, alpha_ecoff_object_p, /* bfd_check_format */
2386
     _bfd_ecoff_archive_p, _bfd_dummy_target},
2387
  {bfd_false, _bfd_ecoff_mkobject,  /* bfd_set_format */
2388
     _bfd_generic_mkarchive, bfd_false},
2389
  {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2390
     _bfd_write_archive_contents, bfd_false},
2391
 
2392
     BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2393
     BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2394
     BFD_JUMP_TABLE_CORE (_bfd_nocore),
2395
     BFD_JUMP_TABLE_ARCHIVE (alpha_ecoff),
2396
     BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2397
     BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2398
     BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2399
     BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2400
     BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2401
 
2402
  NULL,
2403
 
2404
  (PTR) &alpha_ecoff_backend_data
2405
};

powered by: WebSVN 2.1.0

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