Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/bfd/elf32-vax.c
Line
Count
Source (jump to first uncovered line)
1
/* VAX series support for 32-bit ELF
2
   Copyright (C) 1993-2024 Free Software Foundation, Inc.
3
   Contributed by Matt Thomas <matt@3am-software.com>.
4
5
   This file is part of BFD, the Binary File Descriptor library.
6
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
22
#include "sysdep.h"
23
#include "bfd.h"
24
#include "bfdlink.h"
25
#include "libbfd.h"
26
#include "elf-bfd.h"
27
#include "elf/vax.h"
28
29
static reloc_howto_type *reloc_type_lookup (bfd *, bfd_reloc_code_real_type);
30
static bool rtype_to_howto (bfd *, arelent *, Elf_Internal_Rela *);
31
static struct bfd_hash_entry *elf_vax_link_hash_newfunc (struct bfd_hash_entry *,
32
               struct bfd_hash_table *,
33
               const char *);
34
static struct bfd_link_hash_table *elf_vax_link_hash_table_create (bfd *);
35
static bool elf_vax_check_relocs (bfd *, struct bfd_link_info *,
36
          asection *, const Elf_Internal_Rela *);
37
static bool elf_vax_adjust_dynamic_symbol (struct bfd_link_info *,
38
             struct elf_link_hash_entry *);
39
static int elf_vax_relocate_section (bfd *, struct bfd_link_info *,
40
             bfd *, asection *, bfd_byte *,
41
             Elf_Internal_Rela *,
42
             Elf_Internal_Sym *, asection **);
43
static bool elf_vax_finish_dynamic_symbol (bfd *, struct bfd_link_info *,
44
             struct elf_link_hash_entry *,
45
             Elf_Internal_Sym *);
46
static bool elf_vax_finish_dynamic_sections (bfd *, struct bfd_link_info *);
47
static bfd_vma elf_vax_plt_sym_val (bfd_vma, const asection *,
48
            const arelent *);
49
50
static bool elf32_vax_set_private_flags (bfd *, flagword);
51
static bool elf32_vax_print_private_bfd_data (bfd *, void *);
52
53
static reloc_howto_type howto_table[] = {
54
  HOWTO (R_VAX_NONE,    /* type */
55
   0,     /* rightshift */
56
   0,     /* size */
57
   0,     /* bitsize */
58
   false,     /* pc_relative */
59
   0,     /* bitpos */
60
   complain_overflow_dont, /* complain_on_overflow */
61
   bfd_elf_generic_reloc, /* special_function */
62
   "R_VAX_NONE",    /* name */
63
   false,     /* partial_inplace */
64
   0,     /* src_mask */
65
   0x00000000,    /* dst_mask */
66
   false),    /* pcrel_offset */
67
68
  HOWTO (R_VAX_32,    /* type */
69
   0,     /* rightshift */
70
   4,     /* size */
71
   32,      /* bitsize */
72
   false,     /* pc_relative */
73
   0,     /* bitpos */
74
   complain_overflow_bitfield, /* complain_on_overflow */
75
   bfd_elf_generic_reloc, /* special_function */
76
   "R_VAX_32",    /* name */
77
   false,     /* partial_inplace */
78
   0,     /* src_mask */
79
   0xffffffff,    /* dst_mask */
80
   false),    /* pcrel_offset */
81
82
  HOWTO (R_VAX_16,    /* type */
83
   0,     /* rightshift */
84
   2,     /* size */
85
   16,      /* bitsize */
86
   false,     /* pc_relative */
87
   0,     /* bitpos */
88
   complain_overflow_bitfield, /* complain_on_overflow */
89
   bfd_elf_generic_reloc, /* special_function */
90
   "R_VAX_16",    /* name */
91
   false,     /* partial_inplace */
92
   0,     /* src_mask */
93
   0x0000ffff,    /* dst_mask */
94
   false),    /* pcrel_offset */
95
96
  HOWTO (R_VAX_8,   /* type */
97
   0,     /* rightshift */
98
   1,     /* size */
99
   8,     /* bitsize */
100
   false,     /* pc_relative */
101
   0,     /* bitpos */
102
   complain_overflow_bitfield, /* complain_on_overflow */
103
   bfd_elf_generic_reloc, /* special_function */
104
   "R_VAX_8",   /* name */
105
   false,     /* partial_inplace */
106
   0,     /* src_mask */
107
   0x000000ff,    /* dst_mask */
108
   false),    /* pcrel_offset */
109
110
  HOWTO (R_VAX_PC32,    /* type */
111
   0,     /* rightshift */
112
   4,     /* size */
113
   32,      /* bitsize */
114
   true,      /* pc_relative */
115
   0,     /* bitpos */
116
   complain_overflow_bitfield, /* complain_on_overflow */
117
   bfd_elf_generic_reloc, /* special_function */
118
   "R_VAX_PC32",    /* name */
119
   false,     /* partial_inplace */
120
   0,     /* src_mask */
121
   0xffffffff,    /* dst_mask */
122
   true),     /* pcrel_offset */
123
124
  HOWTO (R_VAX_PC16,    /* type */
125
   0,     /* rightshift */
126
   2,     /* size */
127
   16,      /* bitsize */
128
   true,      /* pc_relative */
129
   0,     /* bitpos */
130
   complain_overflow_signed, /* complain_on_overflow */
131
   bfd_elf_generic_reloc, /* special_function */
132
   "R_VAX_PC16",    /* name */
133
   false,     /* partial_inplace */
134
   0,     /* src_mask */
135
   0x0000ffff,    /* dst_mask */
136
   true),     /* pcrel_offset */
137
138
  HOWTO (R_VAX_PC8,   /* type */
139
   0,     /* rightshift */
140
   1,     /* size */
141
   8,     /* bitsize */
142
   true,      /* pc_relative */
143
   0,     /* bitpos */
144
   complain_overflow_signed, /* complain_on_overflow */
145
   bfd_elf_generic_reloc, /* special_function */
146
   "R_VAX_PC8",   /* name */
147
   false,     /* partial_inplace */
148
   0,     /* src_mask */
149
   0x000000ff,    /* dst_mask */
150
   true),     /* pcrel_offset */
151
152
  HOWTO (R_VAX_GOT32,   /* type */
153
   0,     /* rightshift */
154
   4,     /* size */
155
   32,      /* bitsize */
156
   true,      /* pc_relative */
157
   0,     /* bitpos */
158
   complain_overflow_bitfield, /* complain_on_overflow */
159
   bfd_elf_generic_reloc, /* special_function */
160
   "R_VAX_GOT32",   /* name */
161
   false,     /* partial_inplace */
162
   0,     /* src_mask */
163
   0xffffffff,    /* dst_mask */
164
   true),     /* pcrel_offset */
165
166
  EMPTY_HOWTO (-1),
167
  EMPTY_HOWTO (-1),
168
  EMPTY_HOWTO (-1),
169
  EMPTY_HOWTO (-1),
170
  EMPTY_HOWTO (-1),
171
172
  HOWTO (R_VAX_PLT32,   /* type */
173
   0,     /* rightshift */
174
   4,     /* size */
175
   32,      /* bitsize */
176
   true,      /* pc_relative */
177
   0,     /* bitpos */
178
   complain_overflow_bitfield, /* complain_on_overflow */
179
   bfd_elf_generic_reloc, /* special_function */
180
   "R_VAX_PLT32",   /* name */
181
   false,     /* partial_inplace */
182
   0,     /* src_mask */
183
   0xffffffff,    /* dst_mask */
184
   true),     /* pcrel_offset */
185
186
  EMPTY_HOWTO (-1),
187
  EMPTY_HOWTO (-1),
188
  EMPTY_HOWTO (-1),
189
  EMPTY_HOWTO (-1),
190
  EMPTY_HOWTO (-1),
191
192
  HOWTO (R_VAX_COPY,    /* type */
193
   0,     /* rightshift */
194
   0,     /* size */
195
   0,     /* bitsize */
196
   false,     /* pc_relative */
197
   0,     /* bitpos */
198
   complain_overflow_dont, /* complain_on_overflow */
199
   bfd_elf_generic_reloc, /* special_function */
200
   "R_VAX_COPY",    /* name */
201
   false,     /* partial_inplace */
202
   0,     /* src_mask */
203
   0xffffffff,    /* dst_mask */
204
   false),    /* pcrel_offset */
205
206
  HOWTO (R_VAX_GLOB_DAT,  /* type */
207
   0,     /* rightshift */
208
   4,     /* size */
209
   32,      /* bitsize */
210
   false,     /* pc_relative */
211
   0,     /* bitpos */
212
   complain_overflow_dont, /* complain_on_overflow */
213
   bfd_elf_generic_reloc, /* special_function */
214
   "R_VAX_GLOB_DAT",  /* name */
215
   false,     /* partial_inplace */
216
   0,     /* src_mask */
217
   0xffffffff,    /* dst_mask */
218
   false),    /* pcrel_offset */
219
220
  HOWTO (R_VAX_JMP_SLOT,  /* type */
221
   0,     /* rightshift */
222
   4,     /* size */
223
   32,      /* bitsize */
224
   false,     /* pc_relative */
225
   0,     /* bitpos */
226
   complain_overflow_dont, /* complain_on_overflow */
227
   bfd_elf_generic_reloc, /* special_function */
228
   "R_VAX_JMP_SLOT",  /* name */
229
   false,     /* partial_inplace */
230
   0,     /* src_mask */
231
   0xffffffff,    /* dst_mask */
232
   false),    /* pcrel_offset */
