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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [elf32-vax.c] - Blame information for rev 156

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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