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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [bfd/] [elf64-hppa.c] - Blame information for rev 1776

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* Support for HPPA 64-bit ELF
2
   Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
3
 
4
This file is part of BFD, the Binary File Descriptor library.
5
 
6
This program is free software; you can redistribute it and/or modify
7
it under the terms of the GNU General Public License as published by
8
the Free Software Foundation; either version 2 of the License, or
9
(at your option) any later version.
10
 
11
This program is distributed in the hope that it will be useful,
12
but WITHOUT ANY WARRANTY; without even the implied warranty of
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
GNU General Public License for more details.
15
 
16
You should have received a copy of the GNU General Public License
17
along with this program; if not, write to the Free Software
18
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
19
 
20
#include "alloca-conf.h"
21
#include "bfd.h"
22
#include "sysdep.h"
23
#include "libbfd.h"
24
#include "elf-bfd.h"
25
#include "elf/hppa.h"
26
#include "libhppa.h"
27
#include "elf64-hppa.h"
28
#define ARCH_SIZE              64
29
 
30
#define PLT_ENTRY_SIZE 0x10
31
#define DLT_ENTRY_SIZE 0x8
32
#define OPD_ENTRY_SIZE 0x20
33
 
34
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/pa20_64/dld.sl"
35
 
36
/* The stub is supposed to load the target address and target's DP
37
   value out of the PLT, then do an external branch to the target
38
   address.
39
 
40
   LDD PLTOFF(%r27),%r1
41
   BVE (%r1)
42
   LDD PLTOFF+8(%r27),%r27
43
 
44
   Note that we must use the LDD with a 14 bit displacement, not the one
45
   with a 5 bit displacement.  */
46
static char plt_stub[] = {0x53, 0x61, 0x00, 0x00, 0xe8, 0x20, 0xd0, 0x00,
47
                          0x53, 0x7b, 0x00, 0x00 };
48
 
49
struct elf64_hppa_dyn_hash_entry
50
{
51
  struct bfd_hash_entry root;
52
 
53
  /* Offsets for this symbol in various linker sections.  */
54
  bfd_vma dlt_offset;
55
  bfd_vma plt_offset;
56
  bfd_vma opd_offset;
57
  bfd_vma stub_offset;
58
 
59
  /* The symbol table entry, if any, that this was derived from.  */
60
  struct elf_link_hash_entry *h;
61
 
62
  /* The index of the (possibly local) symbol in the input bfd and its
63
     associated BFD.  Needed so that we can have relocs against local
64
     symbols in shared libraries.  */
65
  unsigned long sym_indx;
66
  bfd *owner;
67
 
68
  /* Dynamic symbols may need to have two different values.  One for
69
     the dynamic symbol table, one for the normal symbol table.
70
 
71
     In such cases we store the symbol's real value and section
72
     index here so we can restore the real value before we write
73
     the normal symbol table.  */
74
  bfd_vma st_value;
75
  int st_shndx;
76
 
77
  /* Used to count non-got, non-plt relocations for delayed sizing
78
     of relocation sections.  */
79
  struct elf64_hppa_dyn_reloc_entry
80
  {
81
    /* Next relocation in the chain.  */
82
    struct elf64_hppa_dyn_reloc_entry *next;
83
 
84
    /* The type of the relocation.  */
85
    int type;
86
 
87
    /* The input section of the relocation.  */
88
    asection *sec;
89
 
90
    /* The index of the section symbol for the input section of
91
       the relocation.  Only needed when building shared libraries.  */
92
    int sec_symndx;
93
 
94
    /* The offset within the input section of the relocation.  */
95
    bfd_vma offset;
96
 
97
    /* The addend for the relocation.  */
98
    bfd_vma addend;
99
 
100
  } *reloc_entries;
101
 
102
  /* Nonzero if this symbol needs an entry in one of the linker
103
     sections.  */
104
  unsigned want_dlt;
105
  unsigned want_plt;
106
  unsigned want_opd;
107
  unsigned want_stub;
108
};
109
 
110
struct elf64_hppa_dyn_hash_table
111
{
112
  struct bfd_hash_table root;
113
};
114
 
115
struct elf64_hppa_link_hash_table
116
{
117
  struct elf_link_hash_table root;
118
 
119
  /* Shortcuts to get to the various linker defined sections.  */
120
  asection *dlt_sec;
121
  asection *dlt_rel_sec;
122
  asection *plt_sec;
123
  asection *plt_rel_sec;
124
  asection *opd_sec;
125
  asection *opd_rel_sec;
126
  asection *other_rel_sec;
127
 
128
  /* Offset of __gp within .plt section.  When the PLT gets large we want
129
     to slide __gp into the PLT section so that we can continue to use
130
     single DP relative instructions to load values out of the PLT.  */
131
  bfd_vma gp_offset;
132
 
133
  /* Note this is not strictly correct.  We should create a stub section for
134
     each input section with calls.  The stub section should be placed before
135
     the section with the call.  */
136
  asection *stub_sec;
137
 
138
  bfd_vma text_segment_base;
139
  bfd_vma data_segment_base;
140
 
141
  struct elf64_hppa_dyn_hash_table dyn_hash_table;
142
 
143
  /* We build tables to map from an input section back to its
144
     symbol index.  This is the BFD for which we currently have
145
     a map.  */
146
  bfd *section_syms_bfd;
147
 
148
  /* Array of symbol numbers for each input section attached to the
149
     current BFD.  */
150
  int *section_syms;
151
};
152
 
153
#define elf64_hppa_hash_table(p) \
154
  ((struct elf64_hppa_link_hash_table *) ((p)->hash))
155
 
156
typedef struct bfd_hash_entry *(*new_hash_entry_func)
157
  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
158
 
159
static boolean elf64_hppa_dyn_hash_table_init
160
  PARAMS ((struct elf64_hppa_dyn_hash_table *ht, bfd *abfd,
161
           new_hash_entry_func new));
162
static struct bfd_hash_entry *elf64_hppa_new_dyn_hash_entry
163
  PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
164
           const char *string));
165
static struct bfd_link_hash_table *elf64_hppa_hash_table_create
166
  PARAMS ((bfd *abfd));
167
static struct elf64_hppa_dyn_hash_entry *elf64_hppa_dyn_hash_lookup
168
  PARAMS ((struct elf64_hppa_dyn_hash_table *table, const char *string,
169
           boolean create, boolean copy));
170
static void elf64_hppa_dyn_hash_traverse
171
  PARAMS ((struct elf64_hppa_dyn_hash_table *table,
172
           boolean (*func) (struct elf64_hppa_dyn_hash_entry *, PTR),
173
           PTR info));
174
 
175
static const char *get_dyn_name
176
  PARAMS ((asection *, struct elf_link_hash_entry *,
177
           const Elf_Internal_Rela *, char **, size_t *));
178
 
179
/* This must follow the definitions of the various derived linker
180
   hash tables and shared functions.  */
181
#include "elf-hppa.h"
182
 
183
static boolean elf64_hppa_object_p
184
  PARAMS ((bfd *));
185
 
186
static boolean elf64_hppa_section_from_shdr
187
  PARAMS ((bfd *, Elf64_Internal_Shdr *, char *));
188
 
189
static void elf64_hppa_post_process_headers
190
  PARAMS ((bfd *, struct bfd_link_info *));
191
 
192
static boolean elf64_hppa_create_dynamic_sections
193
  PARAMS ((bfd *, struct bfd_link_info *));
194
 
195
static boolean elf64_hppa_adjust_dynamic_symbol
196
  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
197
 
198
static boolean elf64_hppa_size_dynamic_sections
199
  PARAMS ((bfd *, struct bfd_link_info *));
200
 
201
static boolean elf64_hppa_finish_dynamic_symbol
202
  PARAMS ((bfd *, struct bfd_link_info *,
203
           struct elf_link_hash_entry *, Elf_Internal_Sym *));
204
 
205
static boolean elf64_hppa_finish_dynamic_sections
206
  PARAMS ((bfd *, struct bfd_link_info *));
207
 
208
static boolean elf64_hppa_check_relocs
209
  PARAMS ((bfd *, struct bfd_link_info *,
210
           asection *, const Elf_Internal_Rela *));
211
 
212
static boolean elf64_hppa_dynamic_symbol_p
213
  PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *));
214
 
215
static boolean elf64_hppa_mark_exported_functions
216
  PARAMS ((struct elf_link_hash_entry *, PTR));
217
 
218
static boolean elf64_hppa_finalize_opd
219
  PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
220
 
221
static boolean elf64_hppa_finalize_dlt
222
  PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
223
 
224
static boolean allocate_global_data_dlt
225
  PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
226
 
227
static boolean allocate_global_data_plt
228
  PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
229
 
230
static boolean allocate_global_data_stub
231
  PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
232
 
233
static boolean allocate_global_data_opd
234
  PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
235
 
236
static boolean get_reloc_section
237
  PARAMS ((bfd *, struct elf64_hppa_link_hash_table *, asection *));
238
 
239
static boolean count_dyn_reloc
240
  PARAMS ((bfd *, struct elf64_hppa_dyn_hash_entry *,
241
           int, asection *, int, bfd_vma, bfd_vma));
242
 
243
static boolean allocate_dynrel_entries
244
  PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
245
 
246
static boolean elf64_hppa_finalize_dynreloc
247
  PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
248
 
249
static boolean get_opd
250
  PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *));
251
 
252
static boolean get_plt
253
  PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *));
254
 
255
static boolean get_dlt
256
  PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *));
257
 
258
static boolean get_stub
259
  PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *));
260
 
261
static int elf64_hppa_elf_get_symbol_type
262
  PARAMS ((Elf_Internal_Sym *, int));
263
 
264
static boolean
265
elf64_hppa_dyn_hash_table_init (ht, abfd, new)
266
     struct elf64_hppa_dyn_hash_table *ht;
267
     bfd *abfd ATTRIBUTE_UNUSED;
268
     new_hash_entry_func new;
269
{
270
  memset (ht, 0, sizeof (*ht));
271
  return bfd_hash_table_init (&ht->root, new);
272
}
273
 
274
static struct bfd_hash_entry*
275
elf64_hppa_new_dyn_hash_entry (entry, table, string)
276
     struct bfd_hash_entry *entry;
277
     struct bfd_hash_table *table;
278
     const char *string;
279
{
280
  struct elf64_hppa_dyn_hash_entry *ret;
281
  ret = (struct elf64_hppa_dyn_hash_entry *) entry;
282
 
283
  /* Allocate the structure if it has not already been allocated by a
284
     subclass.  */
285
  if (!ret)
286
    ret = bfd_hash_allocate (table, sizeof (*ret));
287
 
288
  if (!ret)
289
    return 0;
290
 
291
  /* Initialize our local data.  All zeros, and definitely easier
292
     than setting 8 bit fields.  */
293
  memset (ret, 0, sizeof (*ret));
294
 
295
  /* Call the allocation method of the superclass.  */
296
  ret = ((struct elf64_hppa_dyn_hash_entry *)
297
         bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
298
 
299
  return &ret->root;
300
}
301
 
302
/* Create the derived linker hash table.  The PA64 ELF port uses this
303
   derived hash table to keep information specific to the PA ElF
304
   linker (without using static variables).  */
305
 
306
static struct bfd_link_hash_table*
307
elf64_hppa_hash_table_create (abfd)
308
     bfd *abfd;
309
{
310
  struct elf64_hppa_link_hash_table *ret;
311
 
312
  ret = bfd_zalloc (abfd, sizeof (*ret));
313
  if (!ret)
314
    return 0;
315
  if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
316
                                      _bfd_elf_link_hash_newfunc))
317
    {
318
      bfd_release (abfd, ret);
319
      return 0;
320
    }
321
 
322
  if (!elf64_hppa_dyn_hash_table_init (&ret->dyn_hash_table, abfd,
323
                                       elf64_hppa_new_dyn_hash_entry))
324
    return 0;
325
  return &ret->root.root;
326
}
327
 
328
/* Look up an entry in a PA64 ELF linker hash table.  */
329
 
330
static struct elf64_hppa_dyn_hash_entry *
331
elf64_hppa_dyn_hash_lookup(table, string, create, copy)
332
     struct elf64_hppa_dyn_hash_table *table;
333
     const char *string;
334
     boolean create, copy;
335
{
336
  return ((struct elf64_hppa_dyn_hash_entry *)
337
          bfd_hash_lookup (&table->root, string, create, copy));
338
}
339
 
340
/* Traverse a PA64 ELF linker hash table.  */
341
 
342
static void
343
elf64_hppa_dyn_hash_traverse (table, func, info)
344
     struct elf64_hppa_dyn_hash_table *table;
345
     boolean (*func) PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
346
     PTR info;
347
{
348
  (bfd_hash_traverse
349
   (&table->root,
350
    (boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) func,
351
    info));
352
}
353
 