233
234
  HOWTO (R_VAX_RELATIVE,  /* type */
235
   0,     /* rightshift */
236
   4,     /* size */
237
   32,      /* bitsize */
238
   false,     /* pc_relative */
239
   0,     /* bitpos */
240
   complain_overflow_dont, /* complain_on_overflow */
241
   bfd_elf_generic_reloc, /* special_function */
242
   "R_VAX_RELATIVE",  /* name */
243
   false,     /* partial_inplace */
244
   0,     /* src_mask */
245
   0xffffffff,    /* dst_mask */
246
   false),    /* pcrel_offset */
247
248
  /* GNU extension to record C++ vtable hierarchy */
249
  HOWTO (R_VAX_GNU_VTINHERIT, /* type */
250
   0,     /* rightshift */
251
   4,     /* size */
252
   0,     /* bitsize */
253
   false,     /* pc_relative */
254
   0,     /* bitpos */
255
   complain_overflow_dont, /* complain_on_overflow */
256
   NULL,      /* special_function */
257
   "R_VAX_GNU_VTINHERIT", /* name */
258
   false,     /* partial_inplace */
259
   0,     /* src_mask */
260
   0,     /* dst_mask */
261
   false),    /* pcrel_offset */
262
263
  /* GNU extension to record C++ vtable member usage */
264
  HOWTO (R_VAX_GNU_VTENTRY, /* type */
265
   0,     /* rightshift */
266
   4,     /* size */
267
   0,     /* bitsize */
268
   false,     /* pc_relative */
269
   0,     /* bitpos */
270
   complain_overflow_dont, /* complain_on_overflow */
271
   _bfd_elf_rel_vtable_reloc_fn, /* special_function */
272
   "R_VAX_GNU_VTENTRY", /* name */
273
   false,     /* partial_inplace */
274
   0,     /* src_mask */
275
   0,     /* dst_mask */
276
   false),    /* pcrel_offset */
277
};
278
279
static bool
280
rtype_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)
281
0
{
282
0
  unsigned int r_type;
283
284
0
  r_type = ELF32_R_TYPE (dst->r_info);
285
0
  if (r_type >= R_VAX_max)
286
0
    {
287
      /* xgettext:c-format */
288
0
      _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
289
0
        abfd, r_type);
290
0
      bfd_set_error (bfd_error_bad_value);
291
0
      return false;
292
0
    }
293
0
  cache_ptr->howto = &howto_table[r_type];
294
0
  return true;
295
0
}
296
297
#define elf_info_to_howto rtype_to_howto
298
299
static const struct
300
{
301
  bfd_reloc_code_real_type bfd_val;
302
  int elf_val;
303
} reloc_map[] = {
304
  { BFD_RELOC_NONE, R_VAX_NONE },
305
  { BFD_RELOC_32, R_VAX_32 },
306
  { BFD_RELOC_16, R_VAX_16 },
307
  { BFD_RELOC_8, R_VAX_8 },
308
  { BFD_RELOC_32_PCREL, R_VAX_PC32 },
309
  { BFD_RELOC_16_PCREL, R_VAX_PC16 },
310
  { BFD_RELOC_8_PCREL, R_VAX_PC8 },
311
  { BFD_RELOC_32_GOT_PCREL, R_VAX_GOT32 },
312
  { BFD_RELOC_32_PLT_PCREL, R_VAX_PLT32 },
313
  { BFD_RELOC_NONE, R_VAX_COPY },
314
  { BFD_RELOC_VAX_GLOB_DAT, R_VAX_GLOB_DAT },
315
  { BFD_RELOC_VAX_JMP_SLOT, R_VAX_JMP_SLOT },
316
  { BFD_RELOC_VAX_RELATIVE, R_VAX_RELATIVE },
317
  { BFD_RELOC_CTOR, R_VAX_32 },
318
  { BFD_RELOC_VTABLE_INHERIT, R_VAX_GNU_VTINHERIT },
319
  { BFD_RELOC_VTABLE_ENTRY, R_VAX_GNU_VTENTRY },
320
};
321
322
static reloc_howto_type *
323
reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
324
0
{
325
0
  unsigned int i;
326
0
  for (i = 0; i < sizeof (reloc_map) / sizeof (reloc_map[0]); i++)
327
0
    {
328
0
      if (reloc_map[i].bfd_val == code)
329
0
  return &howto_table[reloc_map[i].elf_val];
330
0
    }
331
0
  return 0;
332
0
}
333
334
static reloc_howto_type *
335
reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
336
       const char *r_name)
337
0
{
338
0
  unsigned int i;
339
340
0
  for (i = 0; i < sizeof (howto_table) / sizeof (howto_table[0]); i++)
341
0
    if (howto_table[i].name != NULL
342
0
  && strcasecmp (howto_table[i].name, r_name) == 0)
343
0
      return &howto_table[i];
344
345
0
  return NULL;
346
0
}
347
348
#define bfd_elf32_bfd_reloc_type_lookup reloc_type_lookup
349
#define bfd_elf32_bfd_reloc_name_lookup reloc_name_lookup
350
#define ELF_ARCH bfd_arch_vax
351
/* end code generated by elf.el */
352

353
/* Functions for the VAX ELF linker.  */
354
355
/* The name of the dynamic interpreter.  This is put in the .interp
356
   section.  */
357
358
0
#define ELF_DYNAMIC_INTERPRETER "/usr/libexec/ld.elf_so"
359
360
/* The size in bytes of an entry in the procedure linkage table.  */
361
362
0
#define PLT_ENTRY_SIZE 12
363
364
/* The first entry in a procedure linkage table looks like this.  See
365
   the SVR4 ABI VAX supplement to see how this works.  */
366
367
static const bfd_byte elf_vax_plt0_entry[PLT_ENTRY_SIZE] =
368
{
369
  0xdd, 0xef,   /* pushl l^ */
370
  0, 0, 0, 0,   /* offset to .plt.got + 4 */
371
  0x17, 0xff,   /* jmp @L^(pc) */
372
  0, 0, 0, 0,   /* offset to .plt.got + 8 */
373
};
374
375
/* Subsequent entries in a procedure linkage table look like this.  */
376
377
static const bfd_byte elf_vax_plt_entry[PLT_ENTRY_SIZE] =
378
{
379
  0xfc, 0x0f,   /* .word ^M<r11:r2> */
380
  0x16, 0xef,   /* jsb L^(pc) */
381
  0, 0, 0, 0,   /* replaced with offset to start of .plt  */
382
  0, 0, 0, 0,   /* index into .rela.plt */
383
};
384
385
/* The VAX linker needs to keep track of the number of relocs that it
386
   decides to copy in check_relocs for each symbol.  This is so that it
387
   can discard PC relative relocs if it doesn't need them when linking
388
   with -Bsymbolic.  We store the information in a field extending the
389
   regular ELF linker hash table.  */
390
391
/* This structure keeps track of the number of PC relative relocs we have
392
   copied for a given symbol.  */
393
394
struct elf_vax_pcrel_relocs_copied
395
{
396
  /* Next section.  */
397
  struct elf_vax_pcrel_relocs_copied *next;
398
  /* A section in dynobj.  */
399
  asection *section;
400
  /* Number of relocs copied in this section.  */
401
  bfd_size_type count;
402
};
403
404
/* VAX ELF linker hash entry.  */
405
406
struct elf_vax_link_hash_entry
407
{
408
  struct elf_link_hash_entry root;
409
410
  /* Number of PC relative relocs copied for this symbol.  */
411
  struct elf_vax_pcrel_relocs_copied *pcrel_relocs_copied;
412
413
  bfd_vma got_addend;
414
};
415
416
/* Declare this now that the above structures are defined.  */
417
418
static bool elf_vax_discard_copies (struct elf_vax_link_hash_entry *,
419
            void *);
420
421
/* Declare this now that the above structures are defined.  */
422
423
static bool elf_vax_instantiate_got_entries (struct elf_link_hash_entry *,
424
               void *);
425
426
/* Traverse an VAX ELF linker hash table.  */
427
428
#define elf_vax_link_hash_traverse(table, func, info)     \
429
0
  (elf_link_hash_traverse           \
430
0
   ((table),                \
431
0
    (bool (*) (struct elf_link_hash_entry *, void *)) (func),   \
432
0
    (info)))
433
434
/* Create an entry in an VAX ELF linker hash table.  */
435
436
static struct bfd_hash_entry *
437
elf_vax_link_hash_newfunc (struct bfd_hash_entry *entry,
438
         struct bfd_hash_table *table,
439
         const char *string)
440
0
{
441
0
  struct elf_vax_link_hash_entry *ret =
442
0
    (struct elf_vax_link_hash_entry *) entry;
443
444
  /* Allocate the structure if it has not already been allocated by a
445
     subclass.  */
446
0
  if (ret == NULL)
447
0
    ret = ((struct elf_vax_link_hash_entry *)
448
0
     bfd_hash_allocate (table,
449
0
            sizeof (struct elf_vax_link_hash_entry)));
450
0
  if (ret == NULL)
451
0
    return (struct bfd_hash_entry *) ret;
452
453
  /* Call the allocation method of the superclass.  */
454
0
  ret = ((struct elf_vax_link_hash_entry *)
455
0
   _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
456
0
             table, string));
