Coverage Report

Created: 2024-05-21 06:29

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