354
/* Return nonzero if ABFD represents a PA2.0 ELF64 file.
355
 
356
   Additionally we set the default architecture and machine.  */
357
static boolean
358
elf64_hppa_object_p (abfd)
359
     bfd *abfd;
360
{
361
  Elf_Internal_Ehdr * i_ehdrp;
362
  unsigned int flags;
363
 
364
  i_ehdrp = elf_elfheader (abfd);
365
  if (strcmp (bfd_get_target (abfd), "elf64-hppa-linux") == 0)
366
    {
367
      if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_LINUX)
368
        return false;
369
    }
370
  else
371
    {
372
      if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX)
373
        return false;
374
    }
375
 
376
  flags = i_ehdrp->e_flags;
377
  switch (flags & (EF_PARISC_ARCH | EF_PARISC_WIDE))
378
    {
379
    case EFA_PARISC_1_0:
380
      return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10);
381
    case EFA_PARISC_1_1:
382
      return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11);
383
    case EFA_PARISC_2_0:
384
      return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20);
385
    case EFA_PARISC_2_0 | EF_PARISC_WIDE:
386
      return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
387
    }
388
  /* Don't be fussy.  */
389
  return true;
390
}
391
 
392
/* Given section type (hdr->sh_type), return a boolean indicating
393
   whether or not the section is an elf64-hppa specific section.  */
394
static boolean
395
elf64_hppa_section_from_shdr (abfd, hdr, name)
396
     bfd *abfd;
397
     Elf64_Internal_Shdr *hdr;
398
     char *name;
399
{
400
  asection *newsect;
401
 
402
  switch (hdr->sh_type)
403
    {
404
    case SHT_PARISC_EXT:
405
      if (strcmp (name, ".PARISC.archext") != 0)
406
        return false;
407
      break;
408
    case SHT_PARISC_UNWIND:
409
      if (strcmp (name, ".PARISC.unwind") != 0)
410
        return false;
411
      break;
412
    case SHT_PARISC_DOC:
413
    case SHT_PARISC_ANNOT:
414
    default:
415
      return false;
416
    }
417
 
418
  if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
419
    return false;
420
  newsect = hdr->bfd_section;
421
 
422
  return true;
423
}
424
 
425
/* Construct a string for use in the elf64_hppa_dyn_hash_table.  The
426
   name describes what was once potentially anonymous memory.  We
427
   allocate memory as necessary, possibly reusing PBUF/PLEN.  */
428
 
429
static const char *
430
get_dyn_name (sec, h, rel, pbuf, plen)
431
     asection *sec;
432
     struct elf_link_hash_entry *h;
433
     const Elf_Internal_Rela *rel;
434
     char **pbuf;
435
     size_t *plen;
436
{
437
  size_t nlen, tlen;
438
  char *buf;
439
  size_t len;
440
 
441
  if (h && rel->r_addend == 0)
442
    return h->root.root.string;
443
 
444
  if (h)
445
    nlen = strlen (h->root.root.string);
446
  else
447
    nlen = 8 + 1 + sizeof (rel->r_info) * 2 - 8;
448
  tlen = nlen + 1 + sizeof (rel->r_addend) * 2 + 1;
449
 
450
  len = *plen;
451
  buf = *pbuf;
452
  if (len < tlen)
453
    {
454
      if (buf)
455
        free (buf);
456
      *pbuf = buf = malloc (tlen);
457
      *plen = len = tlen;
458
      if (!buf)
459
        return NULL;
460
    }
461
 
462
  if (h)
463
    {
464
      memcpy (buf, h->root.root.string, nlen);
465
      buf[nlen++] = '+';
466
      sprintf_vma (buf + nlen, rel->r_addend);
467
    }
468
  else
469
    {
470
      nlen = sprintf (buf, "%x:%lx",
471
                      sec->id & 0xffffffff,
472
                      (long) ELF64_R_SYM (rel->r_info));
473
      if (rel->r_addend)
474
        {
475
          buf[nlen++] = '+';
476
          sprintf_vma (buf + nlen, rel->r_addend);
477
        }
478
    }
479
 
480
  return buf;
481
}
482
 
483
/* SEC is a section containing relocs for an input BFD when linking; return
484
   a suitable section for holding relocs in the output BFD for a link.  */
485
 
486
static boolean
487
get_reloc_section (abfd, hppa_info, sec)
488
     bfd *abfd;
489
     struct elf64_hppa_link_hash_table *hppa_info;
490
     asection *sec;
491
{
492
  const char *srel_name;
493
  asection *srel;
494
  bfd *dynobj;
495
 
496
  srel_name = (bfd_elf_string_from_elf_section
497
               (abfd, elf_elfheader(abfd)->e_shstrndx,
498
                elf_section_data(sec)->rel_hdr.sh_name));
499
  if (srel_name == NULL)
500
    return false;
501
 
502
  BFD_ASSERT ((strncmp (srel_name, ".rela", 5) == 0
503
               && strcmp (bfd_get_section_name (abfd, sec),
504
                          srel_name+5) == 0)
505
              || (strncmp (srel_name, ".rel", 4) == 0
506
                  && strcmp (bfd_get_section_name (abfd, sec),
507
                             srel_name+4) == 0));
508
 
509
  dynobj = hppa_info->root.dynobj;
510
  if (!dynobj)
511
    hppa_info->root.dynobj = dynobj = abfd;
512
 
513
  srel = bfd_get_section_by_name (dynobj, srel_name);
514
  if (srel == NULL)
515
    {
516
      srel = bfd_make_section (dynobj, srel_name);
517
      if (srel == NULL
518
          || !bfd_set_section_flags (dynobj, srel,
519
                                     (SEC_ALLOC
520
                                      | SEC_LOAD
521
                                      | SEC_HAS_CONTENTS
522
                                      | SEC_IN_MEMORY
523
                                      | SEC_LINKER_CREATED
524
                                      | SEC_READONLY))
525
          || !bfd_set_section_alignment (dynobj, srel, 3))
526
        return false;
527
    }
528
 
529
  hppa_info->other_rel_sec = srel;
530
  return true;
531
}
532
 
533
/* Add a new entry to the list of dynamic relocations against DYN_H.
534
 
535
   We use this to keep a record of all the FPTR relocations against a
536
   particular symbol so that we can create FPTR relocations in the
537
   output file.  */
538
 
539
static boolean
540
count_dyn_reloc (abfd, dyn_h, type, sec, sec_symndx, offset, addend)
541
     bfd *abfd;
542
     struct elf64_hppa_dyn_hash_entry *dyn_h;
543
     int type;
544
     asection *sec;
545
     int sec_symndx;
546
     bfd_vma offset;
547
     bfd_vma addend;
548
{
549
  struct elf64_hppa_dyn_reloc_entry *rent;
550
 
551
  rent = (struct elf64_hppa_dyn_reloc_entry *)
552
  bfd_alloc (abfd, sizeof (*rent));
553
  if (!rent)
554
    return false;
555
 
556
  rent->next = dyn_h->reloc_entries;
557
  rent->type = type;
558
  rent->sec = sec;
559
  rent->sec_symndx = sec_symndx;
560
  rent->offset = offset;
561
  rent->addend = addend;
562
  dyn_h->reloc_entries = rent;
563
 
564
  return true;
565
}
566
 
567
/* Scan the RELOCS and record the type of dynamic entries that each
568
   referenced symbol needs.  */
569
 
570
static boolean
571
elf64_hppa_check_relocs (abfd, info, sec, relocs)
572
     bfd *abfd;
573
     struct bfd_link_info *info;
574
     asection *sec;
575
     const Elf_Internal_Rela *relocs;
576
{
577
  struct elf64_hppa_link_hash_table *hppa_info;
578
  const Elf_Internal_Rela *relend;
579
  Elf_Internal_Shdr *symtab_hdr;
580
  const Elf_Internal_Rela *rel;
581
  asection *dlt, *plt, *stubs;
582
  char *buf;
583
  size_t buf_len;
584
  int sec_symndx;
585
 
586
  if (info->relocateable)
587
    return true;
588
 
589
  /* If this is the first dynamic object found in the link, create
590
     the special sections required for dynamic linking.  */
591
  if (! elf_hash_table (info)->dynamic_sections_created)
592
    {
593
      if (! bfd_elf64_link_create_dynamic_sections (abfd, info))
594
        return false;
595
    }
596
 
597
  hppa_info = elf64_hppa_hash_table (info);
598
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
599
 
600
  /* If necessary, build a new table holding section symbols indices
601
     for this BFD.  This is disgusting.  */
602
 
603
  if (info->shared && hppa_info->section_syms_bfd != abfd)
604
    {
605
      unsigned long i;
606
      int highest_shndx;
607
      Elf_Internal_Sym *local_syms, *isym;
608
      Elf64_External_Sym *ext_syms, *esym;
609
 
610
      /* We're done with the old cache of section index to section symbol
611
         index information.  Free it.
612
 
613
         ?!? Note we leak the last section_syms array.  Presumably we
614
         could free it in one of the later routines in this file.  */
615
      if (hppa_info->section_syms)
616
        free (hppa_info->section_syms);
617
 
618
      /* Allocate memory for the internal and external symbols.  */
619
      local_syms
620
        = (Elf_Internal_Sym *) bfd_malloc (symtab_hdr->sh_info
621
                                           * sizeof (Elf_Internal_Sym));
622
      if (local_syms == NULL)
623
        return false;
624
 
625
      ext_syms
626
        = (Elf64_External_Sym *) bfd_malloc (symtab_hdr->sh_info
627
                                             * sizeof (Elf64_External_Sym));
628
      if (ext_syms == NULL)
629
        {
630
          free (local_syms);
631
          return false;
632
        }
633
 
634
      /* Read in the local symbols.  */
635
      if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
636
          || bfd_read (ext_syms, 1,
637
                       (symtab_hdr->sh_info
638
                        * sizeof (Elf64_External_Sym)), abfd)
639
          != (symtab_hdr->sh_info * sizeof (Elf64_External_Sym)))
640
        {
641
          free (local_syms);
642
          free (ext_syms);
643
          return false;
644
        }
645
 
646
      /* Swap in the local symbols, also record the highest section index
647
         referenced by the local symbols.  */
648
      isym = local_syms;
649
      esym = ext_syms;
650
      highest_shndx = 0;
651
      for (i = 0; i < symtab_hdr->sh_info; i++, esym++, isym++)
652
        {
653
          bfd_elf64_swap_symbol_in (abfd, esym, isym);
654
          if (isym->st_shndx > highest_shndx)
655
            highest_shndx = isym->st_shndx;
656
        }
657
 
658
      /* Now we can free the external symbols.  */
659
      free (ext_syms);
660
 
661
      /* Allocate an array to hold the section index to section symbol index
662
         mapping.  Bump by one since we start counting at zero.  */
663
      highest_shndx++;
664
      hppa_info->section_syms = (int *) bfd_malloc (highest_shndx
665
                                                    * sizeof (int));
666
 
667
      /* Now walk the local symbols again.  If we find a section symbol,
668
         record the index of the symbol into the section_syms array.  */
669
      for (isym = local_syms, i = 0; i < symtab_hdr->sh_info; i++, isym++)
670
        {
671
          if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
672
            hppa_info->section_syms[isym->st_shndx] = i;
673
        }
674
 
675
      /* We are finished with the local symbols.  Get rid of them.  */
676
      free (local_syms);
677
 
678
      /* Record which BFD we built the section_syms mapping for.  */
679
      hppa_info->section_syms_bfd = abfd;
680
    }
681
 
682
  /* Record the symbol index for this input section.  We may need it for
683
     relocations when building shared libraries.  When not building shared
684
     libraries this value is never really used, but assign it to zero to
685
     prevent out of bounds memory accesses in other routines.  */
686
  if (info->shared)
687
    {
688
      sec_symndx = _bfd_elf_section_from_bfd_section (abfd, sec);
689
 
690
      /* If we did not find a section symbol for this section, then
691
         something went terribly wrong above.  */
692
      if (sec_symndx == -1)
693
        return false;
694
 
695
      sec_symndx = hppa_info->section_syms[sec_symndx];
696
    }
697
  else
698
    sec_symndx = 0;
699
 
700
  dlt = plt = stubs = NULL;
701
  buf = NULL;
702
  buf_len = 0;
703
 
704
  relend = relocs + sec->reloc_count;
705
  for (rel = relocs; rel < relend; ++rel)