457
0
  if (ret != NULL)
458
0
    {
459
0
      ret->pcrel_relocs_copied = NULL;
460
0
    }
461
462
0
  return (struct bfd_hash_entry *) ret;
463
0
}
464
465
/* Create an VAX ELF linker hash table.  */
466
467
static struct bfd_link_hash_table *
468
elf_vax_link_hash_table_create (bfd *abfd)
469
0
{
470
0
  struct elf_link_hash_table *ret;
471
0
  size_t amt = sizeof (struct elf_link_hash_table);
472
473
0
  ret = bfd_zmalloc (amt);
474
0
  if (ret == NULL)
475
0
    return NULL;
476
477
0
  if (!_bfd_elf_link_hash_table_init (ret, abfd,
478
0
              elf_vax_link_hash_newfunc,
479
0
              sizeof (struct elf_vax_link_hash_entry),
480
0
              GENERIC_ELF_DATA))
481
0
    {
482
0
      free (ret);
483
0
      return NULL;
484
0
    }
485
486
0
  return &ret->root;
487
0
}
488
489
/* Keep vax-specific flags in the ELF header */
490
static bool
491
elf32_vax_set_private_flags (bfd *abfd, flagword flags)
492
0
{
493
0
  elf_elfheader (abfd)->e_flags = flags;
494
0
  elf_flags_init (abfd) = true;
495
0
  return true;
496
0
}
497
498
/* Merge backend specific data from an object file to the output
499
   object file when linking.  */
500
static bool
501
elf32_vax_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
502
0
{
503
0
  bfd *obfd = info->output_bfd;
504
0
  flagword in_flags;
505
506
0
  if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
507
0
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
508
0
    return true;
509
510
0
  in_flags  = elf_elfheader (ibfd)->e_flags;
511
512
0
  if (!elf_flags_init (obfd))
513
0
    {
514
0
      elf_flags_init (obfd) = true;
515
0
      elf_elfheader (obfd)->e_flags = in_flags;
516
0
    }
517
518
0
  return true;
519
0
}
520
521
/* Display the flags field */
522
static bool
523
elf32_vax_print_private_bfd_data (bfd *abfd, void * ptr)
524
0
{
525
0
  FILE *file = (FILE *) ptr;
526
527
0
  BFD_ASSERT (abfd != NULL && ptr != NULL);
528
529
  /* Print normal ELF private data.  */
530
0
  _bfd_elf_print_private_bfd_data (abfd, ptr);
531
532
  /* Ignore init flag - it may not be set, despite the flags field containing valid data.  */
533
534
  /* xgettext:c-format */
535
0
  fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
536
537
0
  if (elf_elfheader (abfd)->e_flags & EF_VAX_NONPIC)
538
0
    fprintf (file, _(" [nonpic]"));
539
540
0
  if (elf_elfheader (abfd)->e_flags & EF_VAX_DFLOAT)
541
0
    fprintf (file, _(" [d-float]"));
542
543
0
  if (elf_elfheader (abfd)->e_flags & EF_VAX_GFLOAT)
544
0
    fprintf (file, _(" [g-float]"));
545
546
0
  fputc ('\n', file);
547
548
0
  return true;
549
0
}
550
/* Look through the relocs for a section during the first phase, and
551
   allocate space in the global offset table or procedure linkage
552
   table.  */
553
554
static bool
555
elf_vax_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
556
          const Elf_Internal_Rela *relocs)
