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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [elf32-vax.c] - Blame information for rev 148

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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