706
    {
707
      enum {
708
        NEED_DLT = 1,
709
        NEED_PLT = 2,
710
        NEED_STUB = 4,
711
        NEED_OPD = 8,
712
        NEED_DYNREL = 16,
713
      };
714
 
715
      struct elf_link_hash_entry *h = NULL;
716
      unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
717
      struct elf64_hppa_dyn_hash_entry *dyn_h;
718
      int need_entry;
719
      const char *addr_name;
720
      boolean maybe_dynamic;
721
      int dynrel_type = R_PARISC_NONE;
722
      static reloc_howto_type *howto;
723
 
724
      if (r_symndx >= symtab_hdr->sh_info)
725
        {
726
          /* We're dealing with a global symbol -- find its hash entry
727
             and mark it as being referenced.  */
728
          long indx = r_symndx - symtab_hdr->sh_info;
729
          h = elf_sym_hashes (abfd)[indx];
730
          while (h->root.type == bfd_link_hash_indirect
731
                 || h->root.type == bfd_link_hash_warning)
732
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
733
 
734
          h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
735
        }
736
 
737
      /* We can only get preliminary data on whether a symbol is
738
         locally or externally defined, as not all of the input files
739
         have yet been processed.  Do something with what we know, as
740
         this may help reduce memory usage and processing time later.  */
741
      maybe_dynamic = false;
742
      if (h && ((info->shared && ! info->symbolic)
743
                || ! (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
744
                || h->root.type == bfd_link_hash_defweak))
745
        maybe_dynamic = true;
746
 
747
      howto = elf_hppa_howto_table + ELF64_R_TYPE (rel->r_info);
748
      need_entry = 0;
749
      switch (howto->type)
750
        {
751
        /* These are simple indirect references to symbols through the
752
           DLT.  We need to create a DLT entry for any symbols which
753
           appears in a DLTIND relocation.  */
754
        case R_PARISC_DLTIND21L:
755
        case R_PARISC_DLTIND14R:
756
        case R_PARISC_DLTIND14F:
757
        case R_PARISC_DLTIND14WR:
758
        case R_PARISC_DLTIND14DR:
759
          need_entry = NEED_DLT;
760
          break;
761
 
762
        /* ?!?  These need a DLT entry.  But I have no idea what to do with
763
           the "link time TP value.  */
764
        case R_PARISC_LTOFF_TP21L:
765
        case R_PARISC_LTOFF_TP14R:
766
        case R_PARISC_LTOFF_TP14F:
767
        case R_PARISC_LTOFF_TP64:
768
        case R_PARISC_LTOFF_TP14WR:
769
        case R_PARISC_LTOFF_TP14DR:
770
        case R_PARISC_LTOFF_TP16F:
771
        case R_PARISC_LTOFF_TP16WF:
772
        case R_PARISC_LTOFF_TP16DF:
773
          need_entry = NEED_DLT;
774
          break;
775
 
776
        /* These are function calls.  Depending on their precise target we
777
           may need to make a stub for them.  The stub uses the PLT, so we
778
           need to create PLT entries for these symbols too.  */
779
        case R_PARISC_PCREL12F:
780
        case R_PARISC_PCREL17F:
781
        case R_PARISC_PCREL22F:
782
        case R_PARISC_PCREL32:
783
        case R_PARISC_PCREL64:
784
        case R_PARISC_PCREL21L:
785
        case R_PARISC_PCREL17R:
786
        case R_PARISC_PCREL17C:
787
        case R_PARISC_PCREL14R:
788
        case R_PARISC_PCREL14F:
789
        case R_PARISC_PCREL22C:
790
        case R_PARISC_PCREL14WR:
791
        case R_PARISC_PCREL14DR:
792
        case R_PARISC_PCREL16F:
793
        case R_PARISC_PCREL16WF:
794
        case R_PARISC_PCREL16DF:
795
          need_entry = (NEED_PLT | NEED_STUB);
796
          break;
797
 
798
        case R_PARISC_PLTOFF21L:
799
        case R_PARISC_PLTOFF14R:
800
        case R_PARISC_PLTOFF14F:
801
        case R_PARISC_PLTOFF14WR:
802
        case R_PARISC_PLTOFF14DR:
803
        case R_PARISC_PLTOFF16F:
804
        case R_PARISC_PLTOFF16WF:
805
        case R_PARISC_PLTOFF16DF:
806
          need_entry = (NEED_PLT);
807
          break;
808
 
809
        case R_PARISC_DIR64:
810
          if (info->shared || maybe_dynamic)
811
            need_entry = (NEED_DYNREL);
812
          dynrel_type = R_PARISC_DIR64;
813
          break;
814
 
815
        /* This is an indirect reference through the DLT to get the address
816
           of a OPD descriptor.  Thus we need to make a DLT entry that points
817
           to an OPD entry.  */
818
        case R_PARISC_LTOFF_FPTR21L:
819
        case R_PARISC_LTOFF_FPTR14R:
820
        case R_PARISC_LTOFF_FPTR14WR:
821
        case R_PARISC_LTOFF_FPTR14DR:
822
        case R_PARISC_LTOFF_FPTR32:
823
        case R_PARISC_LTOFF_FPTR64:
824
        case R_PARISC_LTOFF_FPTR16F:
825
        case R_PARISC_LTOFF_FPTR16WF:
826
        case R_PARISC_LTOFF_FPTR16DF:
827
          if (info->shared || maybe_dynamic)
828
            need_entry = (NEED_DLT | NEED_OPD);
829
          else
830
            need_entry = (NEED_DLT | NEED_OPD);
831
          dynrel_type = R_PARISC_FPTR64;
832
          break;
833
 
834
        /* This is a simple OPD entry.  */
835
        case R_PARISC_FPTR64:
836
          if (info->shared || maybe_dynamic)
837
            need_entry = (NEED_OPD | NEED_DYNREL);
838
          else
839
            need_entry = (NEED_OPD);
840
          dynrel_type = R_PARISC_FPTR64;
841
          break;
842
 
843
        /* Add more cases as needed.  */
844
        }
845
 
846
      if (!need_entry)
847
        continue;
848
 
849
      /* Collect a canonical name for this address.  */
850
      addr_name = get_dyn_name (sec, h, rel, &buf, &buf_len);
851
 
852
      /* Collect the canonical entry data for this address.  */
853
      dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
854
                                          addr_name, true, true);
855
      BFD_ASSERT (dyn_h);
856
 
857
      /* Stash away enough information to be able to find this symbol
858
         regardless of whether or not it is local or global.  */
859
      dyn_h->h = h;
860
      dyn_h->owner = abfd;
861
      dyn_h->sym_indx = r_symndx;
862
 
863
      /* ?!? We may need to do some error checking in here.  */
864
      /* Create what's needed.  */
865
      if (need_entry & NEED_DLT)
866
        {
867
          if (! hppa_info->dlt_sec
868
              && ! get_dlt (abfd, info, hppa_info))
869
            goto err_out;
870
          dyn_h->want_dlt = 1;
871
        }
872
 
873
      if (need_entry & NEED_PLT)
874
        {
875
          if (! hppa_info->plt_sec
876
              && ! get_plt (abfd, info, hppa_info))
877
            goto err_out;
878
          dyn_h->want_plt = 1;
879
        }
880
 
881
      if (need_entry & NEED_STUB)
882
        {
883
          if (! hppa_info->stub_sec
884
              && ! get_stub (abfd, info, hppa_info))
885
            goto err_out;
886
          dyn_h->want_stub = 1;
887
        }
888
 
889
      if (need_entry & NEED_OPD)
890
        {
891
          if (! hppa_info->opd_sec
892
              && ! get_opd (abfd, info, hppa_info))
893
            goto err_out;
894
 
895
          dyn_h->want_opd = 1;
896
 
897
          /* FPTRs are not allocated by the dynamic linker for PA64, though
898
             it is possible that will change in the future.  */
899
 
900
          /* This could be a local function that had its address taken, in
901
             which case H will be NULL.  */
902
          if (h)
903
            h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
904
        }
905
 
906
      /* Add a new dynamic relocation to the chain of dynamic
907
         relocations for this symbol.  */
908
      if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
909
        {
910
          if (! hppa_info->other_rel_sec
911
              && ! get_reloc_section (abfd, hppa_info, sec))
912
            goto err_out;
913
 
914
          if (!count_dyn_reloc (abfd, dyn_h, dynrel_type, sec,
915
                                sec_symndx, rel->r_offset, rel->r_addend))
916
            goto err_out;
917
 
918
          /* If we are building a shared library and we just recorded
919
             a dynamic R_PARISC_FPTR64 relocation, then make sure the
920
             section symbol for this section ends up in the dynamic
921
             symbol table.  */
922
          if (info->shared && dynrel_type == R_PARISC_FPTR64
923
              && ! (_bfd_elf64_link_record_local_dynamic_symbol
924
                    (info, abfd, sec_symndx)))
925
            return false;
926
        }
927
    }
928
 
929
  if (buf)
930
    free (buf);
931
  return true;
932
 
933
 err_out:
934
  if (buf)
935
    free (buf);
936
  return false;
937
}
938
 
939
struct elf64_hppa_allocate_data
940
{
941
  struct bfd_link_info *info;
942
  bfd_size_type ofs;
943
};
944
 
945
/* Should we do dynamic things to this symbol?  */
946
 
947
static boolean
948
elf64_hppa_dynamic_symbol_p (h, info)
949
     struct elf_link_hash_entry *h;
950
     struct bfd_link_info *info;