557
0
{
558
0
  bfd *dynobj;
559
0
  Elf_Internal_Shdr *symtab_hdr;
560
0
  struct elf_link_hash_entry **sym_hashes;
561
0
  const Elf_Internal_Rela *rel;
562
0
  const Elf_Internal_Rela *rel_end;
563
0
  asection *sreloc;
564
565
0
  if (bfd_link_relocatable (info))
566
0
    return true;
567
568
0
  dynobj = elf_hash_table (info)->dynobj;
569
0
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
570
0
  sym_hashes = elf_sym_hashes (abfd);
571
572
0
  sreloc = NULL;
573
574
0
  rel_end = relocs + sec->reloc_count;
575
0
  for (rel = relocs; rel < rel_end; rel++)
576
0
    {
577
0
      unsigned long r_symndx;
578
0
      struct elf_link_hash_entry *h;
579
580
0
      r_symndx = ELF32_R_SYM (rel->r_info);
581
582
0
      if (r_symndx < symtab_hdr->sh_info)
583
0
  h = NULL;
584
0
      else
585
0
  {
586
0
    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
587
0
    while (h->root.type == bfd_link_hash_indirect
588
0
     || h->root.type == bfd_link_hash_warning)
589
0
      h = (struct elf_link_hash_entry *) h->root.u.i.link;
590
0
  }
591
592
0
      switch (ELF32_R_TYPE (rel->r_info))
593
0
  {
594
0
  case R_VAX_GOT32:
595
0
    BFD_ASSERT (h != NULL);
596
597
    /* If this is a local symbol, we resolve it directly without
598
       creating a global offset table entry.  */
599
0
    if (SYMBOL_REFERENCES_LOCAL (info, h)
600
0
        || h == elf_hash_table (info)->hgot
601
0
        || h == elf_hash_table (info)->hplt)
602
0
      break;
603
604
    /* This symbol requires a global offset table entry.  */
605
606
0
    if (dynobj == NULL)
607
0
      {
608
        /* Create the .got section.  */
609
0
        elf_hash_table (info)->dynobj = dynobj = abfd;
610
0
        if (!_bfd_elf_create_got_section (dynobj, info))
611
0
    return false;
612
0
      }
613
614
0
    if (h != NULL)
615
0
      {
616
0
        struct elf_vax_link_hash_entry *eh;
617
618
0
        eh = (struct elf_vax_link_hash_entry *) h;
619
0
        if (h->got.refcount == -1)
620
0
    {
621
0
      h->got.refcount = 1;
622
0
      eh->got_addend = rel->r_addend;
623
0
    }
624
0
        else
625
0
    {
626
0
      h->got.refcount++;
627
0
      if (eh->got_addend != (bfd_vma) rel->r_addend)
628
0
        _bfd_error_handler
629
          /* xgettext:c-format */
630
0
          (_("%pB: warning: GOT addend of %" PRId64 " to `%s' does"
631
0
       " not match previous GOT addend of %" PRId64),
632
0
       abfd, (int64_t) rel->r_addend, h->root.root.string,
633
0
       (int64_t) eh->got_addend);
634
635
0
    }
636
0
      }
637
0
    break;
638
639
0
  case R_VAX_PLT32:
640
    /* This symbol requires a procedure linkage table entry.  We
641
       actually build the entry in adjust_dynamic_symbol,
642
       because this might be a case of linking PIC code which is
643
       never referenced by a dynamic object, in which case we
644
       don't need to generate a procedure linkage table entry
645
       after all.  */
646
0
    BFD_ASSERT (h != NULL);
647
648
    /* If this is a local symbol, we resolve it directly without
649
       creating a procedure linkage table entry.  */
650
0
    if (h->forced_local)
651
0
      break;
652
653
0
    h->needs_plt = 1;
654
0
    if (h->plt.refcount == -1)
655
0
      h->plt.refcount = 1;
656
0
    else
657
0
      h->plt.refcount++;
658
0
    break;
659
660
0
  case R_VAX_PC8:
661
0
  case R_VAX_PC16:
662
0
  case R_VAX_PC32:
663
    /* If we are creating a shared library and this is not a local
664
       symbol, we need to copy the reloc into the shared library.
665
       However when linking with -Bsymbolic and this is a global
666
       symbol which is defined in an object we are including in the
667
       link (i.e., DEF_REGULAR is set), then we can resolve the
668
       reloc directly.  At this point we have not seen all the input
669
       files, so it is possible that DEF_REGULAR is not set now but
670
       will be set later (it is never cleared).  We account for that
671
       possibility below by storing information in the
672
       pcrel_relocs_copied field of the hash table entry.  */
673
0
    if (!(bfd_link_pic (info)
674
0
    && (sec->flags & SEC_ALLOC) != 0
675
0
    && h != NULL
676
0
    && (!info->symbolic
677
0
        || !h->def_regular)))
678
0
      {
679
0
        if (h != NULL
680
0
      && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
681
0
      && !h->forced_local)
682
0
    {
683
      /* Make sure a plt entry is created for this symbol if
684
         it turns out to be a function defined by a dynamic
685
         object.  */
686
0
      if (h->plt.refcount == -1)
687
0
        h->plt.refcount = 1;
688
0
      else
689
0
        h->plt.refcount++;
690
0
    }
691
0
        break;
692
0
      }
693
    /* If this is a local symbol, we can resolve it directly.  */
694
0
    if (h != NULL
695
0
        && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
696
0
      || h->forced_local))
697
0
      break;
698
699
    /* Fall through.  */
700
0
  case R_VAX_8:
701
0
  case R_VAX_16:
702
0
  case R_VAX_32:
703
0
    if (h != NULL && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
704
0
      {
705
        /* Make sure a plt entry is created for this symbol if it
706
     turns out to be a function defined by a dynamic object.  */
707
0
        if (h->plt.refcount == -1)
708
0
    h->plt.refcount = 1;
709
0
        else
710
0
    h->plt.refcount++;
711
0
      }
712
713
    /* Non-GOT reference may need a copy reloc in executable or
714
       a dynamic reloc in shared library.  */
715
0
    if (h != NULL)
716
0
      h->non_got_ref = 1;
717
718
    /* If we are creating a shared library, we need to copy the
719
       reloc into the shared library.  */
720
0
    if (bfd_link_pic (info)
721
0
        && (sec->flags & SEC_ALLOC) != 0)
722
0
      {
723
        /* When creating a shared object, we must copy these
724
     reloc types into the output file.  We create a reloc
725
     section in dynobj and make room for this reloc.  */
726
0
        if (sreloc == NULL)
727
0
    {
728
0
      sreloc = _bfd_elf_make_dynamic_reloc_section
729
0
        (sec, dynobj, 2, abfd, /*rela?*/ true);
730
731
0
      if (sreloc == NULL)
732
0
        return false;
733
734
0
      if (sec->flags & SEC_READONLY)
735
0
        info->flags |= DF_TEXTREL;
736
0
    }
737
738
0
        sreloc->size += sizeof (Elf32_External_Rela);
739
740
        /* If we are linking with -Bsymbolic, we count the number of
741
     PC relative relocations we have entered for this symbol,
742
     so that we can discard them again if the symbol is later
743
     defined by a regular object.  Note that this function is
744
     only called if we are using a vaxelf linker hash table,
745
     which means that h is really a pointer to an
746
     elf_vax_link_hash_entry.  */
747
0
        if ((ELF32_R_TYPE (rel->r_info) == R_VAX_PC8
748
0
       || ELF32_R_TYPE (rel->r_info) == R_VAX_PC16
749
0
       || ELF32_R_TYPE (rel->r_info) == R_VAX_PC32)
750
0
      && info->symbolic)
751
0
    {
752
0
      struct elf_vax_link_hash_entry *eh;
753
0
      struct elf_vax_pcrel_relocs_copied *p;
754
755
0
      eh = (struct elf_vax_link_hash_entry *) h;
756
757
0
      for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
758
0
        if (p->section == sreloc)
759
0
          break;
760
761
0
      if (p == NULL)
762
0
        {
763
0
          p = ((struct elf_vax_pcrel_relocs_copied *)
764
0
         bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
765
0
          if (p == NULL)
766
0
      return false;
767
0
          p->next = eh->pcrel_relocs_copied;
768
0
          eh->pcrel_relocs_copied = p;
769
0
          p->section = sreloc;
770
0
          p->count = 0;
771
0
        }
772
773
0
      ++p->count;
774
0
    }
775
0
      }
776
777
0
    break;
778
779
    /* This relocation describes the C++ object vtable hierarchy.
780
       Reconstruct it for later use during GC.  */
781
0
  case R_VAX_GNU_VTINHERIT:
782
0
    if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
783
0
      return false;
784
0
    break;
785
786
    /* This relocation describes which C++ vtable entries are actually
787
       used.  Record for later use during GC.  */
788
0
  case R_VAX_GNU_VTENTRY:
789
0
    if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
790
0
      return false;
791
0
    break;
792
793
0
  default:
794
0
    break;
795
0
  }
796
0
    }
797
798
0
  return true;
799
0
}
800
801
/* Return the section that should be marked against GC for a given
802
   relocation.  */
803
804
static asection *
805
elf_vax_gc_mark_hook (asection *sec,
806
          struct bfd_link_info *info,
807
          Elf_Internal_Rela *rel,
808
          struct elf_link_hash_entry *h,
809
          Elf_Internal_Sym *sym)
810
0
{
811
0
  if (h != NULL)
812
0
    switch (ELF32_R_TYPE (rel->r_info))
813
0
      {
814
0
      case R_VAX_GNU_VTINHERIT:
815
0
      case R_VAX_GNU_VTENTRY:
816
0
  return NULL;
817
0
      }
818
819
0
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
820
0
}
821
822
/* Adjust a symbol defined by a dynamic object and referenced by a
823
   regular object.  The current definition is in some section of the
824
   dynamic object, but we're not including those sections.  We have to
825
   change the definition to something the rest of the link can
826
   understand.  */
827
828
static bool
829
elf_vax_adjust_dynamic_symbol (struct bfd_link_info *info,
830
             struct elf_link_hash_entry *h)
831
0
{
832
0
  bfd *dynobj;
833
0
  asection *s;
834
835
0
  dynobj = elf_hash_table (info)->dynobj;
836
837
  /* Make sure we know what is going on here.  */
838
0
  BFD_ASSERT (dynobj != NULL
839
0
        && (h->needs_plt
840
0
      || h->is_weakalias
841
0
      || (h->def_dynamic
842
0
          && h->ref_regular
843
0
          && !h->def_regular)));
844
845
  /* If this is a function, put it in the procedure linkage table.  We
846
     will fill in the contents of the procedure linkage table later,
847
     when we know the address of the .got section.  */
848
0
  if (h->type == STT_FUNC
849
0
      || h->needs_plt)
850
0
    {
851
0
      if (h->plt.refcount <= 0
852
0
    || SYMBOL_CALLS_LOCAL (info, h)
853
0
    || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
854
0
        && h->root.type == bfd_link_hash_undefweak))
855
0
  {
856
    /* This case can occur if we saw a PLTxx reloc in an input
857
       file, but the symbol was never referred to by a dynamic
858
       object, or if all references were garbage collected.  In
859
       such a case, we don't actually need to build a procedure
860
       linkage table, and we can just do a PCxx reloc instead.  */
861
0
    h->plt.offset = (bfd_vma) -1;
862
0
    h->needs_plt = 0;
863
0
    return true;
864
0
  }
865
866
0
      s = elf_hash_table (info)->splt;
867
0
      BFD_ASSERT (s != NULL);
868
869
      /* If this is the first .plt entry, make room for the special
870
   first entry.  */
871
0
      if (s->size == 0)
872
0
  {
873
0
    s->size += PLT_ENTRY_SIZE;
874
0
  }
875
876
      /* If this symbol is not defined in a regular file, and we are
877
   not generating a shared library, then set the symbol to this
878
   location in the .plt.  This is required to make function
879
   pointers compare as equal between the normal executable and
880
   the shared library.  */
881
0
      if (!bfd_link_pic (info)
882
0
    && !h->def_regular)
883
0
  {
884
0
    h->root.u.def.section = s;
885
0
    h->root.u.def.value = s->size;
886
0
  }
887
888
0
      h->plt.offset = s->size;
889
890
      /* Make room for this entry.  */
891
0
      s->size += PLT_ENTRY_SIZE;
892
893
      /* We also need to make an entry in the .got.plt section, which
894
   will be placed in the .got section by the linker script.  */
895
896
0
      s = elf_hash_table (info)->sgotplt;
897
0
      BFD_ASSERT (s != NULL);
898
0
      s->size += 4;
899
900
      /* We also need to make an entry in the .rela.plt section.  */
901
902
0
      s = elf_hash_table (info)->srelplt;
903
0
      BFD_ASSERT (s != NULL);
904
0
      s->size += sizeof (Elf32_External_Rela);
905
906
0
      return true;
907
0
    }
908
909
  /* Reinitialize the plt offset now that it is not used as a reference
910
     count any more.  */
911
0
  h->plt.offset = (bfd_vma) -1;
912
913
  /* If this is a weak symbol, and there is a real definition, the
914
     processor independent code will have arranged for us to see the
915
     real definition first, and we can just use the same value.  */
916
0
  if (h->is_weakalias)
917
0
    {
918
0
      struct elf_link_hash_entry *def = weakdef (h);
919
0
      BFD_ASSERT (def->root.type == bfd_link_hash_defined);
920
0
      h->root.u.def.section = def->root.u.def.section;
921
0
      h->root.u.def.value = def->root.u.def.value;
922
0
      return true;
923
0
    }
924
925
  /* This is a reference to a symbol defined by a dynamic object which
926
     is not a function.  */
927
928
  /* If we are creating a shared library, we must presume that the
929
     only references to the symbol are via the global offset table.
930
     For such cases we need not do anything here; the relocations will
931
     be handled correctly by relocate_section.  */
932
0
  if (bfd_link_pic (info))
933
0
    return true;
934
935
  /* If there are no references to this symbol that do not use the
936
     GOT relocation, we don't need to generate a copy reloc.  */
937
0
  if (!h->non_got_ref)
938
0
    return true;
939
940
  /* We must allocate the symbol in our .dynbss section, which will
941
     become part of the .bss section of the executable.  There will be
942
     an entry for this symbol in the .dynsym section.  The dynamic
943
     object will contain position independent code, so all references
944
     from the dynamic object to this symbol will go through the global
945
     offset table.  The dynamic linker will use the .dynsym entry to
946
     determine the address it must put in the global offset table, so
947
     both the dynamic object and the regular object will refer to the
948
     same memory location for the variable.  */
949
950
0
  s = bfd_get_linker_section (dynobj, ".dynbss");
951
0
  BFD_ASSERT (s != NULL);
952
953
  /* We must generate a R_VAX_COPY reloc to tell the dynamic linker to
954
     copy the initial value out of the dynamic object and into the
955
     runtime process image.  We need to remember the offset into the
956
     .rela.bss section we are going to use.  */
957
0
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
958
0
    {
959
0
      asection *srel;
960
961
0
      srel = bfd_get_linker_section (dynobj, ".rela.bss");
962
0
      BFD_ASSERT (srel != NULL);
963
0
      srel->size += sizeof (Elf32_External_Rela);
964
0
      h->needs_copy = 1;
965
0
    }
966
967
0
  return _bfd_elf_adjust_dynamic_copy (info, h, s);
968
0
}
969
970
/* This function is called via elf_link_hash_traverse.  It resets GOT
971
   and PLT (.GOT) reference counts back to -1 so normal PC32 relocation
972
   will be done.  */
