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 266

Go to most recent revision | 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.