951
{
952
  if (h == NULL)
953
    return false;
954
 
955
  while (h->root.type == bfd_link_hash_indirect
956
         || h->root.type == bfd_link_hash_warning)
957
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
958
 
959
  if (h->dynindx == -1)
960
    return false;
961
 
962
  if (h->root.type == bfd_link_hash_undefweak
963
      || h->root.type == bfd_link_hash_defweak)
964
    return true;
965
 
966
  if (h->root.root.string[0] == '$' && h->root.root.string[1] == '$')
967
    return false;
968
 
969
  if ((info->shared && !info->symbolic)
970
      || ((h->elf_link_hash_flags
971
           & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
972
          == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
973
    return true;
974
 
975
  return false;
976
}
977
 
978
/* Mark all funtions exported by this file so that we can later allocate
979
   entries in .opd for them.  */
980
 
981
static boolean
982
elf64_hppa_mark_exported_functions (h, data)
983
     struct elf_link_hash_entry *h;
984
     PTR data;
985
{
986
  struct bfd_link_info *info = (struct bfd_link_info *)data;
987
  struct elf64_hppa_link_hash_table *hppa_info;
988
 
989
  hppa_info = elf64_hppa_hash_table (info);
990
 
991
  if (h
992
      && (h->root.type == bfd_link_hash_defined
993
          || h->root.type == bfd_link_hash_defweak)
994
      && h->root.u.def.section->output_section != NULL
995
      && h->type == STT_FUNC)
996
    {
997
       struct elf64_hppa_dyn_hash_entry *dyn_h;
998
 
999
      /* Add this symbol to the PA64 linker hash table.  */
1000
      dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1001
                                          h->root.root.string, true, true);
1002
      BFD_ASSERT (dyn_h);
1003
      dyn_h->h = h;
1004
 
1005
      if (! hppa_info->opd_sec
1006
          && ! get_opd (hppa_info->root.dynobj, info, hppa_info))
1007
        return false;
1008
 
1009
      dyn_h->want_opd = 1;
1010
      /* Put a flag here for output_symbol_hook.  */
1011
      dyn_h->st_shndx = -1;
1012
      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1013
    }
1014
 
1015
  return true;
1016
}
1017
 
1018
/* Allocate space for a DLT entry.  */
1019
 
1020
static boolean
1021
allocate_global_data_dlt (dyn_h, data)
1022
     struct elf64_hppa_dyn_hash_entry *dyn_h;
1023
     PTR data;
1024
{
1025
  struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1026
 
1027
  if (dyn_h->want_dlt)
1028
    {
1029
      struct elf_link_hash_entry *h = dyn_h->h;
1030
 
1031
      if (x->info->shared)
1032
        {
1033
          /* Possibly add the symbol to the local dynamic symbol
1034
             table since we might need to create a dynamic relocation
1035
             against it.  */
1036
          if (! h
1037
              || (h && h->dynindx == -1))
1038
            {
1039
              bfd *owner;
1040
              owner = (h ? h->root.u.def.section->owner : dyn_h->owner);
1041
 
1042
              if (!_bfd_elf64_link_record_local_dynamic_symbol
1043
                    (x->info, owner, dyn_h->sym_indx))
1044
                return false;
1045
            }
1046
        }
1047
 
1048
      dyn_h->dlt_offset = x->ofs;
1049
      x->ofs += DLT_ENTRY_SIZE;
1050
    }
1051
  return true;
1052
}
1053
 
1054
/* Allocate space for a DLT.PLT entry.  */
1055
 
1056
static boolean
1057
allocate_global_data_plt (dyn_h, data)
1058
     struct elf64_hppa_dyn_hash_entry *dyn_h;
1059
     PTR data;
1060
{
1061
  struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1062
 
1063
  if (dyn_h->want_plt
1064
      && elf64_hppa_dynamic_symbol_p (dyn_h->h, x->info)
1065
      && !((dyn_h->h->root.type == bfd_link_hash_defined
1066
            || dyn_h->h->root.type == bfd_link_hash_defweak)
1067
           && dyn_h->h->root.u.def.section->output_section != NULL))
1068
    {
1069
      dyn_h->plt_offset = x->ofs;
1070
      x->ofs += PLT_ENTRY_SIZE;
1071
      if (dyn_h->plt_offset < 0x2000)
1072
        elf64_hppa_hash_table (x->info)->gp_offset = dyn_h->plt_offset;
1073
    }
1074
  else
1075
    dyn_h->want_plt = 0;
1076
 
1077
  return true;
1078
}
1079
 
1080
/* Allocate space for a STUB entry.  */
1081
 
1082
static boolean
1083
allocate_global_data_stub (dyn_h, data)
1084
     struct elf64_hppa_dyn_hash_entry *dyn_h;
1085
     PTR data;
1086
{
1087
  struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1088
 
1089
  if (dyn_h->want_stub
1090
      && elf64_hppa_dynamic_symbol_p (dyn_h->h, x->info)
1091
      && !((dyn_h->h->root.type == bfd_link_hash_defined
1092
            || dyn_h->h->root.type == bfd_link_hash_defweak)
1093
           && dyn_h->h->root.u.def.section->output_section != NULL))
1094
    {
1095
      dyn_h->stub_offset = x->ofs;
1096
      x->ofs += sizeof (plt_stub);
1097
    }
1098
  else
1099
    dyn_h->want_stub = 0;
1100
  return true;
1101
}
1102
 
1103
/* Allocate space for a FPTR entry.  */
1104
 
1105
static boolean
1106
allocate_global_data_opd (dyn_h, data)
1107
     struct elf64_hppa_dyn_hash_entry *dyn_h;
1108
     PTR data;
1109
{
1110
  struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1111
 
1112
  if (dyn_h->want_opd)
1113
    {
1114
      struct elf_link_hash_entry *h = dyn_h->h;
1115
 
1116
      if (h)
1117
        while (h->root.type == bfd_link_hash_indirect
1118
               || h->root.type == bfd_link_hash_warning)
1119
          h = (struct elf_link_hash_entry *) h->root.u.i.link;
1120
 
1121
      /* We never need an opd entry for a symbol which is not
1122
         defined by this output file.  */
1123
      if (h && h->root.type == bfd_link_hash_undefined)
1124
        dyn_h->want_opd = 0;
1125
 
1126
      /* If we are creating a shared library, took the address of a local
1127
         function or might export this function from this object file, then
1128
         we have to create an opd descriptor.  */
1129
      else if (x->info->shared
1130
               || h == NULL
1131
               || h->dynindx == -1
1132
               || ((h->root.type == bfd_link_hash_defined
1133
                    || h->root.type == bfd_link_hash_defweak)
1134
                   && h->root.u.def.section->output_section != NULL))
1135
        {
1136
          /* If we are creating a shared library, then we will have to
1137
             create a runtime relocation for the symbol to properly
1138
             initialize the .opd entry.  Make sure the symbol gets
1139
             added to the dynamic symbol table.  */
1140
          if (x->info->shared
1141
              && (h == NULL || (h->dynindx == -1)))
1142
            {
1143
              bfd *owner;
1144
              owner = (h ? h->root.u.def.section->owner : dyn_h->owner);
1145
 
1146
              if (!_bfd_elf64_link_record_local_dynamic_symbol
1147
                    (x->info, owner, dyn_h->sym_indx))
1148
                return false;
1149
            }
1150
 
1151
          /* This may not be necessary or desirable anymore now that
1152
             we have some support for dealing with section symbols
1153
             in dynamic relocs.  But name munging does make the result
1154
             much easier to debug.  ie, the EPLT reloc will reference
1155
             a symbol like .foobar, instead of .text + offset.  */
1156
          if (x->info->shared && h)
1157
            {
1158
              char *new_name;
1159
              struct elf_link_hash_entry *nh;
1160
 
1161
              new_name = alloca (strlen (h->root.root.string) + 2);
1162
              new_name[0] = '.';
1163
              strcpy (new_name + 1, h->root.root.string);
1164
 
1165
              nh = elf_link_hash_lookup (elf_hash_table (x->info),
1166
                                         new_name, true, true, true);
1167
 
1168
              nh->root.type = h->root.type;
1169
              nh->root.u.def.value = h->root.u.def.value;
1170
              nh->root.u.def.section = h->root.u.def.section;
1171
 
1172
              if (! bfd_elf64_link_record_dynamic_symbol (x->info, nh))
1173
                return false;
1174
 
1175
             }
1176
          dyn_h->opd_offset = x->ofs;
1177
          x->ofs += OPD_ENTRY_SIZE;
1178
        }
1179
 
1180
      /* Otherwise we do not need an opd entry.  */
1181
      else
1182
        dyn_h->want_opd = 0;
1183
    }
1184
  return true;
1185
}
1186
 
1187
/* HP requires the EI_OSABI field to be filled in.  The assignment to
1188
   EI_ABIVERSION may not be strictly necessary.  */
1189
 
1190
static void
1191
elf64_hppa_post_process_headers (abfd, link_info)
1192
     bfd * abfd;
1193
     struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
1194
{
1195
  Elf_Internal_Ehdr * i_ehdrp;
1196
 
1197
  i_ehdrp = elf_elfheader (abfd);
1198
 
1199
  if (strcmp (bfd_get_target (abfd), "elf64-hppa-linux") == 0)
1200
    {
1201
      i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX;
1202
    }
1203
  else
1204
    {
1205
      i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX;
1206
      i_ehdrp->e_ident[EI_ABIVERSION] = 1;
1207
    }
1208
}
1209
 
1210
/* Create function descriptor section (.opd).  This section is called .opd
1211
   because it contains "official prodecure descriptors".  The "official"
1212
   refers to the fact that these descriptors are used when taking the address
1213
   of a procedure, thus ensuring a unique address for each procedure.  */
1214
 
1215
static boolean
1216
get_opd (abfd, info, hppa_info)
1217
     bfd *abfd;
1218
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
1219
     struct elf64_hppa_link_hash_table *hppa_info;
1220
{
1221
  asection *opd;
1222
  bfd *dynobj;
1223
 
1224
  opd = hppa_info->opd_sec;
1225
  if (!opd)
1226
    {
1227
      dynobj = hppa_info->root.dynobj;
1228
      if (!dynobj)
1229
        hppa_info->root.dynobj = dynobj = abfd;
1230
 
1231
      opd = bfd_make_section (dynobj, ".opd");
1232
      if (!opd
1233
          || !bfd_set_section_flags (dynobj, opd,
1234
                                     (SEC_ALLOC
1235
                                      | SEC_LOAD
1236
                                      | SEC_HAS_CONTENTS
1237
                                      | SEC_IN_MEMORY
1238
                                      | SEC_LINKER_CREATED))
1239
          || !bfd_set_section_alignment (abfd, opd, 3))
1240
        {
1241
          BFD_ASSERT (0);
1242
          return false;
1243
        }
1244
 
1245
      hppa_info->opd_sec = opd;
1246
    }
1247
 
1248
  return true;
1249
}
1250
 
1251
/* Create the PLT section.  */
1252
 
1253
static boolean
1254
get_plt (abfd, info, hppa_info)
1255
     bfd *abfd;
1256
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
1257
     struct elf64_hppa_link_hash_table *hppa_info;
1258
{
1259
  asection *plt;
1260
  bfd *dynobj;
1261
 
1262
  plt = hppa_info->plt_sec;
1263
  if (!plt)
1264
    {
1265
      dynobj = hppa_info->root.dynobj;
1266
      if (!dynobj)
1267
        hppa_info->root.dynobj = dynobj = abfd;
1268
 
1269
      plt = bfd_make_section (dynobj, ".plt");
1270
      if (!plt
1271
          || !bfd_set_section_flags (dynobj, plt,
1272
                                     (SEC_ALLOC
1273
                                      | SEC_LOAD
1274
                                      | SEC_HAS_CONTENTS
1275
                                      | SEC_IN_MEMORY
1276
                                      | SEC_LINKER_CREATED))
1277
          || !bfd_set_section_alignment (abfd, plt, 3))
1278
        {
1279
          BFD_ASSERT (0);
1280
          return false;
1281
        }
1282
 
1283
      hppa_info->plt_sec = plt;
1284
    }
1285
 
1286
  return true;
1287
}
1288
 
1289
/* Create the DLT section.  */
1290
 
1291
static boolean
1292
get_dlt (abfd, info, hppa_info)
1293
     bfd *abfd;
1294
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
1295
     struct elf64_hppa_link_hash_table *hppa_info;
1296
{
1297
  asection *dlt;
1298
  bfd *dynobj;
1299
 
1300
  dlt = hppa_info->dlt_sec;
1301
  if (!dlt)
1302
    {
1303
      dynobj = hppa_info->root.dynobj;
1304
      if (!dynobj)
1305
        hppa_info->root.dynobj = dynobj = abfd;
1306
 
1307
      dlt = bfd_make_section (dynobj, ".dlt");
1308
      if (!dlt
1309
          || !bfd_set_section_flags (dynobj, dlt,
1310
                                     (SEC_ALLOC
1311
                                      | SEC_LOAD
1312
                                      | SEC_HAS_CONTENTS
1313
                                      | SEC_IN_MEMORY
1314
                                      | SEC_LINKER_CREATED))
1315
          || !bfd_set_section_alignment (abfd, dlt, 3))
1316
        {
1317
          BFD_ASSERT (0);
1318
          return false;
1319
        }
1320
 
1321
      hppa_info->dlt_sec = dlt;
1322
    }
1323
 
1324
  return true;
1325
}
1326
 
1327
/* Create the stubs section.  */
1328
 
1329
static boolean
1330
get_stub (abfd, info, hppa_info)
1331
     bfd *abfd;
1332
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
1333
     struct elf64_hppa_link_hash_table *hppa_info;
1334
{
1335
  asection *stub;
1336
  bfd *dynobj;
1337
 
1338
  stub = hppa_info->stub_sec;
1339
  if (!stub)
1340
    {
1341
      dynobj = hppa_info->root.dynobj;
1342
      if (!dynobj)
1343
        hppa_info->root.dynobj = dynobj = abfd;
1344
 
1345
      stub = bfd_make_section (dynobj, ".stub");
1346
      if (!stub
1347
          || !bfd_set_section_flags (dynobj, stub,
1348
                                     (SEC_ALLOC
1349
                                      | SEC_LOAD
1350
                                      | SEC_HAS_CONTENTS
1351
                                      | SEC_IN_MEMORY
1352
                                      | SEC_READONLY
1353
                                      | SEC_LINKER_CREATED))
1354
          || !bfd_set_section_alignment (abfd, stub, 3))
1355
        {
1356
          BFD_ASSERT (0);
1357
          return false;
1358
        }
1359
 
1360
      hppa_info->stub_sec = stub;
1361
    }
1362
 
1363
  return true;
1364
}
1365
 
1366
/* Create sections necessary for dynamic linking.  This is only a rough
1367
   cut and will likely change as we learn more about the somewhat
1368
   unusual dynamic linking scheme HP uses.
1369
 
1370
   .stub:
1371
        Contains code to implement cross-space calls.  The first time one
1372
        of the stubs is used it will call into the dynamic linker, later
1373
        calls will go straight to the target.
1374
 
1375
        The only stub we support right now looks like
1376
 
1377
        ldd OFFSET(%dp),%r1
1378
        bve %r0(%r1)
1379
        ldd OFFSET+8(%dp),%dp
1380
 
1381
        Other stubs may be needed in the future.  We may want the remove
1382
        the break/nop instruction.  It is only used right now to keep the
1383
        offset of a .plt entry and a .stub entry in sync.
1384
 
1385
   .dlt:
1386
        This is what most people call the .got.  HP used a different name.
1387
        Losers.
1388
 
1389
   .rela.dlt:
1390
        Relocations for the DLT.
1391
 
1392
   .plt:
1393
        Function pointers as address,gp pairs.
1394
 
1395
   .rela.plt:
1396
        Should contain dynamic IPLT (and EPLT?) relocations.
1397
 
1398
   .opd:
1399
        FPTRS
1400
 
1401
   .rela.opd:
1402
        EPLT relocations for symbols exported from shared libraries.  */
1403
 
1404
static boolean
1405
elf64_hppa_create_dynamic_sections (abfd, info)
1406
     bfd *abfd;
1407
     struct bfd_link_info *info;
1408
{
1409
  asection *s;
1410
 
1411
  if (! get_stub (abfd, info, elf64_hppa_hash_table (info)))
1412
    return false;
1413
 
1414
  if (! get_dlt (abfd, info, elf64_hppa_hash_table (info)))
1415
    return false;
1416
 
1417
  if (! get_plt (abfd, info, elf64_hppa_hash_table (info)))
1418
    return false;
1419
 
1420
  if (! get_opd (abfd, info, elf64_hppa_hash_table (info)))
1421
    return false;
1422
 
1423
  s = bfd_make_section(abfd, ".rela.dlt");
1424
  if (s == NULL
1425
      || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1426
                                           | SEC_HAS_CONTENTS
1427
                                           | SEC_IN_MEMORY
1428
                                           | SEC_READONLY
1429
                                           | SEC_LINKER_CREATED))
1430
      || !bfd_set_section_alignment (abfd, s, 3))
1431
    return false;
1432
  elf64_hppa_hash_table (info)->dlt_rel_sec = s;
1433
 
1434
  s = bfd_make_section(abfd, ".rela.plt");
1435
  if (s == NULL
1436
      || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1437
                                           | SEC_HAS_CONTENTS
1438
                                           | SEC_IN_MEMORY
1439
                                           | SEC_READONLY
1440
                                           | SEC_LINKER_CREATED))