973
974
static bool
975
elf_vax_discard_got_entries (struct elf_link_hash_entry *h,
976
           void *infoptr ATTRIBUTE_UNUSED)
977
0
{
978
0
  h->got.refcount = -1;
979
0
  h->plt.refcount = -1;
980
981
0
  return true;
982
0
}
983
984
/* Discard unused dynamic data if this is a static link.  */
985
986
static bool
987
elf_vax_early_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
988
           struct bfd_link_info *info)
989
0
{
990
0
  bfd *dynobj;
991
0
  asection *s;
992
993
0
  dynobj = elf_hash_table (info)->dynobj;
994
995
0
  if (dynobj && !elf_hash_table (info)->dynamic_sections_created)
996
0
    {
997
      /* We may have created entries in the .rela.got and .got sections.
998
   However, if we are not creating the dynamic sections, we will
999
   not actually use these entries.  Reset the size of .rela.got
1000
   and .got, which will cause them to get stripped from the output
1001
   file below.  */
1002
0
      s = elf_hash_table (info)->srelgot;
1003
0
      if (s != NULL)
1004
0
  s->size = 0;
1005
0
      s = elf_hash_table (info)->sgotplt;
1006
0
      if (s != NULL)
1007
0
  s->size = 0;
1008
0
      s = elf_hash_table (info)->sgot;
1009
0
      if (s != NULL)
1010
0
  s->size = 0;
1011
0
    }
1012
1013
  /* If this is a static link, we need to discard all the got entries we've
1014
     recorded.  */
1015
0
  if (!dynobj || !elf_hash_table (info)->dynamic_sections_created)
1016
0
    elf_link_hash_traverse (elf_hash_table (info),
1017
0
          elf_vax_discard_got_entries,
1018
0
          info);
1019
1020
0
  return true;
1021
0
}
1022
1023
/* Set the sizes of the dynamic sections.  */
1024
1025
static bool
1026
elf_vax_late_size_sections (bfd *output_bfd, struct bfd_link_info *info)
1027
0
{
1028
0
  bfd *dynobj;
1029
0
  asection *s;
1030
0
  bool relocs;
1031
1032
0
  dynobj = elf_hash_table (info)->dynobj;
1033
0
  if (dynobj == NULL)
1034
0
    return true;
1035
1036
0
  if (elf_hash_table (info)->dynamic_sections_created)
1037
0
    {
1038
      /* Set the contents of the .interp section to the interpreter.  */
1039
0
      if (bfd_link_executable (info) && !info->nointerp)
1040
0
  {
1041
0
    s = bfd_get_linker_section (dynobj, ".interp");
1042
0
    BFD_ASSERT (s != NULL);
1043
0
    s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1044
0
    s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1045
0
  }
1046
0
    }
1047
1048
  /* If this is a -Bsymbolic shared link, then we need to discard all PC
1049
     relative relocs against symbols defined in a regular object.  We
1050
     allocated space for them in the check_relocs routine, but we will not
1051
     fill them in in the relocate_section routine.  */
1052
0
  if (bfd_link_pic (info) && info->symbolic)
1053
0
    elf_vax_link_hash_traverse (elf_hash_table (info),
1054
0
        elf_vax_discard_copies,
1055
0
        NULL);
1056
1057
  /* If this is a -Bsymbolic shared link, we need to discard all the got
1058
     entries we've recorded.  Otherwise, we need to instantiate (allocate
1059
     space for them).  */
1060
0
  elf_link_hash_traverse (elf_hash_table (info),
1061
0
        elf_vax_instantiate_got_entries,
1062
0
        info);
1063
1064
  /* The check_relocs and adjust_dynamic_symbol entry points have
1065
     determined the sizes of the various dynamic sections.  Allocate
1066
     memory for them.  */
1067
0
  relocs = false;
1068
0
  for (s = dynobj->sections; s != NULL; s = s->next)
1069
0
    {
1070
0
      const char *name;
1071
1072
0
      if ((s->flags & SEC_LINKER_CREATED) == 0)
1073
0
  continue;
1074
1075
      /* It's OK to base decisions on the section name, because none
1076
   of the dynobj section names depend upon the input files.  */
1077
0
      name = bfd_section_name (s);
1078
1079
0
      if (strcmp (name, ".plt") == 0)
1080
0
  {
1081
    /* Remember whether there is a PLT.  */
1082
0
    ;
1083
0
  }
1084
0
      else if (startswith (name, ".rela"))
1085
0
  {
1086
0
    if (s->size != 0)
1087
0
      {
1088
0
        if (strcmp (name, ".rela.plt") != 0)
1089
0
    relocs = true;
1090
1091
        /* We use the reloc_count field as a counter if we need
1092
     to copy relocs into the output file.  */
1093
0
        s->reloc_count = 0;
1094
0
      }
1095
0
  }
1096
0
      else if (! startswith (name, ".got")
1097
0
         && strcmp (name, ".dynbss") != 0)
1098
0
  {
1099
    /* It's not one of our sections, so don't allocate space.  */
1100
0
    continue;
1101
0
  }
1102
1103
0
      if (s->size == 0)
1104
0
  {
1105
    /* If we don't need this section, strip it from the
1106
       output file.  This is mostly to handle .rela.bss and
1107
       .rela.plt.  We must create both sections in
1108
       create_dynamic_sections, because they must be created
1109
       before the linker maps input sections to output
1110
       sections.  The linker does that before
1111
       adjust_dynamic_symbol is called, and it is that
1112
       function which decides whether anything needs to go
1113
       into these sections.  */
1114
0
    s->flags |= SEC_EXCLUDE;
1115
0
    continue;
1116
0
  }
1117
1118
0
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
1119
0
  continue;
1120
1121
      /* Allocate memory for the section contents.  */
1122
0
      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1123
0
      if (s->contents == NULL)
1124
0
  return false;
1125
0
    }
1126
1127
0
  return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs);
1128
0
}
1129
1130
/* This function is called via elf_vax_link_hash_traverse if we are
1131
   creating a shared object with -Bsymbolic.  It discards the space
1132
   allocated to copy PC relative relocs against symbols which are defined
1133
   in regular objects.  We allocated space for them in the check_relocs
1134
   routine, but we won't fill them in in the relocate_section routine.  */
1135
1136
static bool
1137
elf_vax_discard_copies (struct elf_vax_link_hash_entry *h,
1138
      void * ignore ATTRIBUTE_UNUSED)
1139
0
{
1140
0
  struct elf_vax_pcrel_relocs_copied *s;
1141
1142
  /* We only discard relocs for symbols defined in a regular object.  */
1143
0
  if (!h->root.def_regular)
1144
0
    return true;
1145
1146
0
  for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1147
0
    s->section->size -= s->count * sizeof (Elf32_External_Rela);
1148
1149
0
  return true;
1150
0
}
1151
1152
/* This function is called via elf_link_hash_traverse.  It looks for
1153
   entries that have GOT or PLT (.GOT) references.  If creating a shared
1154
   object with -Bsymbolic, or the symbol has been forced local, then it
1155
   resets the reference count back to -1 so normal PC32 relocation will
1156
   be done.  Otherwise space in the .got and .rela.got will be reserved
1157
   for the symbol.  */
1158
1159
static bool
1160
elf_vax_instantiate_got_entries (struct elf_link_hash_entry *h, void * infoptr)
1161
0
{
1162
0
  struct bfd_link_info *info = (struct bfd_link_info *) infoptr;
1163
0
  bfd *dynobj;
1164
0
  asection *sgot;
1165
0
  asection *srelgot;
1166
1167
  /* We don't care about non-GOT (and non-PLT) entries.  */
1168
0
  if (h->got.refcount <= 0 && h->plt.refcount <= 0)
1169
0
    return true;
1170
1171
0
  dynobj = elf_hash_table (info)->dynobj;
1172
0
  BFD_ASSERT (dynobj != NULL);
1173
1174
0
  sgot = elf_hash_table (info)->sgot;
1175
0
  srelgot = elf_hash_table (info)->srelgot;
1176
1177
0
  if (SYMBOL_REFERENCES_LOCAL (info, h))
1178
0
    {
1179
0
      h->got.refcount = -1;
1180
0
      h->plt.refcount = -1;
1181
0
    }
1182
0
  else if (h->got.refcount > 0)
1183
0
    {
1184
      /* Make sure this symbol is output as a dynamic symbol.  */
1185
0
      if (h->dynindx == -1)
1186
0
  {
1187
0
    if (!bfd_elf_link_record_dynamic_symbol (info, h))
1188
0
      return false;
1189
0
  }
1190
1191
      /* Allocate space in the .got and .rela.got sections.  */
1192
0
      sgot->size += 4;
1193
0
      srelgot->size += sizeof (Elf32_External_Rela);
1194
0
    }
1195
1196
0
  return true;
1197
0
}
1198
1199
/* Relocate an VAX ELF section.  */
1200
1201
static int
1202
elf_vax_relocate_section (bfd *output_bfd,
1203
        struct bfd_link_info *info,
1204
        bfd *input_bfd,
1205
        asection *input_section,
1206
        bfd_byte *contents,
1207
        Elf_Internal_Rela *relocs,
1208
        Elf_Internal_Sym *local_syms,
1209
        asection **local_sections)