1441
      || !bfd_set_section_alignment (abfd, s, 3))
1442
    return false;
1443
  elf64_hppa_hash_table (info)->plt_rel_sec = s;
1444
 
1445
  s = bfd_make_section(abfd, ".rela.data");
1446
  if (s == NULL
1447
      || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1448
                                           | SEC_HAS_CONTENTS
1449
                                           | SEC_IN_MEMORY
1450
                                           | SEC_READONLY
1451
                                           | SEC_LINKER_CREATED))
1452
      || !bfd_set_section_alignment (abfd, s, 3))
1453
    return false;
1454
  elf64_hppa_hash_table (info)->other_rel_sec = s;
1455
 
1456
  s = bfd_make_section(abfd, ".rela.opd");
1457
  if (s == NULL
1458
      || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1459
                                           | SEC_HAS_CONTENTS
1460
                                           | SEC_IN_MEMORY
1461
                                           | SEC_READONLY
1462
                                           | SEC_LINKER_CREATED))
1463
      || !bfd_set_section_alignment (abfd, s, 3))
1464
    return false;
1465
  elf64_hppa_hash_table (info)->opd_rel_sec = s;
1466
 
1467
  return true;
1468
}
1469
 
1470
/* Allocate dynamic relocations for those symbols that turned out
1471
   to be dynamic.  */
1472
 
1473
static boolean
1474
allocate_dynrel_entries (dyn_h, data)
1475
     struct elf64_hppa_dyn_hash_entry *dyn_h;
1476
     PTR data;
1477
{
1478
  struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1479
  struct elf64_hppa_link_hash_table *hppa_info;
1480
  struct elf64_hppa_dyn_reloc_entry *rent;
1481
  boolean dynamic_symbol, shared;
1482
 
1483
  hppa_info = elf64_hppa_hash_table (x->info);
1484
  dynamic_symbol = elf64_hppa_dynamic_symbol_p (dyn_h->h, x->info);
1485
  shared = x->info->shared;
1486
 
1487
  /* We may need to allocate relocations for a non-dynamic symbol
1488
     when creating a shared library.  */
1489
  if (!dynamic_symbol && !shared)
1490
    return true;
1491
 
1492
  /* Take care of the normal data relocations.  */
1493
 
1494
  for (rent = dyn_h->reloc_entries; rent; rent = rent->next)
1495
    {
1496
      switch (rent->type)
1497
        {
1498
        case R_PARISC_FPTR64:
1499
          /* Allocate one iff we are not building a shared library and
1500
             !want_opd, which by this point will be true only if we're
1501
             actually allocating one statically in the main executable.  */
1502
          if (!x->info->shared && dyn_h->want_opd)
1503
            continue;
1504
          break;
1505
        }
1506
      hppa_info->other_rel_sec->_raw_size += sizeof (Elf64_External_Rela);
1507
 
1508
      /* Make sure this symbol gets into the dynamic symbol table if it is
1509
         not already recorded.  ?!? This should not be in the loop since
1510
         the symbol need only be added once.  */
1511
      if (dyn_h->h == 0 || dyn_h->h->dynindx == -1)
1512
        if (!_bfd_elf64_link_record_local_dynamic_symbol
1513
            (x->info, rent->sec->owner, dyn_h->sym_indx))
1514
          return false;
1515
    }
1516
 
1517
  /* Take care of the GOT and PLT relocations.  */
1518
 
1519
  if ((dynamic_symbol || shared) && dyn_h->want_dlt)
1520
    hppa_info->dlt_rel_sec->_raw_size += sizeof (Elf64_External_Rela);
1521
 
1522
  /* If we are building a shared library, then every symbol that has an
1523
     opd entry will need an EPLT relocation to relocate the symbol's address
1524
     and __gp value based on the runtime load address.  */
1525
  if (shared && dyn_h->want_opd)
1526
    hppa_info->opd_rel_sec->_raw_size += sizeof (Elf64_External_Rela);
1527
 
1528
  if (dyn_h->want_plt && dynamic_symbol)
1529
    {
1530
      bfd_size_type t = 0;
1531
 
1532
      /* Dynamic symbols get one IPLT relocation.  Local symbols in
1533
         shared libraries get two REL relocations.  Local symbols in
1534
         main applications get nothing.  */
1535
      if (dynamic_symbol)
1536
        t = sizeof (Elf64_External_Rela);
1537
      else if (shared)
1538
        t = 2 * sizeof (Elf64_External_Rela);
1539
 
1540
      hppa_info->plt_rel_sec->_raw_size += t;
1541
    }
1542
 
1543
  return true;
1544
}
1545
 
1546
/* Adjust a symbol defined by a dynamic object and referenced by a
1547
   regular object.  */
1548
 
1549
static boolean
1550
elf64_hppa_adjust_dynamic_symbol (info, h)
1551
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
1552
     struct elf_link_hash_entry *h;
1553
{
1554
  /* ??? Undefined symbols with PLT entries should be re-defined
1555
     to be the PLT entry.  */
1556
 
1557
  /* If this is a weak symbol, and there is a real definition, the
1558
     processor independent code will have arranged for us to see the
1559
     real definition first, and we can just use the same value.  */
1560
  if (h->weakdef != NULL)
1561
    {
1562
      BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1563
                  || h->weakdef->root.type == bfd_link_hash_defweak);
1564
      h->root.u.def.section = h->weakdef->root.u.def.section;
1565
      h->root.u.def.value = h->weakdef->root.u.def.value;
1566
      return true;
1567
    }
1568
 
1569
  /* If this is a reference to a symbol defined by a dynamic object which
1570
     is not a function, we might allocate the symbol in our .dynbss section
1571
     and allocate a COPY dynamic relocation.
1572
 
1573
     But PA64 code is canonically PIC, so as a rule we can avoid this sort
1574
     of hackery.  */
1575
 
1576
  return true;
1577
}
1578
 
1579
/* Set the final sizes of the dynamic sections and allocate memory for
1580
   the contents of our special sections.  */
1581
 
1582
static boolean
1583
elf64_hppa_size_dynamic_sections (output_bfd, info)
1584
     bfd *output_bfd;
1585
     struct bfd_link_info *info;
1586
{
1587
  bfd *dynobj;
1588
  asection *s;
1589
  boolean plt;
1590
  boolean relocs;
1591
  boolean reltext;
1592
  struct elf64_hppa_allocate_data data;
1593
  struct elf64_hppa_link_hash_table *hppa_info;
1594
 
1595
  hppa_info = elf64_hppa_hash_table (info);
1596
 
1597
  dynobj = elf_hash_table (info)->dynobj;
1598
  BFD_ASSERT (dynobj != NULL);
1599
 
1600
  if (elf_hash_table (info)->dynamic_sections_created)
1601
    {
1602
      /* Set the contents of the .interp section to the interpreter.  */
1603
      if (! info->shared)
1604
        {
1605
          s = bfd_get_section_by_name (dynobj, ".interp");
1606
          BFD_ASSERT (s != NULL);
1607
          s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1608
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1609
        }
1610
    }
1611
  else
1612
    {
1613
      /* We may have created entries in the .rela.got section.
1614
         However, if we are not creating the dynamic sections, we will
1615
         not actually use these entries.  Reset the size of .rela.dlt,
1616
         which will cause it to get stripped from the output file
1617
         below.  */
1618
      s = bfd_get_section_by_name (dynobj, ".rela.dlt");
1619
      if (s != NULL)
1620
        s->_raw_size = 0;
1621
    }
1622
 
1623
  /* Allocate the GOT entries.  */
1624
 
1625
  data.info = info;
1626
  if (elf64_hppa_hash_table (info)->dlt_sec)
1627
    {
1628
      data.ofs = 0x0;
1629
      elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1630
                                    allocate_global_data_dlt, &data);
1631
      hppa_info->dlt_sec->_raw_size = data.ofs;
1632
 
1633
      data.ofs = 0x0;
1634
      elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1635
                                    allocate_global_data_plt, &data);
1636
      hppa_info->plt_sec->_raw_size = data.ofs;
1637
 
1638
      data.ofs = 0x0;
1639
      elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1640
                                    allocate_global_data_stub, &data);
1641
      hppa_info->stub_sec->_raw_size = data.ofs;
1642
    }
1643
 
1644
  /* Mark each function this program exports so that we will allocate
1645
     space in the .opd section for each function's FPTR.
1646
 
1647
     We have to traverse the main linker hash table since we have to
1648
     find functions which may not have been mentioned in any relocs.  */
1649
  elf_link_hash_traverse (elf_hash_table (info),
1650
                          elf64_hppa_mark_exported_functions,
1651
                          info);
1652
 
1653
  /* Allocate space for entries in the .opd section.  */
1654
  if (elf64_hppa_hash_table (info)->opd_sec)
1655
    {
1656
      data.ofs = 0;
1657
      elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1658
                                    allocate_global_data_opd, &data);
1659
      hppa_info->opd_sec->_raw_size = data.ofs;
1660
    }
1661
 
1662
  /* Now allocate space for dynamic relocations, if necessary.  */
1663
  if (hppa_info->root.dynamic_sections_created)
1664
    elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1665
                                  allocate_dynrel_entries, &data);
1666
 
1667
  /* The sizes of all the sections are set.  Allocate memory for them.  */
1668
  plt = false;
1669
  relocs = false;
1670
  reltext = false;
1671
  for (s = dynobj->sections; s != NULL; s = s->next)
1672
    {
1673
      const char *name;
1674
      boolean strip;
1675
 
1676
      if ((s->flags & SEC_LINKER_CREATED) == 0)
1677
        continue;
1678
 
1679
      /* It's OK to base decisions on the section name, because none
1680
         of the dynobj section names depend upon the input files.  */
1681
      name = bfd_get_section_name (dynobj, s);
1682
 
1683
      strip = 0;
1684
 
1685
      if (strcmp (name, ".plt") == 0)
1686
        {
1687
          if (s->_raw_size == 0)
1688
            {
1689
              /* Strip this section if we don't need it; see the
1690
                 comment below.  */
1691
              strip = true;
1692
            }
1693
          else
1694
            {
1695
              /* Remember whether there is a PLT.  */
1696
              plt = true;
1697
            }
1698
        }
1699
      else if (strcmp (name, ".dlt") == 0)
1700
        {
1701
          if (s->_raw_size == 0)
1702
            {
1703
              /* Strip this section if we don't need it; see the
1704
                 comment below.  */
1705
              strip = true;
1706
            }
1707
        }
1708
      else if (strcmp (name, ".opd") == 0)
1709
        {
1710
          if (s->_raw_size == 0)
1711
            {
1712
              /* Strip this section if we don't need it; see the
1713
                 comment below.  */
1714
              strip = true;
1715
            }
1716
        }
1717
      else if (strncmp (name, ".rela", 4) == 0)
1718
        {
1719
          if (s->_raw_size == 0)
1720
            {
1721
              /* If we don't need this section, strip it from the
1722
                 output file.  This is mostly to handle .rela.bss and
1723
                 .rela.plt.  We must create both sections in
1724
                 create_dynamic_sections, because they must be created
1725
                 before the linker maps input sections to output
1726
                 sections.  The linker does that before
1727
                 adjust_dynamic_symbol is called, and it is that
1728
                 function which decides whether anything needs to go
1729
                 into these sections.  */
1730
              strip = true;
1731
            }
1732
          else
1733
            {
1734
              asection *target;
1735
 
1736
              /* Remember whether there are any reloc sections other
1737
                 than .rela.plt.  */
1738
              if (strcmp (name, ".rela.plt") != 0)
1739
                {
1740
                  const char *outname;
1741
 
1742
                  relocs = true;
1743
 
1744
                  /* If this relocation section applies to a read only
1745
                     section, then we probably need a DT_TEXTREL
1746
                     entry.  The entries in the .rela.plt section
1747
                     really apply to the .got section, which we
1748
                     created ourselves and so know is not readonly.  */
1749
                  outname = bfd_get_section_name (output_bfd,
1750
                                                  s->output_section);
1751
                  target = bfd_get_section_by_name (output_bfd, outname + 4);
1752
                  if (target != NULL
1753
                      && (target->flags & SEC_READONLY) != 0
1754
                      && (target->flags & SEC_ALLOC) != 0)
1755
                    reltext = true;
1756
                }
1757
 
1758
              /* We use the reloc_count field as a counter if we need
1759
                 to copy relocs into the output file.  */
1760
              s->reloc_count = 0;
1761
            }
1762
        }
1763
      else if (strncmp (name, ".dlt", 4) != 0
1764
               && strcmp (name, ".stub") != 0
1765
               && strcmp (name, ".got") != 0)
1766
        {
1767
          /* It's not one of our sections, so don't allocate space.  */
1768
          continue;
1769
        }
1770
 
1771
      if (strip)
1772
        {
1773
          _bfd_strip_section_from_output (info, s);
1774
          continue;
1775
        }
1776
 
1777
      /* Allocate memory for the section contents if it has not
1778
         been allocated already.  We use bfd_zalloc here in case
1779
         unused entries are not reclaimed before the section's
1780
         contents are written out.  This should not happen, but this
1781
         way if it does, we get a R_PARISC_NONE reloc instead of
1782
         garbage.  */
1783
      if (s->contents == NULL)
1784
        {
1785
          s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1786
          if (s->contents == NULL && s->_raw_size != 0)
1787
            return false;
1788
        }
1789
    }
1790
 
1791
  if (elf_hash_table (info)->dynamic_sections_created)
1792
    {
1793
      /* Always create a DT_PLTGOT.  It actually has nothing to do with
1794
         the PLT, it is how we communicate the __gp value of a load
1795
         module to the dynamic linker.  */
1796
      if (! bfd_elf64_add_dynamic_entry (info, DT_HP_DLD_FLAGS, 0)
1797
          || ! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
1798
        return false;
1799
 
1800
      /* Add some entries to the .dynamic section.  We fill in the
1801
         values later, in elf64_hppa_finish_dynamic_sections, but we
1802
         must add the entries now so that we get the correct size for
1803
         the .dynamic section.  The DT_DEBUG entry is filled in by the
1804
         dynamic linker and used by the debugger.  */
1805
      if (! info->shared)
1806
        {
1807
          if (! bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0)
1808
              || ! bfd_elf64_add_dynamic_entry (info, DT_HP_DLD_HOOK, 0)
1809
              || ! bfd_elf64_add_dynamic_entry (info, DT_HP_LOAD_MAP, 0))
1810
            return false;
1811
        }
1812
 
1813
      if (plt)
1814
        {
1815
          if (! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1816
              || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
1817
              || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
1818
            return false;
1819
        }
1820
 
1821
      if (relocs)
1822
        {
1823
          if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
1824
              || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
1825
              || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
1826
                                                sizeof (Elf64_External_Rela)))
1827
            return false;
1828
        }
1829
 
1830
      if (reltext)
1831
        {
1832
          if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
1833
            return false;
1834
          info->flags |= DF_TEXTREL;
1835
        }
1836
    }
1837
 
1838
  return true;
1839
}
1840
 
1841
/* Called after we have output the symbol into the dynamic symbol
1842
   table, but before we output the symbol into the normal symbol
1843
   table.
1844
 
1845
   For some symbols we had to change their address when outputting
1846
   the dynamic symbol table.  We undo that change here so that
1847
   the symbols have their expected value in the normal symbol
1848
   table.  Ick.  */
1849
 
1850
static boolean
1851
elf64_hppa_link_output_symbol_hook (abfd, info, name, sym, input_sec)
1852
     bfd *abfd ATTRIBUTE_UNUSED;
1853
     struct bfd_link_info *info;
1854
     const char *name;
1855
     Elf_Internal_Sym *sym;
1856
     asection *input_sec ATTRIBUTE_UNUSED;
1857
{
1858
  struct elf64_hppa_link_hash_table *hppa_info;
1859
  struct elf64_hppa_dyn_hash_entry *dyn_h;
1860
 
1861
  /* We may be called with the file symbol or section symbols.
1862
     They never need munging, so it is safe to ignore them.  */
1863
  if (!name)
1864
    return true;
1865
 
1866
  /* Get the PA dyn_symbol (if any) associated with NAME.  */
1867
  hppa_info = elf64_hppa_hash_table (info);
1868
  dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1869
                                      name, false, false);
1870
 
1871
  /* Function symbols for which we created .opd entries *may* have been
1872
     munged by finish_dynamic_symbol and have to be un-munged here.
1873
 
1874
     Note that finish_dynamic_symbol sometimes turns dynamic symbols
1875
     into non-dynamic ones, so we initialize st_shndx to -1 in
1876
     mark_exported_functions and check to see if it was overwritten
1877
     here instead of just checking dyn_h->h->dynindx.  */
1878
  if (dyn_h && dyn_h->want_opd && dyn_h->st_shndx != -1)
1879
    {
1880
      /* Restore the saved value and section index.  */
1881
      sym->st_value = dyn_h->st_value;
1882
      sym->st_shndx = dyn_h->st_shndx;
1883
    }
1884
 
1885
  return true;
1886
}
1887
 
1888
/* Finish up dynamic symbol handling.  We set the contents of various
1889
   dynamic sections here.  */
1890
 
1891
static boolean
1892
elf64_hppa_finish_dynamic_symbol (output_bfd, info, h, sym)
1893
     bfd *output_bfd;
1894
     struct bfd_link_info *info;
1895
     struct elf_link_hash_entry *h;
1896
     Elf_Internal_Sym *sym;
1897
{
1898
  asection *stub, *splt, *sdlt, *sopd, *spltrel, *sdltrel;
1899
  struct elf64_hppa_link_hash_table *hppa_info;
1900
  struct elf64_hppa_dyn_hash_entry *dyn_h;
1901
 
1902
  hppa_info = elf64_hppa_hash_table (info);
1903
  dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1904
                                      h->root.root.string, false, false);
1905
 
1906
  stub = hppa_info->stub_sec;
1907
  splt = hppa_info->plt_sec;
1908
  sdlt = hppa_info->dlt_sec;
1909
  sopd = hppa_info->opd_sec;
1910
  spltrel = hppa_info->plt_rel_sec;
1911
  sdltrel = hppa_info->dlt_rel_sec;
1912
 
1913
  BFD_ASSERT (stub != NULL && splt != NULL
1914
              && sopd != NULL && sdlt != NULL)
1915
 
1916
  /* Incredible.  It is actually necessary to NOT use the symbol's real
1917
     value when building the dynamic symbol table for a shared library.
1918
     At least for symbols that refer to functions.
1919
 
1920
     We will store a new value and section index into the symbol long
1921
     enough to output it into the dynamic symbol table, then we restore
1922
     the original values (in elf64_hppa_link_output_symbol_hook).  */
1923
  if (dyn_h && dyn_h->want_opd)
1924
    {
1925
      /* Save away the original value and section index so that we
1926
         can restore them later.  */
1927
      dyn_h->st_value = sym->st_value;
1928
      dyn_h->st_shndx = sym->st_shndx;
1929
 
1930
      /* For the dynamic symbol table entry, we want the value to be
1931
         address of this symbol's entry within the .opd section.  */
1932
      sym->st_value = (dyn_h->opd_offset
1933
                       + sopd->output_offset
1934
                       + sopd->output_section->vma);
1935
      sym->st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
1936
                                                         sopd->output_section);
1937
    }
1938
 
1939
  /* Initialize a .plt entry if requested.  */
1940
  if (dyn_h && dyn_h->want_plt
1941
      && elf64_hppa_dynamic_symbol_p (dyn_h->h, info))
1942
    {
1943
      bfd_vma value;
1944
      Elf_Internal_Rela rel;
1945
 
1946
      /* We do not actually care about the value in the PLT entry
1947
         if we are creating a shared library and the symbol is
1948
         still undefined, we create a dynamic relocation to fill
1949
         in the correct value.  */
1950
      if (info->shared && h->root.type == bfd_link_hash_undefined)
1951
        value = 0;
1952
      else
1953
        value = (h->root.u.def.value + h->root.u.def.section->vma);
1954
 
1955
      /* Fill in the entry in the procedure linkage table.
1956
 
1957
         The format of a plt entry is
1958
         <funcaddr> <__gp>.
1959
 
1960
         plt_offset is the offset within the PLT section at which to
1961
         install the PLT entry.
1962
 
1963
         We are modifying the in-memory PLT contents here, so we do not add
1964
         in the output_offset of the PLT section.  */
1965
 
1966
      bfd_put_64 (splt->owner, value, splt->contents + dyn_h->plt_offset);
1967
      value = _bfd_get_gp_value (splt->output_section->owner);
1968
      bfd_put_64 (splt->owner, value, splt->contents + dyn_h->plt_offset + 0x8);
1969
 
1970
      /* Create a dynamic IPLT relocation for this entry.
1971
 
1972
         We are creating a relocation in the output file's PLT section,
1973
         which is included within the DLT secton.  So we do need to include
1974
         the PLT's output_offset in the computation of the relocation's
1975
         address.  */
1976
      rel.r_offset = (dyn_h->plt_offset + splt->output_offset
1977
                      + splt->output_section->vma);
1978
      rel.r_info = ELF64_R_INFO (h->dynindx, R_PARISC_IPLT);
1979
      rel.r_addend = 0;
1980
 
1981
      bfd_elf64_swap_reloca_out (splt->output_section->owner, &rel,
1982
                                 (((Elf64_External_Rela *)
1983
                                   spltrel->contents)
1984
                                  + spltrel->reloc_count));
1985
      spltrel->reloc_count++;
1986
    }
1987
 
1988
  /* Initialize an external call stub entry if requested.  */
1989
  if (dyn_h && dyn_h->want_stub
1990
      && elf64_hppa_dynamic_symbol_p (dyn_h->h, info))
1991
    {
1992
      bfd_vma value;
1993
      int insn;
1994
      unsigned int max_offset;
1995
 
1996
      /* Install the generic stub template.
1997
 
1998
         We are modifying the contents of the stub section, so we do not
1999
         need to include the stub section's output_offset here.  */
2000
      memcpy (stub->contents + dyn_h->stub_offset, plt_stub, sizeof (plt_stub));
2001
 
2002
      /* Fix up the first ldd instruction.
2003
 
2004
         We are modifying the contents of the STUB section in memory,
2005
         so we do not need to include its output offset in this computation.
2006
 
2007
         Note the plt_offset value is the value of the PLT entry relative to
2008
         the start of the PLT section.  These instructions will reference
2009
         data relative to the value of __gp, which may not necessarily have
2010
         the same address as the start of the PLT section.
2011
 
2012
         gp_offset contains the offset of __gp within the PLT section.  */
2013
      value = dyn_h->plt_offset - hppa_info->gp_offset;
2014
 
2015
      insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset);
2016
      if (output_bfd->arch_info->mach >= 25)
2017
        {
2018
          /* Wide mode allows 16 bit offsets.  */
2019
          max_offset = 32768;
2020
          insn &= ~ 0xfff1;
2021
          insn |= re_assemble_16 (value);
2022
        }
2023
      else
2024
        {
2025
          max_offset = 8192;
2026
          insn &= ~ 0x3ff1;
2027
          insn |= re_assemble_14 (value);
2028
        }
2029
 
2030
      if ((value & 7) || value + max_offset >= 2*max_offset - 8)
2031
        {
2032
          (*_bfd_error_handler) (_("stub entry for %s cannot load .plt, dp offset = %ld"),
2033
                                 dyn_h->root.string,
2034
                                 (long) value);
2035
          return false;
2036
        }
2037
 
2038
      bfd_put_32 (stub->owner, insn,
2039
                  stub->contents + dyn_h->stub_offset);
2040
 
2041
      /* Fix up the second ldd instruction.  */
2042
      value += 8;
2043
      insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset + 8);
2044
      if (output_bfd->arch_info->mach >= 25)
2045
        {
2046
          insn &= ~ 0xfff1;
2047
          insn |= re_assemble_16 (value);
2048
        }
2049
      else
2050
        {
2051
          insn &= ~ 0x3ff1;
2052
          insn |= re_assemble_14 (value);
2053
        }
2054
      bfd_put_32 (stub->owner, insn,
2055
                  stub->contents + dyn_h->stub_offset + 8);
2056
    }
2057
 
2058
  /* Millicode symbols should not be put in the dynamic
2059
     symbol table under any circumstances.  */
2060
  if (ELF_ST_TYPE (sym->st_info) == STT_PARISC_MILLI)
2061
    h->dynindx = -1;
2062
 
2063
  return true;
2064
}
2065
 
2066
/* The .opd section contains FPTRs for each function this file
2067
   exports.  Initialize the FPTR entries.  */
2068
 
2069
static boolean
2070
elf64_hppa_finalize_opd (dyn_h, data)
2071
     struct elf64_hppa_dyn_hash_entry *dyn_h;
2072
     PTR data;