1210
0
{
1211
0
  Elf_Internal_Shdr *symtab_hdr;
1212
0
  struct elf_link_hash_entry **sym_hashes;
1213
0
  bfd_vma plt_index;
1214
0
  bfd_vma got_offset;
1215
0
  asection *sgot;
1216
0
  asection *splt;
1217
0
  asection *sgotplt;
1218
0
  asection *sreloc;
1219
0
  Elf_Internal_Rela *rel;
1220
0
  Elf_Internal_Rela *relend;
1221
1222
0
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1223
0
  sym_hashes = elf_sym_hashes (input_bfd);
1224
1225
0
  sgot = NULL;
1226
0
  splt = NULL;
1227
0
  sgotplt = NULL;
1228
0
  sreloc = NULL;
1229
1230
0
  rel = relocs;
1231
0
  relend = relocs + input_section->reloc_count;
1232
0
  for (; rel < relend; rel++)
1233
0
    {
1234
0
      int r_type;
1235
0
      reloc_howto_type *howto;
1236
0
      unsigned long r_symndx;
1237
0
      struct elf_link_hash_entry *h;
1238
0
      Elf_Internal_Sym *sym;
1239
0
      asection *sec;
1240
0
      bfd_vma relocation;
1241
0
      bfd_reloc_status_type r;
1242
1243
0
      r_type = ELF32_R_TYPE (rel->r_info);
1244
0
      if (r_type < 0 || r_type >= (int) R_VAX_max)
1245
0
  {
1246
0
    bfd_set_error (bfd_error_bad_value);
1247
0
    return false;
1248
0
  }
1249
0
      howto = howto_table + r_type;
1250
1251
0
      r_symndx = ELF32_R_SYM (rel->r_info);
1252
0
      h = NULL;
1253
0
      sym = NULL;
1254
0
      sec = NULL;
1255
0
      if (r_symndx < symtab_hdr->sh_info)
1256
0
  {
1257
0
    sym = local_syms + r_symndx;
1258
0
    sec = local_sections[r_symndx];
1259
0
    relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1260
0
  }
1261
0
      else
1262
0
  {
1263
0
    bool unresolved_reloc;
1264
0
    bool warned, ignored;
1265
1266
0
    RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1267
0
           r_symndx, symtab_hdr, sym_hashes,
1268
0
           h, sec, relocation,
1269
0
           unresolved_reloc, warned, ignored);
1270
1271
0
    if ((h->root.type == bfd_link_hash_defined
1272
0
        || h->root.type == bfd_link_hash_defweak)
1273
0
        && ((r_type == R_VAX_PLT32
1274
0
       && h->plt.offset != (bfd_vma) -1
1275
0
       && !h->forced_local
1276
0
       && elf_hash_table (info)->dynamic_sections_created)
1277
0
      || (r_type == R_VAX_GOT32
1278
0
          && h->got.offset != (bfd_vma) -1
1279
0
          && !h->forced_local
1280
0
          && elf_hash_table (info)->dynamic_sections_created
1281
0
          && (! bfd_link_pic (info)
1282
0
        || (! info->symbolic && h->dynindx != -1)
1283
0
        || !h->def_regular))
1284
0
      || (bfd_link_pic (info)
1285
0
          && ((! info->symbolic && h->dynindx != -1)
1286
0
        || !h->def_regular)
1287
0
          && ((input_section->flags & SEC_ALLOC) != 0
1288
        /* DWARF will emit R_VAX_32 relocations in its
1289
           sections against symbols defined externally
1290
           in shared libraries.  We can't do anything
1291
           with them here.  */
1292
1293
0
        || ((input_section->flags & SEC_DEBUGGING) != 0
1294
0
            && h->def_dynamic))
1295
0
          && (r_type == R_VAX_8
1296
0
        || r_type == R_VAX_16
1297
0
        || r_type == R_VAX_32))))
1298
      /* In these cases, we don't need the relocation
1299
         value.  We check specially because in some
1300
         obscure cases sec->output_section will be NULL.  */
1301
0
      relocation = 0;
1302
0
  }
1303
1304
0
      if (sec != NULL && discarded_section (sec))
1305
0
  RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1306
0
           rel, 1, relend, howto, 0, contents);
1307
1308
0
      if (bfd_link_relocatable (info))
1309
0
  continue;
1310
1311
0
      switch (r_type)