2073
{
2074
  struct bfd_link_info *info = (struct bfd_link_info *)data;
2075
  struct elf64_hppa_link_hash_table *hppa_info;
2076
  struct elf_link_hash_entry *h = dyn_h->h;
2077
  asection *sopd;
2078
  asection *sopdrel;
2079
 
2080
  hppa_info = elf64_hppa_hash_table (info);
2081
  sopd = hppa_info->opd_sec;
2082
  sopdrel = hppa_info->opd_rel_sec;
2083
 
2084
  if (h && dyn_h && dyn_h->want_opd)
2085
    {
2086
      bfd_vma value;
2087
 
2088
      /* The first two words of an .opd entry are zero.
2089
 
2090
         We are modifying the contents of the OPD section in memory, so we
2091
         do not need to include its output offset in this computation.  */
2092
      memset (sopd->contents + dyn_h->opd_offset, 0, 16);
2093
 
2094
      value = (h->root.u.def.value
2095
               + h->root.u.def.section->output_section->vma
2096
               + h->root.u.def.section->output_offset);
2097
 
2098
      /* The next word is the address of the function.  */
2099
      bfd_put_64 (sopd->owner, value, sopd->contents + dyn_h->opd_offset + 16);
2100
 
2101
      /* The last word is our local __gp value.  */
2102
      value = _bfd_get_gp_value (sopd->output_section->owner);
2103
      bfd_put_64 (sopd->owner, value, sopd->contents + dyn_h->opd_offset + 24);
2104
    }
2105
 
2106
  /* If we are generating a shared library, we must generate EPLT relocations
2107
     for each entry in the .opd, even for static functions (they may have
2108
     had their address taken).  */
2109
  if (info->shared && dyn_h && dyn_h->want_opd)
2110
    {
2111
      Elf64_Internal_Rela rel;
2112
      int dynindx;
2113
 
2114
      /* We may need to do a relocation against a local symbol, in
2115
         which case we have to look up it's dynamic symbol index off
2116
         the local symbol hash table.  */
2117
      if (h && h->dynindx != -1)
2118
        dynindx = h->dynindx;
2119
      else
2120
        dynindx
2121
          = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner,
2122
                                                dyn_h->sym_indx);
2123
 
2124
      /* The offset of this relocation is the absolute address of the
2125
         .opd entry for this symbol.  */
2126
      rel.r_offset = (dyn_h->opd_offset + sopd->output_offset
2127
                      + sopd->output_section->vma);
2128
 
2129
      /* If H is non-null, then we have an external symbol.
2130
 
2131
         It is imperative that we use a different dynamic symbol for the
2132
         EPLT relocation if the symbol has global scope.
2133
 
2134
         In the dynamic symbol table, the function symbol will have a value
2135
         which is address of the function's .opd entry.
2136
 
2137
         Thus, we can not use that dynamic symbol for the EPLT relocation
2138
         (if we did, the data in the .opd would reference itself rather
2139
         than the actual address of the function).  Instead we have to use
2140
         a new dynamic symbol which has the same value as the original global
2141
         function symbol.
2142
 
2143
         We prefix the original symbol with a "." and use the new symbol in
2144
         the EPLT relocation.  This new symbol has already been recorded in
2145
         the symbol table, we just have to look it up and use it.
2146
 
2147
         We do not have such problems with static functions because we do
2148
         not make their addresses in the dynamic symbol table point to
2149
         the .opd entry.  Ultimately this should be safe since a static
2150
         function can not be directly referenced outside of its shared
2151
         library.
2152
 
2153
         We do have to play similar games for FPTR relocations in shared
2154
         libraries, including those for static symbols.  See the FPTR
2155
         handling in elf64_hppa_finalize_dynreloc.  */
2156
      if (h)
2157
        {
2158
          char *new_name;
2159
          struct elf_link_hash_entry *nh;
2160
 
2161
          new_name = alloca (strlen (h->root.root.string) + 2);
2162
          new_name[0] = '.';
2163
          strcpy (new_name + 1, h->root.root.string);
2164
 
2165
          nh = elf_link_hash_lookup (elf_hash_table (info),
2166
                                     new_name, false, false, false);
2167
 
2168
          /* All we really want from the new symbol is its dynamic
2169
             symbol index.  */
2170
          dynindx = nh->dynindx;
2171
        }
2172
 
2173
      rel.r_addend = 0;
2174
      rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_EPLT);
2175
 
2176
      bfd_elf64_swap_reloca_out (sopd->output_section->owner, &rel,
2177
                                 (((Elf64_External_Rela *)
2178
                                   sopdrel->contents)
2179
                                  + sopdrel->reloc_count));
2180
      sopdrel->reloc_count++;
2181
    }
2182
  return true;
2183
}
2184
 
2185
/* The .dlt section contains addresses for items referenced through the
2186
   dlt.  Note that we can have a DLTIND relocation for a local symbol, thus
2187
   we can not depend on finish_dynamic_symbol to initialize the .dlt.  */
2188
 
2189
static boolean
2190
elf64_hppa_finalize_dlt (dyn_h, data)
2191
     struct elf64_hppa_dyn_hash_entry *dyn_h;
2192
     PTR data;
2193
{
2194
  struct bfd_link_info *info = (struct bfd_link_info *)data;
2195
  struct elf64_hppa_link_hash_table *hppa_info;
2196
  asection *sdlt, *sdltrel;
2197
  struct elf_link_hash_entry *h = dyn_h->h;
2198
 
2199
  hppa_info = elf64_hppa_hash_table (info);
2200
 
2201
  sdlt = hppa_info->dlt_sec;
2202
  sdltrel = hppa_info->dlt_rel_sec;
2203
 
2204
  /* H/DYN_H may refer to a local variable and we know it's
2205
     address, so there is no need to create a relocation.  Just install
2206
     the proper value into the DLT, note this shortcut can not be
2207
     skipped when building a shared library.  */
2208
  if (! info->shared && h && dyn_h && dyn_h->want_dlt)
2209
    {
2210
      bfd_vma value;
2211
 
2212
      /* If we had an LTOFF_FPTR style relocation we want the DLT entry
2213
         to point to the FPTR entry in the .opd section.
2214
 
2215
         We include the OPD's output offset in this computation as
2216
         we are referring to an absolute address in the resulting
2217
         object file.  */
2218
      if (dyn_h->want_opd)
2219
        {
2220
          value = (dyn_h->opd_offset
2221
                   + hppa_info->opd_sec->output_offset
2222
                   + hppa_info->opd_sec->output_section->vma);
2223
        }
2224
      else
2225
        {
2226
          value = (h->root.u.def.value
2227
                   + h->root.u.def.section->output_offset);
2228
 
2229
          if (h->root.u.def.section->output_section)
2230
            value += h->root.u.def.section->output_section->vma;
2231
          else
2232
            value += h->root.u.def.section->vma;
2233
        }
2234
 
2235
      /* We do not need to include the output offset of the DLT section
2236
         here because we are modifying the in-memory contents.  */
2237
      bfd_put_64 (sdlt->owner, value, sdlt->contents + dyn_h->dlt_offset);
2238
    }
2239
 
2240
  /* Create a relocation for the DLT entry assocated with this symbol.
2241
     When building a shared library the symbol does not have to be dynamic.  */
2242
  if (dyn_h->want_dlt
2243
      && (elf64_hppa_dynamic_symbol_p (dyn_h->h, info) || info->shared))
2244
    {
2245
      Elf64_Internal_Rela rel;
2246
      int dynindx;
2247
 
2248
      /* We may need to do a relocation against a local symbol, in
2249
         which case we have to look up it's dynamic symbol index off
2250
         the local symbol hash table.  */
2251
      if (h && h->dynindx != -1)
2252
        dynindx = h->dynindx;
2253
      else
2254
        dynindx
2255
          = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner,
2256
                                                dyn_h->sym_indx);
2257
 
2258
      /* Create a dynamic relocation for this entry.  Do include the output
2259
         offset of the DLT entry since we need an absolute address in the
2260
         resulting object file.  */
2261
      rel.r_offset = (dyn_h->dlt_offset + sdlt->output_offset
2262
                      + sdlt->output_section->vma);
2263
      if (h && h->type == STT_FUNC)
2264
          rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_FPTR64);
2265
      else
2266
          rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_DIR64);
2267
      rel.r_addend = 0;
2268
 
2269
      bfd_elf64_swap_reloca_out (sdlt->output_section->owner, &rel,
2270
                                 (((Elf64_External_Rela *)
2271
                                   sdltrel->contents)
2272
                                  + sdltrel->reloc_count));
2273
      sdltrel->reloc_count++;
2274
    }
2275
  return true;
2276
}
2277
 
2278
/* Finalize the dynamic relocations.  Specifically the FPTR relocations
2279
   for dynamic functions used to initialize static data.  */
2280
 
2281
static boolean
2282
elf64_hppa_finalize_dynreloc (dyn_h, data)
2283
     struct elf64_hppa_dyn_hash_entry *dyn_h;
2284
     PTR data;
2285
{
2286
  struct bfd_link_info *info = (struct bfd_link_info *)data;
2287
  struct elf64_hppa_link_hash_table *hppa_info;
2288
  struct elf_link_hash_entry *h;
2289
  int dynamic_symbol;
2290
 
2291
  dynamic_symbol = elf64_hppa_dynamic_symbol_p (dyn_h->h, info);
2292
 
2293
  if (!dynamic_symbol && !info->shared)
2294
    return true;
2295
 
2296
  if (dyn_h->reloc_entries)
2297
    {
2298
      struct elf64_hppa_dyn_reloc_entry *rent;
2299
      int dynindx;
2300
 
2301
      hppa_info = elf64_hppa_hash_table (info);
2302
      h = dyn_h->h;
2303
 
2304
      /* We may need to do a relocation against a local symbol, in
2305
         which case we have to look up it's dynamic symbol index off
2306
         the local symbol hash table.  */
2307
      if (h && h->dynindx != -1)
2308
        dynindx = h->dynindx;
2309
      else
2310
        dynindx
2311
          = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner,
2312
                                                dyn_h->sym_indx);
2313
 
2314
      for (rent = dyn_h->reloc_entries; rent; rent = rent->next)
2315
        {
2316
          Elf64_Internal_Rela rel;
2317
 
2318
          switch (rent->type)
2319
            {
2320
              case R_PARISC_FPTR64:
2321
              /* Allocate one iff we are not building a shared library and
2322
                 !want_opd, which by this point will be true only if we're
2323
                 actually allocating one statically in the main executable.  */
2324
              if (!info->shared && dyn_h->want_opd)
2325
                continue;
2326
              break;
2327
            }
2328
 
2329
          /* Create a dynamic relocation for this entry.
2330
 
2331
             We need the output offset for the reloc's section because
2332
             we are creating an absolute address in the resulting object
2333
             file.  */
2334
          rel.r_offset = (rent->offset + rent->sec->output_offset
2335
                          + rent->sec->output_section->vma);
2336
 
2337
          /* An FPTR64 relocation implies that we took the address of
2338
             a function and that the function has an entry in the .opd
2339
             section.  We want the FPTR64 relocation to reference the
2340
             entry in .opd.
2341
 
2342
             We could munge the symbol value in the dynamic symbol table
2343
             (in fact we already do for functions with global scope) to point
2344
             to the .opd entry.  Then we could use that dynamic symbol in
2345
             this relocation.
2346
 
2347
             Or we could do something sensible, not munge the symbol's
2348
             address and instead just use a different symbol to reference
2349
             the .opd entry.  At least that seems sensible until you
2350
             realize there's no local dynamic symbols we can use for that
2351
             purpose.  Thus the hair in the check_relocs routine.
2352
 
2353
             We use a section symbol recorded by check_relocs as the
2354
             base symbol for the relocation.  The addend is the difference
2355
             between the section symbol and the address of the .opd entry.  */
2356
          if (info->shared && rent->type == R_PARISC_FPTR64)
2357
            {
2358
              bfd_vma value, value2;
2359
 
2360
              /* First compute the address of the opd entry for this symbol.  */
2361
              value = (dyn_h->opd_offset
2362
                       + hppa_info->opd_sec->output_section->vma
2363
                       + hppa_info->opd_sec->output_offset);
2364
 
2365
              /* Compute the value of the start of the section with
2366
                 the relocation.  */
2367
              value2 = (rent->sec->output_section->vma
2368
                        + rent->sec->output_offset);
2369
 
2370
              /* Compute the difference between the start of the section
2371
                 with the relocation and the opd entry.  */
2372
              value -= value2;
2373
 
2374
              /* The result becomes the addend of the relocation.  */
2375
              rel.r_addend = value;
2376
 
2377
              /* The section symbol becomes the symbol for the dynamic
2378
                 relocation.  */
2379
              dynindx
2380
                = _bfd_elf_link_lookup_local_dynindx (info,
2381
                                                      rent->sec->owner,
2382
                                                      rent->sec_symndx);
2383
            }
2384
          else
2385
            rel.r_addend = rent->addend;
2386
 
2387
          rel.r_info = ELF64_R_INFO (dynindx, rent->type);
2388
 
2389
          bfd_elf64_swap_reloca_out (hppa_info->other_rel_sec->output_section->owner,
2390
                                     &rel,
2391
                                     (((Elf64_External_Rela *)
2392
                                      hppa_info->other_rel_sec->contents)
2393
                                      + hppa_info->other_rel_sec->reloc_count));
2394
          hppa_info->other_rel_sec->reloc_count++;
2395
        }
2396
    }
2397
 
2398
  return true;
2399
}
2400
 
2401
/* Finish up the dynamic sections.  */
2402
 
2403
static boolean
2404
elf64_hppa_finish_dynamic_sections (output_bfd, info)
2405
     bfd *output_bfd;
2406
     struct bfd_link_info *info;
2407
{
2408
  bfd *dynobj;
2409
  asection *sdyn;
2410
  struct elf64_hppa_link_hash_table *hppa_info;
2411
 
2412
  hppa_info = elf64_hppa_hash_table (info);
2413
 
2414
  /* Finalize the contents of the .opd section.  */
2415
  elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
2416
                                elf64_hppa_finalize_opd,
2417
                                info);
2418
 
2419
  elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
2420
                                elf64_hppa_finalize_dynreloc,
2421
                                info);
2422
 
2423
  /* Finalize the contents of the .dlt section.  */
2424
  dynobj = elf_hash_table (info)->dynobj;
2425
  /* Finalize the contents of the .dlt section.  */
2426
  elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
2427
                                elf64_hppa_finalize_dlt,
2428
                                info);
2429
 
2430
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2431
 
2432
  if (elf_hash_table (info)->dynamic_sections_created)
2433
    {
2434
      Elf64_External_Dyn *dyncon, *dynconend;
2435
 
2436
      BFD_ASSERT (sdyn != NULL);
2437
 
2438
      dyncon = (Elf64_External_Dyn *) sdyn->contents;
2439
      dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2440
      for (; dyncon < dynconend; dyncon++)
2441
        {
2442
          Elf_Internal_Dyn dyn;
2443
          asection *s;
2444
 
2445
          bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2446
 
2447
          switch (dyn.d_tag)
2448
            {
2449
            default:
2450
              break;
2451
 
2452
            case DT_HP_LOAD_MAP:
2453
              /* Compute the absolute address of 16byte scratchpad area
2454
                 for the dynamic linker.
2455
 
2456
                 By convention the linker script will allocate the scratchpad
2457
                 area at the start of the .data section.  So all we have to
2458
                 to is find the start of the .data section.  */
2459
              s = bfd_get_section_by_name (output_bfd, ".data");
2460
              dyn.d_un.d_ptr = s->vma;
2461
              bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2462
              break;
2463
 
2464
            case DT_PLTGOT:
2465
              /* HP's use PLTGOT to set the GOT register.  */
2466
              dyn.d_un.d_ptr = _bfd_get_gp_value (output_bfd);
2467
              bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2468
              break;
2469
 
2470
            case DT_JMPREL:
2471
              s = hppa_info->plt_rel_sec;
2472
              dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2473
              bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2474
              break;
2475
 
2476
            case DT_PLTRELSZ:
2477
              s = hppa_info->plt_rel_sec;
2478
              dyn.d_un.d_val = s->_raw_size;
2479
              bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2480
              break;
2481
 
2482
            case DT_RELA:
2483
              s = hppa_info->other_rel_sec;
2484
              if (! s)
2485
                s = hppa_info->dlt_rel_sec;
2486
              dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2487
              bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2488
              break;
2489
 
2490
            case DT_RELASZ:
2491
              s = hppa_info->other_rel_sec;
2492
              dyn.d_un.d_val = s->_raw_size;
2493
              s = hppa_info->dlt_rel_sec;
2494
              dyn.d_un.d_val += s->_raw_size;
2495
              s = hppa_info->opd_rel_sec;
2496
              dyn.d_un.d_val += s->_raw_size;
2497
              /* There is some question about whether or not the size of
2498
                 the PLT relocs should be included here.  HP's tools do
2499
                 it, so we'll emulate them.  */
2500
              s = hppa_info->plt_rel_sec;
2501
              dyn.d_un.d_val += s->_raw_size;
2502
              bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2503
              break;
2504
 
2505
            }
2506
        }
2507
    }
2508
 
2509
  return true;
2510
}
2511
 
2512
/* Return the number of additional phdrs we will need.
2513
 
2514
   The generic ELF code only creates PT_PHDRs for executables.  The HP
2515
   dynamic linker requires PT_PHDRs for dynamic libraries too.
2516
 
2517
   This routine indicates that the backend needs one additional program
2518
   header for that case.
2519
 
2520
   Note we do not have access to the link info structure here, so we have
2521
   to guess whether or not we are building a shared library based on the
2522
   existence of a .interp section.  */
2523
 
2524
static int
2525
elf64_hppa_additional_program_headers (abfd)
2526
     bfd *abfd;
2527
{
2528
  asection *s;
2529
 
2530
  /* If we are creating a shared library, then we have to create a
2531
     PT_PHDR segment.  HP's dynamic linker chokes without it.  */
2532
  s = bfd_get_section_by_name (abfd, ".interp");
2533
  if (! s)
2534
    return 1;
2535
  return 0;
2536
}
2537
 
2538
/* Allocate and initialize any program headers required by this
2539
   specific backend.
2540
 
2541
   The generic ELF code only creates PT_PHDRs for executables.  The HP
2542
   dynamic linker requires PT_PHDRs for dynamic libraries too.
2543
 
2544
   This allocates the PT_PHDR and initializes it in a manner suitable
2545
   for the HP linker.
2546
 
2547
   Note we do not have access to the link info structure here, so we have
2548
   to guess whether or not we are building a shared library based on the
2549
   existence of a .interp section.  */
2550
 
2551
static boolean
2552
elf64_hppa_modify_segment_map (abfd)
2553
     bfd *abfd;
2554
{
2555
  struct elf_segment_map *m;
2556
  asection *s;
2557
 
2558
  s = bfd_get_section_by_name (abfd, ".interp");
2559
  if (! s)
2560
    {
2561
      for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2562
        if (m->p_type == PT_PHDR)
2563
          break;
2564
      if (m == NULL)
2565
        {
2566
          m = (struct elf_segment_map *) bfd_zalloc (abfd, sizeof *m);
2567
          if (m == NULL)
2568
            return false;
2569
 
2570
          m->p_type = PT_PHDR;
2571
          m->p_flags = PF_R | PF_X;
2572
          m->p_flags_valid = 1;
2573
          m->p_paddr_valid = 1;
2574
          m->includes_phdrs = 1;
2575
 
2576
          m->next = elf_tdata (abfd)->segment_map;
2577
          elf_tdata (abfd)->segment_map = m;
2578
        }
2579
    }
2580
 
2581
  for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2582
    if (m->p_type == PT_LOAD)
2583
      {
2584
        unsigned int i;
2585
 
2586
        for (i = 0; i < m->count; i++)
2587
          {
2588
            /* The code "hint" is not really a hint.  It is a requirement
2589
               for certain versions of the HP dynamic linker.  Worse yet,
2590
               it must be set even if the shared library does not have
2591
               any code in its "text" segment (thus the check for .hash
2592
               to catch this situation).  */
2593
            if (m->sections[i]->flags & SEC_CODE
2594
                || (strcmp (m->sections[i]->name, ".hash") == 0))
2595
              m->p_flags |= (PF_X | PF_HP_CODE);
2596
          }
2597
      }
2598
 
2599
  return true;
2600
}
2601
 
2602
/* Called when writing out an object file to decide the type of a
2603
   symbol.  */
2604
static int
2605
elf64_hppa_elf_get_symbol_type (elf_sym, type)
2606
     Elf_Internal_Sym *elf_sym;
2607
     int type;
2608
{
2609
  if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)
2610
    return STT_PARISC_MILLI;
2611
  else
2612
    return type;
2613
}
2614
 
2615
/* The hash bucket size is the standard one, namely 4.  */
2616
 
2617
const struct elf_size_info hppa64_elf_size_info =
2618
{
2619
  sizeof (Elf64_External_Ehdr),
2620
  sizeof (Elf64_External_Phdr),
2621
  sizeof (Elf64_External_Shdr),
2622
  sizeof (Elf64_External_Rel),
2623
  sizeof (Elf64_External_Rela),
2624
  sizeof (Elf64_External_Sym),
2625
  sizeof (Elf64_External_Dyn),
2626
  sizeof (Elf_External_Note),
2627
  4,
2628
  1,
2629
  64, 8,
2630
  ELFCLASS64, EV_CURRENT,
2631
  bfd_elf64_write_out_phdrs,
2632
  bfd_elf64_write_shdrs_and_ehdr,
2633
  bfd_elf64_write_relocs,
2634
  bfd_elf64_swap_symbol_out,
2635
  bfd_elf64_slurp_reloc_table,
2636
  bfd_elf64_slurp_symbol_table,
2637
  bfd_elf64_swap_dyn_in,
2638
  bfd_elf64_swap_dyn_out,
2639
  NULL,
2640
  NULL,
2641
  NULL,
2642
  NULL
2643
};
2644
 
2645
#define TARGET_BIG_SYM                  bfd_elf64_hppa_vec
2646
#define TARGET_BIG_NAME                 "elf64-hppa"
2647
#define ELF_ARCH                        bfd_arch_hppa
2648
#define ELF_MACHINE_CODE                EM_PARISC
2649
/* This is not strictly correct.  The maximum page size for PA2.0 is
2650
   64M.  But everything still uses 4k.  */
2651
#define ELF_MAXPAGESIZE                 0x1000
2652
#define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
2653
#define bfd_elf64_bfd_is_local_label_name       elf_hppa_is_local_label_name
2654
#define elf_info_to_howto               elf_hppa_info_to_howto
2655
#define elf_info_to_howto_rel           elf_hppa_info_to_howto_rel
2656
 
2657
#define elf_backend_section_from_shdr   elf64_hppa_section_from_shdr
2658
#define elf_backend_object_p            elf64_hppa_object_p
2659
#define elf_backend_final_write_processing \
2660
                                        elf_hppa_final_write_processing
2661
#define elf_backend_fake_sections       elf_hppa_fake_sections
2662
#define elf_backend_add_symbol_hook     elf_hppa_add_symbol_hook
2663
 
2664
#define elf_backend_relocate_section        elf_hppa_relocate_section
2665
 
2666
#define bfd_elf64_bfd_final_link        elf_hppa_final_link
2667
 
2668
#define elf_backend_create_dynamic_sections \
2669
                                        elf64_hppa_create_dynamic_sections
2670
#define elf_backend_post_process_headers        elf64_hppa_post_process_headers
2671
 
2672
#define elf_backend_adjust_dynamic_symbol \
2673
                                        elf64_hppa_adjust_dynamic_symbol
2674
 
2675
#define elf_backend_size_dynamic_sections \
2676
                                        elf64_hppa_size_dynamic_sections
2677
 
2678
#define elf_backend_finish_dynamic_symbol \
2679
                                        elf64_hppa_finish_dynamic_symbol
2680
#define elf_backend_finish_dynamic_sections \
2681
                                        elf64_hppa_finish_dynamic_sections
2682
 
2683
/* Stuff for the BFD linker: */
2684
#define bfd_elf64_bfd_link_hash_table_create \
2685
        elf64_hppa_hash_table_create
2686
 
2687
#define elf_backend_check_relocs \
2688
        elf64_hppa_check_relocs
2689
 
2690
#define elf_backend_size_info \
2691
  hppa64_elf_size_info
2692
 
2693
#define elf_backend_additional_program_headers \
2694
        elf64_hppa_additional_program_headers
2695
 
2696
#define elf_backend_modify_segment_map \
2697
        elf64_hppa_modify_segment_map
2698
 
2699
#define elf_backend_link_output_symbol_hook \
2700
        elf64_hppa_link_output_symbol_hook
2701
 
2702
#define elf_backend_want_got_plt        0
2703
#define elf_backend_plt_readonly        0
2704
#define elf_backend_want_plt_sym        0
2705
#define elf_backend_got_header_size     0
2706
#define elf_backend_plt_header_size     0
2707
#define elf_backend_type_change_ok true
2708
#define elf_backend_get_symbol_type          elf64_hppa_elf_get_symbol_type
2709
 
2710
#include "elf64-target.h"
2711
 
2712
#undef TARGET_BIG_SYM
2713
#define TARGET_BIG_SYM                  bfd_elf64_hppa_linux_vec
2714
#undef TARGET_BIG_NAME
2715
#define TARGET_BIG_NAME                 "elf64-hppa-linux"
2716
 
2717
#define INCLUDED_TARGET_FILE 1
2718
#include "elf64-target.h"

powered by: WebSVN 2.1.0

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