1312
0
  {
1313
0
  case R_VAX_GOT32:
1314
    /* Relocation is to the address of the entry for this symbol
1315
       in the global offset table.  */
1316
1317
    /* Resolve a GOTxx reloc against a local symbol directly,
1318
       without using the global offset table.  */
1319
0
    if (h == NULL
1320
0
        || h->got.offset == (bfd_vma) -1)
1321
0
      break;
1322
1323
0
    {
1324
0
      bfd_vma off;
1325
1326
0
      sgot = elf_hash_table (info)->sgot;
1327
0
      BFD_ASSERT (sgot != NULL);
1328
1329
0
      off = h->got.offset;
1330
0
      BFD_ASSERT (off < sgot->size);
1331
1332
0
      bfd_put_32 (output_bfd, rel->r_addend, sgot->contents + off);
1333
1334
0
      relocation = sgot->output_offset + off;
1335
      /* The GOT relocation uses the addend.  */
1336
0
      rel->r_addend = 0;
1337
1338
      /* Change the reference to be indirect.  */
1339
0
      contents[rel->r_offset - 1] |= 0x10;
1340
0
      relocation += sgot->output_section->vma;
1341
0
    }
1342
0
    break;
1343
1344
0
  case R_VAX_PC32:
1345
    /* If we are creating an executable and the function this
1346
       reloc refers to is in a shared lib, then we made a PLT
1347
       entry for this symbol and need to handle the reloc like
1348
       a PLT reloc.  */
1349
0
    if (bfd_link_pic (info))
1350
0
       goto r_vax_pc32_shared;
1351
    /* Fall through.  */
1352
0
  case R_VAX_PLT32:
1353
    /* Relocation is to the entry for this symbol in the
1354
       procedure linkage table.  */
1355
1356
    /* Resolve a PLTxx reloc against a local symbol directly,
1357
       without using the procedure linkage table.  */
1358
0
    if (h == NULL
1359
0
        || h->plt.offset == (bfd_vma) -1)
1360
0
      break;
1361
1362
0
    splt = elf_hash_table (info)->splt;
1363
0
    BFD_ASSERT (splt != NULL);
1364
1365
0
    sgotplt = elf_hash_table (info)->sgotplt;
1366
0
    BFD_ASSERT (sgotplt != NULL);
1367
1368
0
    plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1369
1370
    /* Get the offset into the .got table of the entry that
1371
       corresponds to this function.  Each .got entry is 4 bytes.
1372
       The first two are reserved.  */
1373
0
    got_offset = (plt_index + 3) * 4;
1374
1375
    /* We want the relocation to point into the .got.plt instead
1376
       of the plt itself.  */
1377
0
    relocation = (sgotplt->output_section->vma
1378
0
      + sgotplt->output_offset
1379
0
      + got_offset);
1380
0
    contents[rel->r_offset-1] |= 0x10; /* make indirect */
1381
0
    if (rel->r_addend == 2)
1382
0
      {
1383
0
        h->plt.offset |= 1;
1384
0
      }
1385
0
    else if (rel->r_addend != 0)
1386
0
      _bfd_error_handler
1387
        /* xgettext:c-format */
1388
0
        (_("%pB: warning: PLT addend of %" PRId64 " to `%s'"
1389
0
     " from %pA section ignored"),
1390
0
         input_bfd, (int64_t) rel->r_addend, h->root.root.string,
1391
0
         input_section);
1392
0
    rel->r_addend = 0;
1393
1394
0
    break;
1395
1396
0
  case R_VAX_PC8:
1397
0
  case R_VAX_PC16:
1398
0
  r_vax_pc32_shared:
1399
0
    if (h == NULL
1400
0
        || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1401
0
        || h->forced_local)
1402
0
      break;
1403
    /* Fall through.  */
1404
0
  case R_VAX_8:
1405
0
  case R_VAX_16:
1406
0
  case R_VAX_32:
1407
0
    if (bfd_link_pic (info)
1408
0
        && r_symndx != STN_UNDEF
1409
0
        && (input_section->flags & SEC_ALLOC) != 0
1410
0
        && ((r_type != R_VAX_PC8
1411
0
       && r_type != R_VAX_PC16
1412
0
       && r_type != R_VAX_PC32)
1413
0
      || ((input_section->flags & SEC_CODE)
1414
0
          && (!info->symbolic
1415
0
        || (!h->def_regular && h->type != STT_SECTION)))))
1416
0
      {
1417
0
        Elf_Internal_Rela outrel;
1418
0
        bfd_byte *loc;
1419
0
        bool skip, relocate;
1420
1421
        /* When generating a shared object, these relocations
1422
     are copied into the output file to be resolved at run
1423
     time.  */
1424
0
        if (sreloc == NULL)
1425
0
    {
1426
0
      sreloc = _bfd_elf_get_dynamic_reloc_section
1427
0
        (input_bfd, input_section, /*rela?*/ true);
1428
0
      if (sreloc == NULL)
1429
0
        return false;
1430
0
    }
1431
1432
0
        skip = false;
1433
0
        relocate = false;
1434
1435
0
        outrel.r_offset =
1436
0
    _bfd_elf_section_offset (output_bfd, info, input_section,
1437
0
           rel->r_offset);
1438
0
        if (outrel.r_offset == (bfd_vma) -1)
1439
0
    skip = true;
1440
0
        if (outrel.r_offset == (bfd_vma) -2)
1441
0
    skip = true, relocate = true;
1442
0
        outrel.r_offset += (input_section->output_section->vma
1443
0
          + input_section->output_offset);
1444
1445
0
        if (skip)
1446
0
      memset (&outrel, 0, sizeof outrel);
1447
        /* h->dynindx may be -1 if the symbol was marked to
1448
     become local.  */
1449
0
        else if (h != NULL
1450
0
           && ((! info->symbolic && h->dynindx != -1)
1451
0
         || !h->def_regular))
1452
0
    {
1453
0
      BFD_ASSERT (h->dynindx != -1);
1454
0
      outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1455
0
      outrel.r_addend = relocation + rel->r_addend;
1456
0
    }
1457
0
        else
1458
0
    {
1459
0
      if (r_type == R_VAX_32)
1460
0
        {
1461
0
          relocate = true;
1462
0
          outrel.r_info = ELF32_R_INFO (0, R_VAX_RELATIVE);
1463
0
          BFD_ASSERT (bfd_get_signed_32 (input_bfd,
1464
0
                 &contents[rel->r_offset]) == 0);
1465
0
          outrel.r_addend = relocation + rel->r_addend;
1466
0
        }
1467
0
      else
1468
0
        {
1469
0
          long indx;
1470
1471
0
          if (bfd_is_abs_section (sec))
1472
0
      indx = 0;
1473
0
          else if (sec == NULL || sec->owner == NULL)
1474
0
      {
1475
0
        bfd_set_error (bfd_error_bad_value);
1476
0
        return false;
1477
0
      }
1478
0
          else
1479
0
      {
1480
0
        asection *osec;
1481
1482
        /* We are turning this relocation into one
1483
           against a section symbol.  It would be
1484
           proper to subtract the symbol's value,
1485
           osec->vma, from the emitted reloc addend,
1486
           but ld.so expects buggy relocs.  */
1487
0
        osec = sec->output_section;
1488
0
        indx = elf_section_data (osec)->dynindx;
1489
0
        if (indx == 0)
1490
0
          {
1491
0
            struct elf_link_hash_table *htab;
1492
0
            htab = elf_hash_table (info);
1493
0
            osec = htab->text_index_section;
1494
0
            indx = elf_section_data (osec)->dynindx;
1495
0
          }
1496
0
        BFD_ASSERT (indx != 0);
1497
0
      }
1498
1499
0
          outrel.r_info = ELF32_R_INFO (indx, r_type);
1500
0
          outrel.r_addend = relocation + rel->r_addend;
1501
0
        }
1502
0
    }
1503
1504
0
        if ((input_section->flags & SEC_CODE) != 0
1505
0
      || (ELF32_R_TYPE (outrel.r_info) != R_VAX_32
1506
0
          && ELF32_R_TYPE (outrel.r_info) != R_VAX_RELATIVE
1507
0
          && ELF32_R_TYPE (outrel.r_info) != R_VAX_COPY
1508
0
          && ELF32_R_TYPE (outrel.r_info) != R_VAX_JMP_SLOT
1509
0
          && ELF32_R_TYPE (outrel.r_info) != R_VAX_GLOB_DAT))
1510
0
    {
1511
0
      if (h != NULL)
1512
0
        _bfd_error_handler
1513
          /* xgettext:c-format */
1514
0
          (_("%pB: warning: %s relocation against symbol `%s'"
1515
0
       " from %pA section"),
1516
0
          input_bfd, howto->name, h->root.root.string,
1517
0
          input_section);
1518
0
      else
1519
0
        _bfd_error_handler
1520
          /* xgettext:c-format */
1521
0
          (_("%pB: warning: %s relocation to %#" PRIx64
1522
0
       " from %pA section"),
1523
0
          input_bfd, howto->name, (uint64_t) outrel.r_addend,
1524
0
          input_section);
1525
0
    }
1526
0
        loc = sreloc->contents;
1527
0
        loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1528
0
        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1529
1530
        /* This reloc will be computed at runtime, so there's no
1531
     need to do anything now, except for R_VAX_32
1532
     relocations that have been turned into
1533
     R_VAX_RELATIVE.  */
1534
0
        if (!relocate)
1535
0
    continue;
1536
0
      }
1537
1538
0
    break;
1539
1540
0
  case R_VAX_GNU_VTINHERIT:
1541
0
  case R_VAX_GNU_VTENTRY:
1542
    /* These are no-ops in the end.  */
1543
0
    continue;
1544
1545
0
  default:
1546
0
    break;
1547
0
  }
1548
1549
      /* VAX PCREL relocations are from the end of relocation, not the start.
1550
   So subtract the difference from the relocation amount since we can't
1551
   add it to the offset.  */
1552
0
      if (howto->pc_relative && howto->pcrel_offset)
1553
0
  relocation -= bfd_get_reloc_size(howto);
1554
1555
0
      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1556
0
            contents, rel->r_offset,
1557
0
            relocation, rel->r_addend);
1558
1559
0
      if (r != bfd_reloc_ok)
1560
0
  {
1561
0
    switch (r)
1562
0
      {
1563
0
      default:
1564
0
      case bfd_reloc_outofrange:
1565
0
        abort ();
1566
0
      case bfd_reloc_overflow:
1567
0
        {
1568
0
    const char *name;
1569
1570
0
    if (h != NULL)
1571
0
      name = NULL;
1572
0
    else
1573
0
      {
1574
0
        name = bfd_elf_string_from_elf_section (input_bfd,
1575
0
                  symtab_hdr->sh_link,
1576
0
                  sym->st_name);
1577
0
        if (name == NULL)
1578
0
          return false;
1579
0
        if (*name == '\0')
1580
0
          name = bfd_section_name (sec);
1581
0
      }
1582
0
    info->callbacks->reloc_overflow
1583
0
      (info, (h ? &h->root : NULL), name, howto->name,
1584
0
       (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1585
0
        }
1586
0
        break;
1587
0
      }
1588
0
  }
1589
0
    }
1590
1591
0
  return true;
1592
0
}
1593
1594
/* Finish up dynamic symbol handling.  We set the contents of various
1595
   dynamic sections here.  */
1596
1597
static bool
1598
elf_vax_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
1599
             struct elf_link_hash_entry *h,
1600
             Elf_Internal_Sym *sym)
1601
0
{
1602
0
  bfd *dynobj;
1603
1604
0
  dynobj = elf_hash_table (info)->dynobj;
1605
1606
0
  if (h->plt.offset != (bfd_vma) -1)
1607
0
    {
1608
0
      asection *splt;
1609
0
      asection *sgot;
1610
0
      asection *srela;
1611
0
      bfd_vma plt_index;
1612
0
      bfd_vma got_offset;
1613
0
      bfd_vma addend;
1614
0
      Elf_Internal_Rela rela;
1615
0
      bfd_byte *loc;
1616
1617
      /* This symbol has an entry in the procedure linkage table.  Set
1618
   it up.  */
1619
0
      BFD_ASSERT (h->dynindx != -1);
1620
1621
0
      splt = elf_hash_table (info)->splt;
1622
0
      sgot = elf_hash_table (info)->sgotplt;
1623
0
      srela = elf_hash_table (info)->srelplt;
1624
0
      BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1625
1626
0
      addend = 2 * (h->plt.offset & 1);
1627
0
      h->plt.offset &= ~1;
1628
1629
      /* Get the index in the procedure linkage table which
1630
   corresponds to this symbol.  This is the index of this symbol
1631
   in all the symbols for which we are making plt entries.  The
1632
   first entry in the procedure linkage table is reserved.  */
1633
0
      plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1634
1635
      /* Get the offset into the .got table of the entry that
1636
   corresponds to this function.  Each .got entry is 4 bytes.
1637
   The first two are reserved.  */
1638
0
      got_offset = (plt_index + 3) * 4;
1639
1640
      /* Fill in the entry in the procedure linkage table.  */
1641
0
      memcpy (splt->contents + h->plt.offset, elf_vax_plt_entry,
1642
0
      PLT_ENTRY_SIZE);
1643
1644
      /* The offset is relative to the first extension word.  */
1645
0
      bfd_put_32 (output_bfd,
1646
0
      -(h->plt.offset + 8),
1647
0
      splt->contents + h->plt.offset + 4);
1648
1649
0
      bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
1650
0
      splt->contents + h->plt.offset + 8);
1651
1652
      /* Fill in the entry in the global offset table.  */
1653
0
      bfd_put_32 (output_bfd,
1654
0
      (splt->output_section->vma
1655
0
       + splt->output_offset
1656
0
       + h->plt.offset) + addend,
1657
0
      sgot->contents + got_offset);
1658
1659
      /* Fill in the entry in the .rela.plt section.  */
1660
0
      rela.r_offset = (sgot->output_section->vma
1661
0
           + sgot->output_offset
1662
0
           + got_offset);
1663
0
      rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_JMP_SLOT);
1664
0
      rela.r_addend = addend;
1665
0
      loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
1666
0
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1667
1668
0
      if (!h->def_regular)
1669
0
  {
1670
    /* Mark the symbol as undefined, rather than as defined in
1671
       the .plt section.  Leave the value alone.  */
1672
0
    sym->st_shndx = SHN_UNDEF;
1673
0
  }
1674
0
    }
1675
1676
0
  if (h->got.offset != (bfd_vma) -1)
1677
0
    {
1678
0
      asection *sgot;
1679
0
      asection *srela;
1680
0
      Elf_Internal_Rela rela;
1681
0
      bfd_byte *loc;
1682
1683
      /* This symbol has an entry in the global offset table.  Set it
1684
   up.  */
1685
0
      sgot = elf_hash_table (info)->sgot;
1686
0
      srela = elf_hash_table (info)->srelgot;
1687
0
      BFD_ASSERT (sgot != NULL && srela != NULL);
1688
1689
0
      rela.r_offset = (sgot->output_section->vma
1690
0
           + sgot->output_offset
1691
0
           + h->got.offset);
1692
0
      rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_GLOB_DAT);
1693
0
      rela.r_addend = bfd_get_signed_32 (output_bfd,
1694
0
           sgot->contents + h->got.offset);
1695
1696
0
      loc = srela->contents;
1697
0
      loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
1698
0
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1699
0
    }
1700
1701
0
  if (h->needs_copy)
1702
0
    {
1703
0
      asection *s;
1704
0
      Elf_Internal_Rela rela;
1705
0
      bfd_byte *loc;
1706
1707
      /* This symbol needs a copy reloc.  Set it up.  */
1708
0
      BFD_ASSERT (h->dynindx != -1
1709
0
      && (h->root.type == bfd_link_hash_defined
1710
0
          || h->root.type == bfd_link_hash_defweak));
1711
1712
0
      s = bfd_get_linker_section (dynobj, ".rela.bss");
1713
0
      BFD_ASSERT (s != NULL);
1714
1715
0
      rela.r_offset = (h->root.u.def.value
1716
0
           + h->root.u.def.section->output_section->vma
1717
0
           + h->root.u.def.section->output_offset);
1718
0
      rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_COPY);
1719
0
      rela.r_addend = 0;
1720
0
      loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
1721
0
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1722
0
    }
1723
1724
  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
1725
0
  if (h == elf_hash_table (info)->hdynamic
1726
0
      || h == elf_hash_table (info)->hgot)
1727
0
    sym->st_shndx = SHN_ABS;
1728
1729
0
  return true;
1730
0
}
1731
1732
/* Finish up the dynamic sections.  */
1733
1734
static bool
1735
elf_vax_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1736
0
{
1737
0
  bfd *dynobj;
1738
0
  asection *sgot;
1739
0
  asection *sdyn;
1740
1741
0
  dynobj = elf_hash_table (info)->dynobj;
1742
1743
0
  sgot = elf_hash_table (info)->sgotplt;
1744
0
  BFD_ASSERT (sgot != NULL);
1745
0
  sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1746
1747
0
  if (elf_hash_table (info)->dynamic_sections_created)
1748
0
    {
1749
0
      asection *splt;
1750
0
      Elf32_External_Dyn *dyncon, *dynconend;
1751
1752
0
      splt = elf_hash_table (info)->splt;
1753
0
      BFD_ASSERT (splt != NULL && sdyn != NULL);
1754
1755
0
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
1756
0
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1757
0
      for (; dyncon < dynconend; dyncon++)
1758
0
  {
1759
0
    Elf_Internal_Dyn dyn;
1760
0
    asection *s;
1761
1762
0
    bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1763
1764
0
    switch (dyn.d_tag)
1765
0
      {
1766
0
      default:
1767
0
        break;
1768
1769
0
      case DT_PLTGOT:
1770
0
        s = elf_hash_table (info)->sgotplt;
1771
0
        goto get_vma;
1772
0
      case DT_JMPREL:
1773
0
        s = elf_hash_table (info)->srelplt;
1774
0
      get_vma:
1775
0
        dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1776
0
        bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1777
0
        break;
1778
1779
0
      case DT_PLTRELSZ:
1780
0
        s = elf_hash_table (info)->srelplt;
1781
0
        dyn.d_un.d_val = s->size;
1782
0
        bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1783
0
        break;
1784
0
      }
1785
0
  }
1786
1787
      /* Fill in the first entry in the procedure linkage table.  */
1788
0
      if (splt->size > 0)
1789
0
  {
1790
0
    memcpy (splt->contents, elf_vax_plt0_entry, PLT_ENTRY_SIZE);
1791
0
    bfd_put_32 (output_bfd,
1792
0
        (sgot->output_section->vma
1793
0
         + sgot->output_offset + 4
1794
0
         - (splt->output_section->vma + 6)),
1795
0
        splt->contents + 2);
1796
0
    bfd_put_32 (output_bfd,
1797
0
        (sgot->output_section->vma
1798
0
         + sgot->output_offset + 8
1799
0
         - (splt->output_section->vma + 12)),
1800
0
        splt->contents + 8);
1801
0
    elf_section_data (splt->output_section)->this_hdr.sh_entsize
1802
0
     = PLT_ENTRY_SIZE;
1803
0
  }
1804
0
    }
1805
1806
  /* Fill in the first three entries in the global offset table.  */
1807
0
  if (sgot->size > 0)
1808
0
    {
1809
0
      if (sdyn == NULL)
1810
0
  bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1811
0
      else
1812
0
  bfd_put_32 (output_bfd,
1813
0
        sdyn->output_section->vma + sdyn->output_offset,
1814
0
        sgot->contents);
1815
0
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1816
0
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1817
0
    }
1818
1819
0
  if (elf_section_data (sgot->output_section) != NULL)
1820
0
    elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1821
1822
0
  return true;
1823
0
}
1824
1825
static enum elf_reloc_type_class
1826
elf_vax_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1827
        const asection *rel_sec ATTRIBUTE_UNUSED,
1828
        const Elf_Internal_Rela *rela)
1829
0
{
1830
0
  switch ((int) ELF32_R_TYPE (rela->r_info))
1831
0
    {
1832
0
    case R_VAX_RELATIVE:
1833
0
      return reloc_class_relative;
1834
0
    case R_VAX_JMP_SLOT:
1835
0
      return reloc_class_plt;
1836
0
    case R_VAX_COPY:
1837
0
      return reloc_class_copy;
1838
0
    default:
1839
0
      return reloc_class_normal;
1840
0
    }
1841
0
}
1842
1843
static bfd_vma
1844
elf_vax_plt_sym_val (bfd_vma i, const asection *plt,
1845
         const arelent *rel ATTRIBUTE_UNUSED)
1846
0
{
1847
0
  return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
1848
0
}
1849
1850
#define TARGET_LITTLE_SYM   vax_elf32_vec
1851
#define TARGET_LITTLE_NAME    "elf32-vax"
1852
#define ELF_MACHINE_CODE    EM_VAX
1853
#define ELF_MAXPAGESIZE     0x1000
1854
1855
#define elf_backend_create_dynamic_sections \
1856
          _bfd_elf_create_dynamic_sections
1857
#define bfd_elf32_bfd_link_hash_table_create \
1858
          elf_vax_link_hash_table_create
1859
#define bfd_elf32_bfd_final_link  bfd_elf_gc_common_final_link
1860
1861
#define elf_backend_check_relocs  elf_vax_check_relocs
1862
#define elf_backend_adjust_dynamic_symbol \
1863
          elf_vax_adjust_dynamic_symbol
1864
#define elf_backend_early_size_sections elf_vax_early_size_sections
1865
#define elf_backend_late_size_sections  elf_vax_late_size_sections
1866
#define elf_backend_init_index_section  _bfd_elf_init_1_index_section
1867
#define elf_backend_relocate_section  elf_vax_relocate_section
1868
#define elf_backend_finish_dynamic_symbol \
1869
          elf_vax_finish_dynamic_symbol
1870
#define elf_backend_finish_dynamic_sections \
1871
          elf_vax_finish_dynamic_sections
1872
#define elf_backend_reloc_type_class  elf_vax_reloc_type_class
1873
#define elf_backend_gc_mark_hook  elf_vax_gc_mark_hook
1874
#define elf_backend_plt_sym_val   elf_vax_plt_sym_val
1875
#define bfd_elf32_bfd_merge_private_bfd_data \
1876
          elf32_vax_merge_private_bfd_data
1877
#define bfd_elf32_bfd_set_private_flags \
1878
          elf32_vax_set_private_flags
1879
#define bfd_elf32_bfd_print_private_bfd_data \
1880
          elf32_vax_print_private_bfd_data
1881
1882
#define elf_backend_can_gc_sections 1
1883
#define elf_backend_want_got_plt  1
1884
#define elf_backend_plt_readonly  1
1885
#define elf_backend_want_plt_sym  0
1886
#define elf_backend_got_header_size 16
1887
#define elf_backend_rela_normal   1
1888
#define elf_backend_dtrel_excludes_plt  1
1889
1890
#include "elf32-target.h"