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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [bfd/] [elf32-hppa.c] - Blame information for rev 834

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

Line No. Rev Author Line
1 227 jeremybenn
/* BFD back-end for HP PA-RISC ELF files.
2
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001,
3
   2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4
   Free Software Foundation, Inc.
5
 
6
   Original code by
7
        Center for Software Science
8
        Department of Computer Science
9
        University of Utah
10
   Largely rewritten by Alan Modra <alan@linuxcare.com.au>
11
   Naming cleanup by Carlos O'Donell <carlos@systemhalted.org>
12
   TLS support written by Randolph Chung <tausq@debian.org>
13
 
14
   This file is part of BFD, the Binary File Descriptor library.
15
 
16
   This program is free software; you can redistribute it and/or modify
17
   it under the terms of the GNU General Public License as published by
18
   the Free Software Foundation; either version 3 of the License, or
19
   (at your option) any later version.
20
 
21
   This program is distributed in the hope that it will be useful,
22
   but WITHOUT ANY WARRANTY; without even the implied warranty of
23
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24
   GNU General Public License for more details.
25
 
26
   You should have received a copy of the GNU General Public License
27
   along with this program; if not, write to the Free Software
28
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
29
   MA 02110-1301, USA.  */
30
 
31
#include "sysdep.h"
32
#include "bfd.h"
33
#include "libbfd.h"
34
#include "elf-bfd.h"
35
#include "elf/hppa.h"
36
#include "libhppa.h"
37
#include "elf32-hppa.h"
38
#define ARCH_SIZE               32
39
#include "elf32-hppa.h"
40
#include "elf-hppa.h"
41
 
42
/* In order to gain some understanding of code in this file without
43
   knowing all the intricate details of the linker, note the
44
   following:
45
 
46
   Functions named elf32_hppa_* are called by external routines, other
47
   functions are only called locally.  elf32_hppa_* functions appear
48
   in this file more or less in the order in which they are called
49
   from external routines.  eg. elf32_hppa_check_relocs is called
50
   early in the link process, elf32_hppa_finish_dynamic_sections is
51
   one of the last functions.  */
52
 
53
/* We use two hash tables to hold information for linking PA ELF objects.
54
 
55
   The first is the elf32_hppa_link_hash_table which is derived
56
   from the standard ELF linker hash table.  We use this as a place to
57
   attach other hash tables and static information.
58
 
59
   The second is the stub hash table which is derived from the
60
   base BFD hash table.  The stub hash table holds the information
61
   necessary to build the linker stubs during a link.
62
 
63
   There are a number of different stubs generated by the linker.
64
 
65
   Long branch stub:
66
   :            ldil LR'X,%r1
67
   :            be,n RR'X(%sr4,%r1)
68
 
69
   PIC long branch stub:
70
   :            b,l .+8,%r1
71
   :            addil LR'X - ($PIC_pcrel$0 - 4),%r1
72
   :            be,n RR'X - ($PIC_pcrel$0 - 8)(%sr4,%r1)
73
 
74
   Import stub to call shared library routine from normal object file
75
   (single sub-space version)
76
   :            addil LR'lt_ptr+ltoff,%dp       ; get procedure entry point
77
   :            ldw RR'lt_ptr+ltoff(%r1),%r21
78
   :            bv %r0(%r21)
79
   :            ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
80
 
81
   Import stub to call shared library routine from shared library
82
   (single sub-space version)
83
   :            addil LR'ltoff,%r19             ; get procedure entry point
84
   :            ldw RR'ltoff(%r1),%r21
85
   :            bv %r0(%r21)
86
   :            ldw RR'ltoff+4(%r1),%r19        ; get new dlt value.
87
 
88
   Import stub to call shared library routine from normal object file
89
   (multiple sub-space support)
90
   :            addil LR'lt_ptr+ltoff,%dp       ; get procedure entry point
91
   :            ldw RR'lt_ptr+ltoff(%r1),%r21
92
   :            ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
93
   :            ldsid (%r21),%r1
94
   :            mtsp %r1,%sr0
95
   :            be 0(%sr0,%r21)                 ; branch to target
96
   :            stw %rp,-24(%sp)                ; save rp
97
 
98
   Import stub to call shared library routine from shared library
99
   (multiple sub-space support)
100
   :            addil LR'ltoff,%r19             ; get procedure entry point
101
   :            ldw RR'ltoff(%r1),%r21
102
   :            ldw RR'ltoff+4(%r1),%r19        ; get new dlt value.
103
   :            ldsid (%r21),%r1
104
   :            mtsp %r1,%sr0
105
   :            be 0(%sr0,%r21)                 ; branch to target
106
   :            stw %rp,-24(%sp)                ; save rp
107
 
108
   Export stub to return from shared lib routine (multiple sub-space support)
109
   One of these is created for each exported procedure in a shared
110
   library (and stored in the shared lib).  Shared lib routines are
111
   called via the first instruction in the export stub so that we can
112
   do an inter-space return.  Not required for single sub-space.
113
   :            bl,n X,%rp                      ; trap the return
114
   :            nop
115
   :            ldw -24(%sp),%rp                ; restore the original rp
116
   :            ldsid (%rp),%r1
117
   :            mtsp %r1,%sr0
118
   :            be,n 0(%sr0,%rp)                ; inter-space return.  */
119
 
120
 
121
/* Variable names follow a coding style.
122
   Please follow this (Apps Hungarian) style:
123
 
124
   Structure/Variable                   Prefix
125
   elf_link_hash_table                  "etab"
126
   elf_link_hash_entry                  "eh"
127
 
128
   elf32_hppa_link_hash_table           "htab"
129
   elf32_hppa_link_hash_entry           "hh"
130
 
131
   bfd_hash_table                       "btab"
132
   bfd_hash_entry                       "bh"
133
 
134
   bfd_hash_table containing stubs      "bstab"
135
   elf32_hppa_stub_hash_entry           "hsh"
136
 
137
   elf32_hppa_dyn_reloc_entry           "hdh"
138
 
139
   Always remember to use GNU Coding Style. */
140
 
141
#define PLT_ENTRY_SIZE 8
142
#define GOT_ENTRY_SIZE 4
143
#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
144
 
145
static const bfd_byte plt_stub[] =
146
{
147
  0x0e, 0x80, 0x10, 0x96,  /* 1: ldw    0(%r20),%r22            */
148
  0xea, 0xc0, 0xc0, 0x00,  /*    bv     %r0(%r22)               */
149
  0x0e, 0x88, 0x10, 0x95,  /*    ldw    4(%r20),%r21            */
150
#define PLT_STUB_ENTRY (3*4)
151
  0xea, 0x9f, 0x1f, 0xdd,  /*    b,l    1b,%r20                 */
152
  0xd6, 0x80, 0x1c, 0x1e,  /*    depi   0,31,2,%r20             */
153
  0x00, 0xc0, 0xff, 0xee,  /* 9: .word  fixup_func              */
154
  0xde, 0xad, 0xbe, 0xef   /*    .word  fixup_ltp               */
155
};
156
 
157
/* Section name for stubs is the associated section name plus this
158
   string.  */
159
#define STUB_SUFFIX ".stub"
160
 
161
/* We don't need to copy certain PC- or GP-relative dynamic relocs
162
   into a shared object's dynamic section.  All the relocs of the
163
   limited class we are interested in, are absolute.  */
164
#ifndef RELATIVE_DYNRELOCS
165
#define RELATIVE_DYNRELOCS 0
166
#define IS_ABSOLUTE_RELOC(r_type) 1
167
#endif
168
 
169
/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
170
   copying dynamic variables from a shared lib into an app's dynbss
171
   section, and instead use a dynamic relocation to point into the
172
   shared lib.  */
173
#define ELIMINATE_COPY_RELOCS 1
174
 
175
enum elf32_hppa_stub_type
176
{
177
  hppa_stub_long_branch,
178
  hppa_stub_long_branch_shared,
179
  hppa_stub_import,
180
  hppa_stub_import_shared,
181
  hppa_stub_export,
182
  hppa_stub_none
183
};
184
 
185
struct elf32_hppa_stub_hash_entry
186
{
187
  /* Base hash table entry structure.  */
188
  struct bfd_hash_entry bh_root;
189
 
190
  /* The stub section.  */
191
  asection *stub_sec;
192
 
193
  /* Offset within stub_sec of the beginning of this stub.  */
194
  bfd_vma stub_offset;
195
 
196
  /* Given the symbol's value and its section we can determine its final
197
     value when building the stubs (so the stub knows where to jump.  */
198
  bfd_vma target_value;
199
  asection *target_section;
200
 
201
  enum elf32_hppa_stub_type stub_type;
202
 
203
  /* The symbol table entry, if any, that this was derived from.  */
204
  struct elf32_hppa_link_hash_entry *hh;
205
 
206
  /* Where this stub is being called from, or, in the case of combined
207
     stub sections, the first input section in the group.  */
208
  asection *id_sec;
209
};
210
 
211
struct elf32_hppa_link_hash_entry
212
{
213
  struct elf_link_hash_entry eh;
214
 
215
  /* A pointer to the most recently used stub hash entry against this
216
     symbol.  */
217
  struct elf32_hppa_stub_hash_entry *hsh_cache;
218
 
219
  /* Used to count relocations for delayed sizing of relocation
220
     sections.  */
221
  struct elf32_hppa_dyn_reloc_entry
222
  {
223
    /* Next relocation in the chain.  */
224
    struct elf32_hppa_dyn_reloc_entry *hdh_next;
225
 
226
    /* The input section of the reloc.  */
227
    asection *sec;
228
 
229
    /* Number of relocs copied in this section.  */
230
    bfd_size_type count;
231
 
232
#if RELATIVE_DYNRELOCS
233
  /* Number of relative relocs copied for the input section.  */
234
    bfd_size_type relative_count;
235
#endif
236
  } *dyn_relocs;
237
 
238
  enum
239
  {
240
    GOT_UNKNOWN = 0, GOT_NORMAL = 1, GOT_TLS_GD = 2, GOT_TLS_LDM = 4, GOT_TLS_IE = 8
241
  } tls_type;
242
 
243
  /* Set if this symbol is used by a plabel reloc.  */
244
  unsigned int plabel:1;
245
};
246
 
247
struct elf32_hppa_link_hash_table
248
{
249
  /* The main hash table.  */
250
  struct elf_link_hash_table etab;
251
 
252
  /* The stub hash table.  */
253
  struct bfd_hash_table bstab;
254
 
255
  /* Linker stub bfd.  */
256
  bfd *stub_bfd;
257
 
258
  /* Linker call-backs.  */
259
  asection * (*add_stub_section) (const char *, asection *);
260
  void (*layout_sections_again) (void);
261
 
262
  /* Array to keep track of which stub sections have been created, and
263
     information on stub grouping.  */
264
  struct map_stub
265
  {
266
    /* This is the section to which stubs in the group will be
267
       attached.  */
268
    asection *link_sec;
269
    /* The stub section.  */
270
    asection *stub_sec;
271
  } *stub_group;
272
 
273
  /* Assorted information used by elf32_hppa_size_stubs.  */
274
  unsigned int bfd_count;
275
  int top_index;
276
  asection **input_list;
277
  Elf_Internal_Sym **all_local_syms;
278
 
279
  /* Short-cuts to get to dynamic linker sections.  */
280
  asection *sgot;
281
  asection *srelgot;
282
  asection *splt;
283
  asection *srelplt;
284
  asection *sdynbss;
285
  asection *srelbss;
286
 
287
  /* Used during a final link to store the base of the text and data
288
     segments so that we can perform SEGREL relocations.  */
289
  bfd_vma text_segment_base;
290
  bfd_vma data_segment_base;
291
 
292
  /* Whether we support multiple sub-spaces for shared libs.  */
293
  unsigned int multi_subspace:1;
294
 
295
  /* Flags set when various size branches are detected.  Used to
296
     select suitable defaults for the stub group size.  */
297
  unsigned int has_12bit_branch:1;
298
  unsigned int has_17bit_branch:1;
299
  unsigned int has_22bit_branch:1;
300
 
301
  /* Set if we need a .plt stub to support lazy dynamic linking.  */
302
  unsigned int need_plt_stub:1;
303
 
304
  /* Small local sym cache.  */
305
  struct sym_cache sym_cache;
306
 
307
  /* Data for LDM relocations.  */
308
  union
309
  {
310
    bfd_signed_vma refcount;
311
    bfd_vma offset;
312
  } tls_ldm_got;
313
};
314
 
315
/* Various hash macros and functions.  */
316
#define hppa_link_hash_table(p) \
317
  (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
318
  == HPPA32_ELF_DATA ? ((struct elf32_hppa_link_hash_table *) ((p)->hash)) : NULL)
319
 
320
#define hppa_elf_hash_entry(ent) \
321
  ((struct elf32_hppa_link_hash_entry *)(ent))
322
 
323
#define hppa_stub_hash_entry(ent) \
324
  ((struct elf32_hppa_stub_hash_entry *)(ent))
325
 
326
#define hppa_stub_hash_lookup(table, string, create, copy) \
327
  ((struct elf32_hppa_stub_hash_entry *) \
328
   bfd_hash_lookup ((table), (string), (create), (copy)))
329
 
330
#define hppa_elf_local_got_tls_type(abfd) \
331
  ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info * 2)))
332
 
333
#define hh_name(hh) \
334
  (hh ? hh->eh.root.root.string : "<undef>")
335
 
336
#define eh_name(eh) \
337
  (eh ? eh->root.root.string : "<undef>")
338
 
339
/* Override the generic function because we want to mark our BFDs.  */
340
 
341
static bfd_boolean
342
elf32_hppa_mkobject (bfd *abfd)
343
{
344
  return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata),
345
                                  HPPA32_ELF_DATA);
346
}
347
 
348
/* Assorted hash table functions.  */
349
 
350
/* Initialize an entry in the stub hash table.  */
351
 
352
static struct bfd_hash_entry *
353
stub_hash_newfunc (struct bfd_hash_entry *entry,
354
                   struct bfd_hash_table *table,
355
                   const char *string)
356
{
357
  /* Allocate the structure if it has not already been allocated by a
358
     subclass.  */
359
  if (entry == NULL)
360
    {
361
      entry = bfd_hash_allocate (table,
362
                                 sizeof (struct elf32_hppa_stub_hash_entry));
363
      if (entry == NULL)
364
        return entry;
365
    }
366
 
367
  /* Call the allocation method of the superclass.  */
368
  entry = bfd_hash_newfunc (entry, table, string);
369
  if (entry != NULL)
370
    {
371
      struct elf32_hppa_stub_hash_entry *hsh;
372
 
373
      /* Initialize the local fields.  */
374
      hsh = hppa_stub_hash_entry (entry);
375
      hsh->stub_sec = NULL;
376
      hsh->stub_offset = 0;
377
      hsh->target_value = 0;
378
      hsh->target_section = NULL;
379
      hsh->stub_type = hppa_stub_long_branch;
380
      hsh->hh = NULL;
381
      hsh->id_sec = NULL;
382
    }
383
 
384
  return entry;
385
}
386
 
387
/* Initialize an entry in the link hash table.  */
388
 
389
static struct bfd_hash_entry *
390
hppa_link_hash_newfunc (struct bfd_hash_entry *entry,
391
                        struct bfd_hash_table *table,
392
                        const char *string)
393
{
394
  /* Allocate the structure if it has not already been allocated by a
395
     subclass.  */
396
  if (entry == NULL)
397
    {
398
      entry = bfd_hash_allocate (table,
399
                                 sizeof (struct elf32_hppa_link_hash_entry));
400
      if (entry == NULL)
401
        return entry;
402
    }
403
 
404
  /* Call the allocation method of the superclass.  */
405
  entry = _bfd_elf_link_hash_newfunc (entry, table, string);
406
  if (entry != NULL)
407
    {
408
      struct elf32_hppa_link_hash_entry *hh;
409
 
410
      /* Initialize the local fields.  */
411
      hh = hppa_elf_hash_entry (entry);
412
      hh->hsh_cache = NULL;
413
      hh->dyn_relocs = NULL;
414
      hh->plabel = 0;
415
      hh->tls_type = GOT_UNKNOWN;
416
    }
417
 
418
  return entry;
419
}
420
 
421
/* Create the derived linker hash table.  The PA ELF port uses the derived
422
   hash table to keep information specific to the PA ELF linker (without
423
   using static variables).  */
424
 
425
static struct bfd_link_hash_table *
426
elf32_hppa_link_hash_table_create (bfd *abfd)
427
{
428
  struct elf32_hppa_link_hash_table *htab;
429
  bfd_size_type amt = sizeof (*htab);
430
 
431
  htab = bfd_malloc (amt);
432
  if (htab == NULL)
433
    return NULL;
434
 
435
  if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd, hppa_link_hash_newfunc,
436
                                      sizeof (struct elf32_hppa_link_hash_entry),
437
                                      HPPA32_ELF_DATA))
438
    {
439
      free (htab);
440
      return NULL;
441
    }
442
 
443
  /* Init the stub hash table too.  */
444
  if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
445
                            sizeof (struct elf32_hppa_stub_hash_entry)))
446
    return NULL;
447
 
448
  htab->stub_bfd = NULL;
449
  htab->add_stub_section = NULL;
450
  htab->layout_sections_again = NULL;
451
  htab->stub_group = NULL;
452
  htab->sgot = NULL;
453
  htab->srelgot = NULL;
454
  htab->splt = NULL;
455
  htab->srelplt = NULL;
456
  htab->sdynbss = NULL;
457
  htab->srelbss = NULL;
458
  htab->text_segment_base = (bfd_vma) -1;
459
  htab->data_segment_base = (bfd_vma) -1;
460
  htab->multi_subspace = 0;
461
  htab->has_12bit_branch = 0;
462
  htab->has_17bit_branch = 0;
463
  htab->has_22bit_branch = 0;
464
  htab->need_plt_stub = 0;
465
  htab->sym_cache.abfd = NULL;
466
  htab->tls_ldm_got.refcount = 0;
467
 
468
  return &htab->etab.root;
469
}
470
 
471
/* Free the derived linker hash table.  */
472
 
473
static void
474
elf32_hppa_link_hash_table_free (struct bfd_link_hash_table *btab)
475
{
476
  struct elf32_hppa_link_hash_table *htab
477
    = (struct elf32_hppa_link_hash_table *) btab;
478
 
479
  bfd_hash_table_free (&htab->bstab);
480
  _bfd_generic_link_hash_table_free (btab);
481
}
482
 
483
/* Build a name for an entry in the stub hash table.  */
484
 
485
static char *
486
hppa_stub_name (const asection *input_section,
487
                const asection *sym_sec,
488
                const struct elf32_hppa_link_hash_entry *hh,
489
                const Elf_Internal_Rela *rela)
490
{
491
  char *stub_name;
492
  bfd_size_type len;
493
 
494
  if (hh)
495
    {
496
      len = 8 + 1 + strlen (hh_name (hh)) + 1 + 8 + 1;
497
      stub_name = bfd_malloc (len);
498
      if (stub_name != NULL)
499
        sprintf (stub_name, "%08x_%s+%x",
500
                 input_section->id & 0xffffffff,
501
                 hh_name (hh),
502
                 (int) rela->r_addend & 0xffffffff);
503
    }
504
  else
505
    {
506
      len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
507
      stub_name = bfd_malloc (len);
508
      if (stub_name != NULL)
509
        sprintf (stub_name, "%08x_%x:%x+%x",
510
                 input_section->id & 0xffffffff,
511
                 sym_sec->id & 0xffffffff,
512
                 (int) ELF32_R_SYM (rela->r_info) & 0xffffffff,
513
                 (int) rela->r_addend & 0xffffffff);
514
    }
515
  return stub_name;
516
}
517
 
518
/* Look up an entry in the stub hash.  Stub entries are cached because
519
   creating the stub name takes a bit of time.  */
520
 
521
static struct elf32_hppa_stub_hash_entry *
522
hppa_get_stub_entry (const asection *input_section,
523
                     const asection *sym_sec,
524
                     struct elf32_hppa_link_hash_entry *hh,
525
                     const Elf_Internal_Rela *rela,
526
                     struct elf32_hppa_link_hash_table *htab)
527
{
528
  struct elf32_hppa_stub_hash_entry *hsh_entry;
529
  const asection *id_sec;
530
 
531
  /* If this input section is part of a group of sections sharing one
532
     stub section, then use the id of the first section in the group.
533
     Stub names need to include a section id, as there may well be
534
     more than one stub used to reach say, printf, and we need to
535
     distinguish between them.  */
536
  id_sec = htab->stub_group[input_section->id].link_sec;
537
 
538
  if (hh != NULL && hh->hsh_cache != NULL
539
      && hh->hsh_cache->hh == hh
540
      && hh->hsh_cache->id_sec == id_sec)
541
    {
542
      hsh_entry = hh->hsh_cache;
543
    }
544
  else
545
    {
546
      char *stub_name;
547
 
548
      stub_name = hppa_stub_name (id_sec, sym_sec, hh, rela);
549
      if (stub_name == NULL)
550
        return NULL;
551
 
552
      hsh_entry = hppa_stub_hash_lookup (&htab->bstab,
553
                                          stub_name, FALSE, FALSE);
554
      if (hh != NULL)
555
        hh->hsh_cache = hsh_entry;
556
 
557
      free (stub_name);
558
    }
559
 
560
  return hsh_entry;
561
}
562
 
563
/* Add a new stub entry to the stub hash.  Not all fields of the new
564
   stub entry are initialised.  */
565
 
566
static struct elf32_hppa_stub_hash_entry *
567
hppa_add_stub (const char *stub_name,
568
               asection *section,
569
               struct elf32_hppa_link_hash_table *htab)
570
{
571
  asection *link_sec;
572
  asection *stub_sec;
573
  struct elf32_hppa_stub_hash_entry *hsh;
574
 
575
  link_sec = htab->stub_group[section->id].link_sec;
576
  stub_sec = htab->stub_group[section->id].stub_sec;
577
  if (stub_sec == NULL)
578
    {
579
      stub_sec = htab->stub_group[link_sec->id].stub_sec;
580
      if (stub_sec == NULL)
581
        {
582
          size_t namelen;
583
          bfd_size_type len;
584
          char *s_name;
585
 
586
          namelen = strlen (link_sec->name);
587
          len = namelen + sizeof (STUB_SUFFIX);
588
          s_name = bfd_alloc (htab->stub_bfd, len);
589
          if (s_name == NULL)
590
            return NULL;
591
 
592
          memcpy (s_name, link_sec->name, namelen);
593
          memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
594
          stub_sec = (*htab->add_stub_section) (s_name, link_sec);
595
          if (stub_sec == NULL)
596
            return NULL;
597
          htab->stub_group[link_sec->id].stub_sec = stub_sec;
598
        }
599
      htab->stub_group[section->id].stub_sec = stub_sec;
600
    }
601
 
602
  /* Enter this entry into the linker stub hash table.  */
603
  hsh = hppa_stub_hash_lookup (&htab->bstab, stub_name,
604
                                      TRUE, FALSE);
605
  if (hsh == NULL)
606
    {
607
      (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
608
                             section->owner,
609
                             stub_name);
610
      return NULL;
611
    }
612
 
613
  hsh->stub_sec = stub_sec;
614
  hsh->stub_offset = 0;
615
  hsh->id_sec = link_sec;
616
  return hsh;
617
}
618
 
619
/* Determine the type of stub needed, if any, for a call.  */
620
 
621
static enum elf32_hppa_stub_type
622
hppa_type_of_stub (asection *input_sec,
623
                   const Elf_Internal_Rela *rela,
624
                   struct elf32_hppa_link_hash_entry *hh,
625
                   bfd_vma destination,
626
                   struct bfd_link_info *info)
627
{
628
  bfd_vma location;
629
  bfd_vma branch_offset;
630
  bfd_vma max_branch_offset;
631
  unsigned int r_type;
632
 
633
  if (hh != NULL
634
      && hh->eh.plt.offset != (bfd_vma) -1
635
      && hh->eh.dynindx != -1
636
      && !hh->plabel
637
      && (info->shared
638
          || !hh->eh.def_regular
639
          || hh->eh.root.type == bfd_link_hash_defweak))
640
    {
641
      /* We need an import stub.  Decide between hppa_stub_import
642
         and hppa_stub_import_shared later.  */
643
      return hppa_stub_import;
644
    }
645
 
646
  /* Determine where the call point is.  */
647
  location = (input_sec->output_offset
648
              + input_sec->output_section->vma
649
              + rela->r_offset);
650
 
651
  branch_offset = destination - location - 8;
652
  r_type = ELF32_R_TYPE (rela->r_info);
653
 
654
  /* Determine if a long branch stub is needed.  parisc branch offsets
655
     are relative to the second instruction past the branch, ie. +8
656
     bytes on from the branch instruction location.  The offset is
657
     signed and counts in units of 4 bytes.  */
658
  if (r_type == (unsigned int) R_PARISC_PCREL17F)
659
    max_branch_offset = (1 << (17 - 1)) << 2;
660
 
661
  else if (r_type == (unsigned int) R_PARISC_PCREL12F)
662
    max_branch_offset = (1 << (12 - 1)) << 2;
663
 
664
  else /* R_PARISC_PCREL22F.  */
665
    max_branch_offset = (1 << (22 - 1)) << 2;
666
 
667
  if (branch_offset + max_branch_offset >= 2*max_branch_offset)
668
    return hppa_stub_long_branch;
669
 
670
  return hppa_stub_none;
671
}
672
 
673
/* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
674
   IN_ARG contains the link info pointer.  */
675
 
676
#define LDIL_R1         0x20200000      /* ldil  LR'XXX,%r1             */
677
#define BE_SR4_R1       0xe0202002      /* be,n  RR'XXX(%sr4,%r1)       */
678
 
679
#define BL_R1           0xe8200000      /* b,l   .+8,%r1                */
680
#define ADDIL_R1        0x28200000      /* addil LR'XXX,%r1,%r1         */
681
#define DEPI_R1         0xd4201c1e      /* depi  0,31,2,%r1             */
682
 
683
#define ADDIL_DP        0x2b600000      /* addil LR'XXX,%dp,%r1         */
684
#define LDW_R1_R21      0x48350000      /* ldw   RR'XXX(%sr0,%r1),%r21  */
685
#define BV_R0_R21       0xeaa0c000      /* bv    %r0(%r21)              */
686
#define LDW_R1_R19      0x48330000      /* ldw   RR'XXX(%sr0,%r1),%r19  */
687
 
688
#define ADDIL_R19       0x2a600000      /* addil LR'XXX,%r19,%r1        */
689
#define LDW_R1_DP       0x483b0000      /* ldw   RR'XXX(%sr0,%r1),%dp   */
690
 
691
#define LDSID_R21_R1    0x02a010a1      /* ldsid (%sr0,%r21),%r1        */
692
#define MTSP_R1         0x00011820      /* mtsp  %r1,%sr0               */
693
#define BE_SR0_R21      0xe2a00000      /* be    0(%sr0,%r21)           */
694
#define STW_RP          0x6bc23fd1      /* stw   %rp,-24(%sr0,%sp)      */
695
 
696
#define BL22_RP         0xe800a002      /* b,l,n XXX,%rp                */
697
#define BL_RP           0xe8400002      /* b,l,n XXX,%rp                */
698
#define NOP             0x08000240      /* nop                          */
699
#define LDW_RP          0x4bc23fd1      /* ldw   -24(%sr0,%sp),%rp      */
700
#define LDSID_RP_R1     0x004010a1      /* ldsid (%sr0,%rp),%r1         */
701
#define BE_SR0_RP       0xe0400002      /* be,n  0(%sr0,%rp)            */
702
 
703
#ifndef R19_STUBS
704
#define R19_STUBS 1
705
#endif
706
 
707
#if R19_STUBS
708
#define LDW_R1_DLT      LDW_R1_R19
709
#else
710
#define LDW_R1_DLT      LDW_R1_DP
711
#endif
712
 
713
static bfd_boolean
714
hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
715
{
716
  struct elf32_hppa_stub_hash_entry *hsh;
717
  struct bfd_link_info *info;
718
  struct elf32_hppa_link_hash_table *htab;
719
  asection *stub_sec;
720
  bfd *stub_bfd;
721
  bfd_byte *loc;
722
  bfd_vma sym_value;
723
  bfd_vma insn;
724
  bfd_vma off;
725
  int val;
726
  int size;
727
 
728
  /* Massage our args to the form they really have.  */
729
  hsh = hppa_stub_hash_entry (bh);
730
  info = (struct bfd_link_info *)in_arg;
731
 
732
  htab = hppa_link_hash_table (info);
733
  if (htab == NULL)
734
    return FALSE;
735
 
736
  stub_sec = hsh->stub_sec;
737
 
738
  /* Make a note of the offset within the stubs for this entry.  */
739
  hsh->stub_offset = stub_sec->size;
740
  loc = stub_sec->contents + hsh->stub_offset;
741
 
742
  stub_bfd = stub_sec->owner;
743
 
744
  switch (hsh->stub_type)
745
    {
746
    case hppa_stub_long_branch:
747
      /* Create the long branch.  A long branch is formed with "ldil"
748
         loading the upper bits of the target address into a register,
749
         then branching with "be" which adds in the lower bits.
750
         The "be" has its delay slot nullified.  */
751
      sym_value = (hsh->target_value
752
                   + hsh->target_section->output_offset
753
                   + hsh->target_section->output_section->vma);
754
 
755
      val = hppa_field_adjust (sym_value, 0, e_lrsel);
756
      insn = hppa_rebuild_insn ((int) LDIL_R1, val, 21);
757
      bfd_put_32 (stub_bfd, insn, loc);
758
 
759
      val = hppa_field_adjust (sym_value, 0, e_rrsel) >> 2;
760
      insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
761
      bfd_put_32 (stub_bfd, insn, loc + 4);
762
 
763
      size = 8;
764
      break;
765
 
766
    case hppa_stub_long_branch_shared:
767
      /* Branches are relative.  This is where we are going to.  */
768
      sym_value = (hsh->target_value
769
                   + hsh->target_section->output_offset
770
                   + hsh->target_section->output_section->vma);
771
 
772
      /* And this is where we are coming from, more or less.  */
773
      sym_value -= (hsh->stub_offset
774
                    + stub_sec->output_offset
775
                    + stub_sec->output_section->vma);
776
 
777
      bfd_put_32 (stub_bfd, (bfd_vma) BL_R1, loc);
778
      val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_lrsel);
779
      insn = hppa_rebuild_insn ((int) ADDIL_R1, val, 21);
780
      bfd_put_32 (stub_bfd, insn, loc + 4);
781
 
782
      val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_rrsel) >> 2;
783
      insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
784
      bfd_put_32 (stub_bfd, insn, loc + 8);
785
      size = 12;
786
      break;
787
 
788
    case hppa_stub_import:
789
    case hppa_stub_import_shared:
790
      off = hsh->hh->eh.plt.offset;
791
      if (off >= (bfd_vma) -2)
792
        abort ();
793
 
794
      off &= ~ (bfd_vma) 1;
795
      sym_value = (off
796
                   + htab->splt->output_offset
797
                   + htab->splt->output_section->vma
798
                   - elf_gp (htab->splt->output_section->owner));
799
 
800
      insn = ADDIL_DP;
801
#if R19_STUBS
802
      if (hsh->stub_type == hppa_stub_import_shared)
803
        insn = ADDIL_R19;
804
#endif
805
      val = hppa_field_adjust (sym_value, 0, e_lrsel),
806
      insn = hppa_rebuild_insn ((int) insn, val, 21);
807
      bfd_put_32 (stub_bfd, insn, loc);
808
 
809
      /* It is critical to use lrsel/rrsel here because we are using
810
         two different offsets (+0 and +4) from sym_value.  If we use
811
         lsel/rsel then with unfortunate sym_values we will round
812
         sym_value+4 up to the next 2k block leading to a mis-match
813
         between the lsel and rsel value.  */
814
      val = hppa_field_adjust (sym_value, 0, e_rrsel);
815
      insn = hppa_rebuild_insn ((int) LDW_R1_R21, val, 14);
816
      bfd_put_32 (stub_bfd, insn, loc + 4);
817
 
818
      if (htab->multi_subspace)
819
        {
820
          val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
821
          insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
822
          bfd_put_32 (stub_bfd, insn, loc + 8);
823
 
824
          bfd_put_32 (stub_bfd, (bfd_vma) LDSID_R21_R1, loc + 12);
825
          bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1,      loc + 16);
826
          bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_R21,   loc + 20);
827
          bfd_put_32 (stub_bfd, (bfd_vma) STW_RP,       loc + 24);
828
 
829
          size = 28;
830
        }
831
      else
832
        {
833
          bfd_put_32 (stub_bfd, (bfd_vma) BV_R0_R21, loc + 8);
834
          val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
835
          insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
836
          bfd_put_32 (stub_bfd, insn, loc + 12);
837
 
838
          size = 16;
839
        }
840
 
841
      break;
842
 
843
    case hppa_stub_export:
844
      /* Branches are relative.  This is where we are going to.  */
845
      sym_value = (hsh->target_value
846
                   + hsh->target_section->output_offset
847
                   + hsh->target_section->output_section->vma);
848
 
849
      /* And this is where we are coming from.  */
850
      sym_value -= (hsh->stub_offset
851
                    + stub_sec->output_offset
852
                    + stub_sec->output_section->vma);
853
 
854
      if (sym_value - 8 + (1 << (17 + 1)) >= (1 << (17 + 2))
855
          && (!htab->has_22bit_branch
856
              || sym_value - 8 + (1 << (22 + 1)) >= (1 << (22 + 2))))
857
        {
858
          (*_bfd_error_handler)
859
            (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
860
             hsh->target_section->owner,
861
             stub_sec,
862
             (long) hsh->stub_offset,
863
             hsh->bh_root.string);
864
          bfd_set_error (bfd_error_bad_value);
865
          return FALSE;
866
        }
867
 
868
      val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_fsel) >> 2;
869
      if (!htab->has_22bit_branch)
870
        insn = hppa_rebuild_insn ((int) BL_RP, val, 17);
871
      else
872
        insn = hppa_rebuild_insn ((int) BL22_RP, val, 22);
873
      bfd_put_32 (stub_bfd, insn, loc);
874
 
875
      bfd_put_32 (stub_bfd, (bfd_vma) NOP,         loc + 4);
876
      bfd_put_32 (stub_bfd, (bfd_vma) LDW_RP,      loc + 8);
877
      bfd_put_32 (stub_bfd, (bfd_vma) LDSID_RP_R1, loc + 12);
878
      bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1,     loc + 16);
879
      bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_RP,   loc + 20);
880
 
881
      /* Point the function symbol at the stub.  */
882
      hsh->hh->eh.root.u.def.section = stub_sec;
883
      hsh->hh->eh.root.u.def.value = stub_sec->size;
884
 
885
      size = 24;
886
      break;
887
 
888
    default:
889
      BFD_FAIL ();
890
      return FALSE;
891
    }
892
 
893
  stub_sec->size += size;
894
  return TRUE;
895
}
896
 
897
#undef LDIL_R1
898
#undef BE_SR4_R1
899
#undef BL_R1
900
#undef ADDIL_R1
901
#undef DEPI_R1
902
#undef LDW_R1_R21
903
#undef LDW_R1_DLT
904
#undef LDW_R1_R19
905
#undef ADDIL_R19
906
#undef LDW_R1_DP
907
#undef LDSID_R21_R1
908
#undef MTSP_R1
909
#undef BE_SR0_R21
910
#undef STW_RP
911
#undef BV_R0_R21
912
#undef BL_RP
913
#undef NOP
914
#undef LDW_RP
915
#undef LDSID_RP_R1
916
#undef BE_SR0_RP
917
 
918
/* As above, but don't actually build the stub.  Just bump offset so
919
   we know stub section sizes.  */
920
 
921
static bfd_boolean
922
hppa_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
923
{
924
  struct elf32_hppa_stub_hash_entry *hsh;
925
  struct elf32_hppa_link_hash_table *htab;
926
  int size;
927
 
928
  /* Massage our args to the form they really have.  */
929
  hsh = hppa_stub_hash_entry (bh);
930
  htab = in_arg;
931
 
932
  if (hsh->stub_type == hppa_stub_long_branch)
933
    size = 8;
934
  else if (hsh->stub_type == hppa_stub_long_branch_shared)
935
    size = 12;
936
  else if (hsh->stub_type == hppa_stub_export)
937
    size = 24;
938
  else /* hppa_stub_import or hppa_stub_import_shared.  */
939
    {
940
      if (htab->multi_subspace)
941
        size = 28;
942
      else
943
        size = 16;
944
    }
945
 
946
  hsh->stub_sec->size += size;
947
  return TRUE;
948
}
949
 
950
/* Return nonzero if ABFD represents an HPPA ELF32 file.
951
   Additionally we set the default architecture and machine.  */
952
 
953
static bfd_boolean
954
elf32_hppa_object_p (bfd *abfd)
955
{
956
  Elf_Internal_Ehdr * i_ehdrp;
957
  unsigned int flags;
958
 
959
  i_ehdrp = elf_elfheader (abfd);
960
  if (strcmp (bfd_get_target (abfd), "elf32-hppa-linux") == 0)
961
    {
962
      /* GCC on hppa-linux produces binaries with OSABI=Linux,
963
         but the kernel produces corefiles with OSABI=SysV.  */
964
      if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_LINUX &&
965
          i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
966
        return FALSE;
967
    }
968
  else if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0)
969
    {
970
      /* GCC on hppa-netbsd produces binaries with OSABI=NetBSD,
971
         but the kernel produces corefiles with OSABI=SysV.  */
972
      if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NETBSD &&
973
          i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
974
        return FALSE;
975
    }
976
  else
977
    {
978
      if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX)
979
        return FALSE;
980
    }
981
 
982
  flags = i_ehdrp->e_flags;
983
  switch (flags & (EF_PARISC_ARCH | EF_PARISC_WIDE))
984
    {
985
    case EFA_PARISC_1_0:
986
      return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10);
987
    case EFA_PARISC_1_1:
988
      return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11);
989
    case EFA_PARISC_2_0:
990
      return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20);
991
    case EFA_PARISC_2_0 | EF_PARISC_WIDE:
992
      return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
993
    }
994
  return TRUE;
995
}
996
 
997
/* Create the .plt and .got sections, and set up our hash table
998
   short-cuts to various dynamic sections.  */
999
 
1000
static bfd_boolean
1001
elf32_hppa_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1002
{
1003
  struct elf32_hppa_link_hash_table *htab;
1004
  struct elf_link_hash_entry *eh;
1005
 
1006
  /* Don't try to create the .plt and .got twice.  */
1007
  htab = hppa_link_hash_table (info);
1008
  if (htab == NULL)
1009
    return FALSE;
1010
  if (htab->splt != NULL)
1011
    return TRUE;
1012
 
1013
  /* Call the generic code to do most of the work.  */
1014
  if (! _bfd_elf_create_dynamic_sections (abfd, info))
1015
    return FALSE;
1016
 
1017
  htab->splt = bfd_get_section_by_name (abfd, ".plt");
1018
  htab->srelplt = bfd_get_section_by_name (abfd, ".rela.plt");
1019
 
1020
  htab->sgot = bfd_get_section_by_name (abfd, ".got");
1021
  htab->srelgot = bfd_get_section_by_name (abfd, ".rela.got");
1022
 
1023
  htab->sdynbss = bfd_get_section_by_name (abfd, ".dynbss");
1024
  htab->srelbss = bfd_get_section_by_name (abfd, ".rela.bss");
1025
 
1026
  /* hppa-linux needs _GLOBAL_OFFSET_TABLE_ to be visible from the main
1027
     application, because __canonicalize_funcptr_for_compare needs it.  */
1028
  eh = elf_hash_table (info)->hgot;
1029
  eh->forced_local = 0;
1030
  eh->other = STV_DEFAULT;
1031
  return bfd_elf_link_record_dynamic_symbol (info, eh);
1032
}
1033
 
1034
/* Copy the extra info we tack onto an elf_link_hash_entry.  */
1035
 
1036
static void
1037
elf32_hppa_copy_indirect_symbol (struct bfd_link_info *info,
1038
                                 struct elf_link_hash_entry *eh_dir,
1039
                                 struct elf_link_hash_entry *eh_ind)
1040
{
1041
  struct elf32_hppa_link_hash_entry *hh_dir, *hh_ind;
1042
 
1043
  hh_dir = hppa_elf_hash_entry (eh_dir);
1044
  hh_ind = hppa_elf_hash_entry (eh_ind);
1045
 
1046
  if (hh_ind->dyn_relocs != NULL)
1047
    {
1048
      if (hh_dir->dyn_relocs != NULL)
1049
        {
1050
          struct elf32_hppa_dyn_reloc_entry **hdh_pp;
1051
          struct elf32_hppa_dyn_reloc_entry *hdh_p;
1052
 
1053
          /* Add reloc counts against the indirect sym to the direct sym
1054
             list.  Merge any entries against the same section.  */
1055
          for (hdh_pp = &hh_ind->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
1056
            {
1057
              struct elf32_hppa_dyn_reloc_entry *hdh_q;
1058
 
1059
              for (hdh_q = hh_dir->dyn_relocs;
1060
                   hdh_q != NULL;
1061
                   hdh_q = hdh_q->hdh_next)
1062
                if (hdh_q->sec == hdh_p->sec)
1063
                  {
1064
#if RELATIVE_DYNRELOCS
1065
                    hdh_q->relative_count += hdh_p->relative_count;
1066
#endif
1067
                    hdh_q->count += hdh_p->count;
1068
                    *hdh_pp = hdh_p->hdh_next;
1069
                    break;
1070
                  }
1071
              if (hdh_q == NULL)
1072
                hdh_pp = &hdh_p->hdh_next;
1073
            }
1074
          *hdh_pp = hh_dir->dyn_relocs;
1075
        }
1076
 
1077
      hh_dir->dyn_relocs = hh_ind->dyn_relocs;
1078
      hh_ind->dyn_relocs = NULL;
1079
    }
1080
 
1081
  if (ELIMINATE_COPY_RELOCS
1082
      && eh_ind->root.type != bfd_link_hash_indirect
1083
      && eh_dir->dynamic_adjusted)
1084
    {
1085
      /* If called to transfer flags for a weakdef during processing
1086
         of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1087
         We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
1088
      eh_dir->ref_dynamic |= eh_ind->ref_dynamic;
1089
      eh_dir->ref_regular |= eh_ind->ref_regular;
1090
      eh_dir->ref_regular_nonweak |= eh_ind->ref_regular_nonweak;
1091
      eh_dir->needs_plt |= eh_ind->needs_plt;
1092
    }
1093
  else
1094
    {
1095
      if (eh_ind->root.type == bfd_link_hash_indirect
1096
          && eh_dir->got.refcount <= 0)
1097
        {
1098
          hh_dir->tls_type = hh_ind->tls_type;
1099
          hh_ind->tls_type = GOT_UNKNOWN;
1100
        }
1101
 
1102
      _bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind);
1103
    }
1104
}
1105
 
1106
static int
1107
elf32_hppa_optimized_tls_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1108
                                int r_type, int is_local ATTRIBUTE_UNUSED)
1109
{
1110
  /* For now we don't support linker optimizations.  */
1111
  return r_type;
1112
}
1113
 
1114
/* Return a pointer to the local GOT, PLT and TLS reference counts
1115
   for ABFD.  Returns NULL if the storage allocation fails.  */
1116
 
1117
static bfd_signed_vma *
1118
hppa32_elf_local_refcounts (bfd *abfd)
1119
{
1120
  Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1121
  bfd_signed_vma *local_refcounts;
1122
 
1123
  local_refcounts = elf_local_got_refcounts (abfd);
1124
  if (local_refcounts == NULL)
1125
    {
1126
      bfd_size_type size;
1127
 
1128
      /* Allocate space for local GOT and PLT reference
1129
         counts.  Done this way to save polluting elf_obj_tdata
1130
         with another target specific pointer.  */
1131
      size = symtab_hdr->sh_info;
1132
      size *= 2 * sizeof (bfd_signed_vma);
1133
      /* Add in space to store the local GOT TLS types.  */
1134
      size += symtab_hdr->sh_info;
1135
      local_refcounts = bfd_zalloc (abfd, size);
1136
      if (local_refcounts == NULL)
1137
        return NULL;
1138
      elf_local_got_refcounts (abfd) = local_refcounts;
1139
      memset (hppa_elf_local_got_tls_type (abfd), GOT_UNKNOWN,
1140
              symtab_hdr->sh_info);
1141
    }
1142
  return local_refcounts;
1143
}
1144
 
1145
 
1146
/* Look through the relocs for a section during the first phase, and
1147
   calculate needed space in the global offset table, procedure linkage
1148
   table, and dynamic reloc sections.  At this point we haven't
1149
   necessarily read all the input files.  */
1150
 
1151
static bfd_boolean
1152
elf32_hppa_check_relocs (bfd *abfd,
1153
                         struct bfd_link_info *info,
1154
                         asection *sec,
1155
                         const Elf_Internal_Rela *relocs)
1156
{
1157
  Elf_Internal_Shdr *symtab_hdr;
1158
  struct elf_link_hash_entry **eh_syms;
1159
  const Elf_Internal_Rela *rela;
1160
  const Elf_Internal_Rela *rela_end;
1161
  struct elf32_hppa_link_hash_table *htab;
1162
  asection *sreloc;
1163
  asection *stubreloc;
1164
  int tls_type = GOT_UNKNOWN, old_tls_type = GOT_UNKNOWN;
1165
 
1166
  if (info->relocatable)
1167
    return TRUE;
1168
 
1169
  htab = hppa_link_hash_table (info);
1170
  if (htab == NULL)
1171
    return FALSE;
1172
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1173
  eh_syms = elf_sym_hashes (abfd);
1174
  sreloc = NULL;
1175
  stubreloc = NULL;
1176
 
1177
  rela_end = relocs + sec->reloc_count;
1178
  for (rela = relocs; rela < rela_end; rela++)
1179
    {
1180
      enum {
1181
        NEED_GOT = 1,
1182
        NEED_PLT = 2,
1183
        NEED_DYNREL = 4,
1184
        PLT_PLABEL = 8
1185
      };
1186
 
1187
      unsigned int r_symndx, r_type;
1188
      struct elf32_hppa_link_hash_entry *hh;
1189
      int need_entry = 0;
1190
 
1191
      r_symndx = ELF32_R_SYM (rela->r_info);
1192
 
1193
      if (r_symndx < symtab_hdr->sh_info)
1194
        hh = NULL;
1195
      else
1196
        {
1197
          hh =  hppa_elf_hash_entry (eh_syms[r_symndx - symtab_hdr->sh_info]);
1198
          while (hh->eh.root.type == bfd_link_hash_indirect
1199
                 || hh->eh.root.type == bfd_link_hash_warning)
1200
            hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
1201
        }
1202
 
1203
      r_type = ELF32_R_TYPE (rela->r_info);
1204
      r_type = elf32_hppa_optimized_tls_reloc (info, r_type, hh == NULL);
1205
 
1206
      switch (r_type)
1207
        {
1208
        case R_PARISC_DLTIND14F:
1209
        case R_PARISC_DLTIND14R:
1210
        case R_PARISC_DLTIND21L:
1211
          /* This symbol requires a global offset table entry.  */
1212
          need_entry = NEED_GOT;
1213
          break;
1214
 
1215
        case R_PARISC_PLABEL14R: /* "Official" procedure labels.  */
1216
        case R_PARISC_PLABEL21L:
1217
        case R_PARISC_PLABEL32:
1218
          /* If the addend is non-zero, we break badly.  */
1219
          if (rela->r_addend != 0)
1220
            abort ();
1221
 
1222
          /* If we are creating a shared library, then we need to
1223
             create a PLT entry for all PLABELs, because PLABELs with
1224
             local symbols may be passed via a pointer to another
1225
             object.  Additionally, output a dynamic relocation
1226
             pointing to the PLT entry.
1227
 
1228
             For executables, the original 32-bit ABI allowed two
1229
             different styles of PLABELs (function pointers):  For
1230
             global functions, the PLABEL word points into the .plt
1231
             two bytes past a (function address, gp) pair, and for
1232
             local functions the PLABEL points directly at the
1233
             function.  The magic +2 for the first type allows us to
1234
             differentiate between the two.  As you can imagine, this
1235
             is a real pain when it comes to generating code to call
1236
             functions indirectly or to compare function pointers.
1237
             We avoid the mess by always pointing a PLABEL into the
1238
             .plt, even for local functions.  */
1239
          need_entry = PLT_PLABEL | NEED_PLT | NEED_DYNREL;
1240
          break;
1241
 
1242
        case R_PARISC_PCREL12F:
1243
          htab->has_12bit_branch = 1;
1244
          goto branch_common;
1245
 
1246
        case R_PARISC_PCREL17C:
1247
        case R_PARISC_PCREL17F:
1248
          htab->has_17bit_branch = 1;
1249
          goto branch_common;
1250
 
1251
        case R_PARISC_PCREL22F:
1252
          htab->has_22bit_branch = 1;
1253
        branch_common:
1254
          /* Function calls might need to go through the .plt, and
1255
             might require long branch stubs.  */
1256
          if (hh == NULL)
1257
            {
1258
              /* We know local syms won't need a .plt entry, and if
1259
                 they need a long branch stub we can't guarantee that
1260
                 we can reach the stub.  So just flag an error later
1261
                 if we're doing a shared link and find we need a long
1262
                 branch stub.  */
1263
              continue;
1264
            }
1265
          else
1266
            {
1267
              /* Global symbols will need a .plt entry if they remain
1268
                 global, and in most cases won't need a long branch
1269
                 stub.  Unfortunately, we have to cater for the case
1270
                 where a symbol is forced local by versioning, or due
1271
                 to symbolic linking, and we lose the .plt entry.  */
1272
              need_entry = NEED_PLT;
1273
              if (hh->eh.type == STT_PARISC_MILLI)
1274
                need_entry = 0;
1275
            }
1276
          break;
1277
 
1278
        case R_PARISC_SEGBASE:  /* Used to set segment base.  */
1279
        case R_PARISC_SEGREL32: /* Relative reloc, used for unwind.  */
1280
        case R_PARISC_PCREL14F: /* PC relative load/store.  */
1281
        case R_PARISC_PCREL14R:
1282
        case R_PARISC_PCREL17R: /* External branches.  */
1283
        case R_PARISC_PCREL21L: /* As above, and for load/store too.  */
1284
        case R_PARISC_PCREL32:
1285
          /* We don't need to propagate the relocation if linking a
1286
             shared object since these are section relative.  */
1287
          continue;
1288
 
1289
        case R_PARISC_DPREL14F: /* Used for gp rel data load/store.  */
1290
        case R_PARISC_DPREL14R:
1291
        case R_PARISC_DPREL21L:
1292
          if (info->shared)
1293
            {
1294
              (*_bfd_error_handler)
1295
                (_("%B: relocation %s can not be used when making a shared object; recompile with -fPIC"),
1296
                 abfd,
1297
                 elf_hppa_howto_table[r_type].name);
1298
              bfd_set_error (bfd_error_bad_value);
1299
              return FALSE;
1300
            }
1301
          /* Fall through.  */
1302
 
1303
        case R_PARISC_DIR17F: /* Used for external branches.  */
1304
        case R_PARISC_DIR17R:
1305
        case R_PARISC_DIR14F: /* Used for load/store from absolute locn.  */
1306
        case R_PARISC_DIR14R:
1307
        case R_PARISC_DIR21L: /* As above, and for ext branches too.  */
1308
        case R_PARISC_DIR32: /* .word relocs.  */
1309
          /* We may want to output a dynamic relocation later.  */
1310
          need_entry = NEED_DYNREL;
1311
          break;
1312
 
1313
          /* This relocation describes the C++ object vtable hierarchy.
1314
             Reconstruct it for later use during GC.  */
1315
        case R_PARISC_GNU_VTINHERIT:
1316
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, &hh->eh, rela->r_offset))
1317
            return FALSE;
1318
          continue;
1319
 
1320
          /* This relocation describes which C++ vtable entries are actually
1321
             used.  Record for later use during GC.  */
1322
        case R_PARISC_GNU_VTENTRY:
1323
          BFD_ASSERT (hh != NULL);
1324
          if (hh != NULL
1325
              && !bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rela->r_addend))
1326
            return FALSE;
1327
          continue;
1328
 
1329
        case R_PARISC_TLS_GD21L:
1330
        case R_PARISC_TLS_GD14R:
1331
        case R_PARISC_TLS_LDM21L:
1332
        case R_PARISC_TLS_LDM14R:
1333
          need_entry = NEED_GOT;
1334
          break;
1335
 
1336
        case R_PARISC_TLS_IE21L:
1337
        case R_PARISC_TLS_IE14R:
1338
          if (info->shared)
1339
            info->flags |= DF_STATIC_TLS;
1340
          need_entry = NEED_GOT;
1341
          break;
1342
 
1343
        default:
1344
          continue;
1345
        }
1346
 
1347
      /* Now carry out our orders.  */
1348
      if (need_entry & NEED_GOT)
1349
        {
1350
          switch (r_type)
1351
            {
1352
            default:
1353
              tls_type = GOT_NORMAL;
1354
              break;
1355
            case R_PARISC_TLS_GD21L:
1356
            case R_PARISC_TLS_GD14R:
1357
              tls_type |= GOT_TLS_GD;
1358
              break;
1359
            case R_PARISC_TLS_LDM21L:
1360
            case R_PARISC_TLS_LDM14R:
1361
              tls_type |= GOT_TLS_LDM;
1362
              break;
1363
            case R_PARISC_TLS_IE21L:
1364
            case R_PARISC_TLS_IE14R:
1365
              tls_type |= GOT_TLS_IE;
1366
              break;
1367
            }
1368
 
1369
          /* Allocate space for a GOT entry, as well as a dynamic
1370
             relocation for this entry.  */
1371
          if (htab->sgot == NULL)
1372
            {
1373
              if (htab->etab.dynobj == NULL)
1374
                htab->etab.dynobj = abfd;
1375
              if (!elf32_hppa_create_dynamic_sections (htab->etab.dynobj, info))
1376
                return FALSE;
1377
            }
1378
 
1379
          if (r_type == R_PARISC_TLS_LDM21L
1380
              || r_type == R_PARISC_TLS_LDM14R)
1381
            htab->tls_ldm_got.refcount += 1;
1382
          else
1383
            {
1384
              if (hh != NULL)
1385
                {
1386
                  hh->eh.got.refcount += 1;
1387
                  old_tls_type = hh->tls_type;
1388
                }
1389
              else
1390
                {
1391
                  bfd_signed_vma *local_got_refcounts;
1392
 
1393
                  /* This is a global offset table entry for a local symbol.  */
1394
                  local_got_refcounts = hppa32_elf_local_refcounts (abfd);
1395
                  if (local_got_refcounts == NULL)
1396
                    return FALSE;
1397
                  local_got_refcounts[r_symndx] += 1;
1398
 
1399
                  old_tls_type = hppa_elf_local_got_tls_type (abfd) [r_symndx];
1400
                }
1401
 
1402
              tls_type |= old_tls_type;
1403
 
1404
              if (old_tls_type != tls_type)
1405
                {
1406
                  if (hh != NULL)
1407
                    hh->tls_type = tls_type;
1408
                  else
1409
                    hppa_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1410
                }
1411
 
1412
            }
1413
        }
1414
 
1415
      if (need_entry & NEED_PLT)
1416
        {
1417
          /* If we are creating a shared library, and this is a reloc
1418
             against a weak symbol or a global symbol in a dynamic
1419
             object, then we will be creating an import stub and a
1420
             .plt entry for the symbol.  Similarly, on a normal link
1421
             to symbols defined in a dynamic object we'll need the
1422
             import stub and a .plt entry.  We don't know yet whether
1423
             the symbol is defined or not, so make an entry anyway and
1424
             clean up later in adjust_dynamic_symbol.  */
1425
          if ((sec->flags & SEC_ALLOC) != 0)
1426
            {
1427
              if (hh != NULL)
1428
                {
1429
                  hh->eh.needs_plt = 1;
1430
                  hh->eh.plt.refcount += 1;
1431
 
1432
                  /* If this .plt entry is for a plabel, mark it so
1433
                     that adjust_dynamic_symbol will keep the entry
1434
                     even if it appears to be local.  */
1435
                  if (need_entry & PLT_PLABEL)
1436
                    hh->plabel = 1;
1437
                }
1438
              else if (need_entry & PLT_PLABEL)
1439
                {
1440
                  bfd_signed_vma *local_got_refcounts;
1441
                  bfd_signed_vma *local_plt_refcounts;
1442
 
1443
                  local_got_refcounts = hppa32_elf_local_refcounts (abfd);
1444
                  if (local_got_refcounts == NULL)
1445
                    return FALSE;
1446
                  local_plt_refcounts = (local_got_refcounts
1447
                                         + symtab_hdr->sh_info);
1448
                  local_plt_refcounts[r_symndx] += 1;
1449
                }
1450
            }
1451
        }
1452
 
1453
      if (need_entry & NEED_DYNREL)
1454
        {
1455
          /* Flag this symbol as having a non-got, non-plt reference
1456
             so that we generate copy relocs if it turns out to be
1457
             dynamic.  */
1458
          if (hh != NULL && !info->shared)
1459
            hh->eh.non_got_ref = 1;
1460
 
1461
          /* If we are creating a shared library then we need to copy
1462
             the reloc into the shared library.  However, if we are
1463
             linking with -Bsymbolic, we need only copy absolute
1464
             relocs or relocs against symbols that are not defined in
1465
             an object we are including in the link.  PC- or DP- or
1466
             DLT-relative relocs against any local sym or global sym
1467
             with DEF_REGULAR set, can be discarded.  At this point we
1468
             have not seen all the input files, so it is possible that
1469
             DEF_REGULAR is not set now but will be set later (it is
1470
             never cleared).  We account for that possibility below by
1471
             storing information in the dyn_relocs field of the
1472
             hash table entry.
1473
 
1474
             A similar situation to the -Bsymbolic case occurs when
1475
             creating shared libraries and symbol visibility changes
1476
             render the symbol local.
1477
 
1478
             As it turns out, all the relocs we will be creating here
1479
             are absolute, so we cannot remove them on -Bsymbolic
1480
             links or visibility changes anyway.  A STUB_REL reloc
1481
             is absolute too, as in that case it is the reloc in the
1482
             stub we will be creating, rather than copying the PCREL
1483
             reloc in the branch.
1484
 
1485
             If on the other hand, we are creating an executable, we
1486
             may need to keep relocations for symbols satisfied by a
1487
             dynamic library if we manage to avoid copy relocs for the
1488
             symbol.  */
1489
          if ((info->shared
1490
               && (sec->flags & SEC_ALLOC) != 0
1491
               && (IS_ABSOLUTE_RELOC (r_type)
1492
                   || (hh != NULL
1493
                       && (!info->symbolic
1494
                           || hh->eh.root.type == bfd_link_hash_defweak
1495
                           || !hh->eh.def_regular))))
1496
              || (ELIMINATE_COPY_RELOCS
1497
                  && !info->shared
1498
                  && (sec->flags & SEC_ALLOC) != 0
1499
                  && hh != NULL
1500
                  && (hh->eh.root.type == bfd_link_hash_defweak
1501
                      || !hh->eh.def_regular)))
1502
            {
1503
              struct elf32_hppa_dyn_reloc_entry *hdh_p;
1504
              struct elf32_hppa_dyn_reloc_entry **hdh_head;
1505
 
1506
              /* Create a reloc section in dynobj and make room for
1507
                 this reloc.  */
1508
              if (sreloc == NULL)
1509
                {
1510
                  if (htab->etab.dynobj == NULL)
1511
                    htab->etab.dynobj = abfd;
1512
 
1513
                  sreloc = _bfd_elf_make_dynamic_reloc_section
1514
                    (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ TRUE);
1515
 
1516
                  if (sreloc == NULL)
1517
                    {
1518
                      bfd_set_error (bfd_error_bad_value);
1519
                      return FALSE;
1520
                    }
1521
                }
1522
 
1523
              /* If this is a global symbol, we count the number of
1524
                 relocations we need for this symbol.  */
1525
              if (hh != NULL)
1526
                {
1527
                  hdh_head = &hh->dyn_relocs;
1528
                }
1529
              else
1530
                {
1531
                  /* Track dynamic relocs needed for local syms too.
1532
                     We really need local syms available to do this
1533
                     easily.  Oh well.  */
1534
                  asection *sr;
1535
                  void *vpp;
1536
                  Elf_Internal_Sym *isym;
1537
 
1538
                  isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1539
                                                abfd, r_symndx);
1540
                  if (isym == NULL)
1541
                    return FALSE;
1542
 
1543
                  sr = bfd_section_from_elf_index (abfd, isym->st_shndx);
1544
                  if (sr == NULL)
1545
                    sr = sec;
1546
 
1547
                  vpp = &elf_section_data (sr)->local_dynrel;
1548
                  hdh_head = (struct elf32_hppa_dyn_reloc_entry **) vpp;
1549
                }
1550
 
1551
              hdh_p = *hdh_head;
1552
              if (hdh_p == NULL || hdh_p->sec != sec)
1553
                {
1554
                  hdh_p = bfd_alloc (htab->etab.dynobj, sizeof *hdh_p);
1555
                  if (hdh_p == NULL)
1556
                    return FALSE;
1557
                  hdh_p->hdh_next = *hdh_head;
1558
                  *hdh_head = hdh_p;
1559
                  hdh_p->sec = sec;
1560
                  hdh_p->count = 0;
1561
#if RELATIVE_DYNRELOCS
1562
                  hdh_p->relative_count = 0;
1563
#endif
1564
                }
1565
 
1566
              hdh_p->count += 1;
1567
#if RELATIVE_DYNRELOCS
1568
              if (!IS_ABSOLUTE_RELOC (rtype))
1569
                hdh_p->relative_count += 1;
1570
#endif
1571
            }
1572
        }
1573
    }
1574
 
1575
  return TRUE;
1576
}
1577
 
1578
/* Return the section that should be marked against garbage collection
1579
   for a given relocation.  */
1580
 
1581
static asection *
1582
elf32_hppa_gc_mark_hook (asection *sec,
1583
                         struct bfd_link_info *info,
1584
                         Elf_Internal_Rela *rela,
1585
                         struct elf_link_hash_entry *hh,
1586
                         Elf_Internal_Sym *sym)
1587
{
1588
  if (hh != NULL)
1589
    switch ((unsigned int) ELF32_R_TYPE (rela->r_info))
1590
      {
1591
      case R_PARISC_GNU_VTINHERIT:
1592
      case R_PARISC_GNU_VTENTRY:
1593
        return NULL;
1594
      }
1595
 
1596
  return _bfd_elf_gc_mark_hook (sec, info, rela, hh, sym);
1597
}
1598
 
1599
/* Update the got and plt entry reference counts for the section being
1600
   removed.  */
1601
 
1602
static bfd_boolean
1603
elf32_hppa_gc_sweep_hook (bfd *abfd,
1604
                          struct bfd_link_info *info ATTRIBUTE_UNUSED,
1605
                          asection *sec,
1606
                          const Elf_Internal_Rela *relocs)
1607
{
1608
  Elf_Internal_Shdr *symtab_hdr;
1609
  struct elf_link_hash_entry **eh_syms;
1610
  bfd_signed_vma *local_got_refcounts;
1611
  bfd_signed_vma *local_plt_refcounts;
1612
  const Elf_Internal_Rela *rela, *relend;
1613
  struct elf32_hppa_link_hash_table *htab;
1614
 
1615
  if (info->relocatable)
1616
    return TRUE;
1617
 
1618
  htab = hppa_link_hash_table (info);
1619
  if (htab == NULL)
1620
    return FALSE;
1621
 
1622
  elf_section_data (sec)->local_dynrel = NULL;
1623
 
1624
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1625
  eh_syms = elf_sym_hashes (abfd);
1626
  local_got_refcounts = elf_local_got_refcounts (abfd);
1627
  local_plt_refcounts = local_got_refcounts;
1628
  if (local_plt_refcounts != NULL)
1629
    local_plt_refcounts += symtab_hdr->sh_info;
1630
 
1631
  relend = relocs + sec->reloc_count;
1632
  for (rela = relocs; rela < relend; rela++)
1633
    {
1634
      unsigned long r_symndx;
1635
      unsigned int r_type;
1636
      struct elf_link_hash_entry *eh = NULL;
1637
 
1638
      r_symndx = ELF32_R_SYM (rela->r_info);
1639
      if (r_symndx >= symtab_hdr->sh_info)
1640
        {
1641
          struct elf32_hppa_link_hash_entry *hh;
1642
          struct elf32_hppa_dyn_reloc_entry **hdh_pp;
1643
          struct elf32_hppa_dyn_reloc_entry *hdh_p;
1644
 
1645
          eh = eh_syms[r_symndx - symtab_hdr->sh_info];
1646
          while (eh->root.type == bfd_link_hash_indirect
1647
                 || eh->root.type == bfd_link_hash_warning)
1648
            eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
1649
          hh = hppa_elf_hash_entry (eh);
1650
 
1651
          for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; hdh_pp = &hdh_p->hdh_next)
1652
            if (hdh_p->sec == sec)
1653
              {
1654
                /* Everything must go for SEC.  */
1655
                *hdh_pp = hdh_p->hdh_next;
1656
                break;
1657
              }
1658
        }
1659
 
1660
      r_type = ELF32_R_TYPE (rela->r_info);
1661
      r_type = elf32_hppa_optimized_tls_reloc (info, r_type, eh != NULL);
1662
 
1663
      switch (r_type)
1664
        {
1665
        case R_PARISC_DLTIND14F:
1666
        case R_PARISC_DLTIND14R:
1667
        case R_PARISC_DLTIND21L:
1668
        case R_PARISC_TLS_GD21L:
1669
        case R_PARISC_TLS_GD14R:
1670
        case R_PARISC_TLS_IE21L:
1671
        case R_PARISC_TLS_IE14R:
1672
          if (eh != NULL)
1673
            {
1674
              if (eh->got.refcount > 0)
1675
                eh->got.refcount -= 1;
1676
            }
1677
          else if (local_got_refcounts != NULL)
1678
            {
1679
              if (local_got_refcounts[r_symndx] > 0)
1680
                local_got_refcounts[r_symndx] -= 1;
1681
            }
1682
          break;
1683
 
1684
        case R_PARISC_TLS_LDM21L:
1685
        case R_PARISC_TLS_LDM14R:
1686
          htab->tls_ldm_got.refcount -= 1;
1687
          break;
1688
 
1689
        case R_PARISC_PCREL12F:
1690
        case R_PARISC_PCREL17C:
1691
        case R_PARISC_PCREL17F:
1692
        case R_PARISC_PCREL22F:
1693
          if (eh != NULL)
1694
            {
1695
              if (eh->plt.refcount > 0)
1696
                eh->plt.refcount -= 1;
1697
            }
1698
          break;
1699
 
1700
        case R_PARISC_PLABEL14R:
1701
        case R_PARISC_PLABEL21L:
1702
        case R_PARISC_PLABEL32:
1703
          if (eh != NULL)
1704
            {
1705
              if (eh->plt.refcount > 0)
1706
                eh->plt.refcount -= 1;
1707
            }
1708
          else if (local_plt_refcounts != NULL)
1709
            {
1710
              if (local_plt_refcounts[r_symndx] > 0)
1711
                local_plt_refcounts[r_symndx] -= 1;
1712
            }
1713
          break;
1714
 
1715
        default:
1716
          break;
1717
        }
1718
    }
1719
 
1720
  return TRUE;
1721
}
1722
 
1723
/* Support for core dump NOTE sections.  */
1724
 
1725
static bfd_boolean
1726
elf32_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1727
{
1728
  int offset;
1729
  size_t size;
1730
 
1731
  switch (note->descsz)
1732
    {
1733
      default:
1734
        return FALSE;
1735
 
1736
      case 396:         /* Linux/hppa */
1737
        /* pr_cursig */
1738
        elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1739
 
1740
        /* pr_pid */
1741
        elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1742
 
1743
        /* pr_reg */
1744
        offset = 72;
1745
        size = 320;
1746
 
1747
        break;
1748
    }
1749
 
1750
  /* Make a ".reg/999" section.  */
1751
  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1752
                                          size, note->descpos + offset);
1753
}
1754
 
1755
static bfd_boolean
1756
elf32_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1757
{
1758
  switch (note->descsz)
1759
    {
1760
      default:
1761
        return FALSE;
1762
 
1763
      case 124:         /* Linux/hppa elf_prpsinfo.  */
1764
        elf_tdata (abfd)->core_program
1765
          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1766
        elf_tdata (abfd)->core_command
1767
          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1768
    }
1769
 
1770
  /* Note that for some reason, a spurious space is tacked
1771
     onto the end of the args in some (at least one anyway)
1772
     implementations, so strip it off if it exists.  */
1773
  {
1774
    char *command = elf_tdata (abfd)->core_command;
1775
    int n = strlen (command);
1776
 
1777
    if (0 < n && command[n - 1] == ' ')
1778
      command[n - 1] = '\0';
1779
  }
1780
 
1781
  return TRUE;
1782
}
1783
 
1784
/* Our own version of hide_symbol, so that we can keep plt entries for
1785
   plabels.  */
1786
 
1787
static void
1788
elf32_hppa_hide_symbol (struct bfd_link_info *info,
1789
                        struct elf_link_hash_entry *eh,
1790
                        bfd_boolean force_local)
1791
{
1792
  if (force_local)
1793
    {
1794
      eh->forced_local = 1;
1795
      if (eh->dynindx != -1)
1796
        {
1797
          eh->dynindx = -1;
1798
          _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1799
                                  eh->dynstr_index);
1800
        }
1801
    }
1802
 
1803
  if (! hppa_elf_hash_entry (eh)->plabel)
1804
    {
1805
      eh->needs_plt = 0;
1806
      eh->plt = elf_hash_table (info)->init_plt_refcount;
1807
    }
1808
}
1809
 
1810
/* Adjust a symbol defined by a dynamic object and referenced by a
1811
   regular object.  The current definition is in some section of the
1812
   dynamic object, but we're not including those sections.  We have to
1813
   change the definition to something the rest of the link can
1814
   understand.  */
1815
 
1816
static bfd_boolean
1817
elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
1818
                                  struct elf_link_hash_entry *eh)
1819
{
1820
  struct elf32_hppa_link_hash_table *htab;
1821
  asection *sec;
1822
 
1823
  /* If this is a function, put it in the procedure linkage table.  We
1824
     will fill in the contents of the procedure linkage table later.  */
1825
  if (eh->type == STT_FUNC
1826
      || eh->needs_plt)
1827
    {
1828
      if (eh->plt.refcount <= 0
1829
          || (eh->def_regular
1830
              && eh->root.type != bfd_link_hash_defweak
1831
              && ! hppa_elf_hash_entry (eh)->plabel
1832
              && (!info->shared || info->symbolic)))
1833
        {
1834
          /* The .plt entry is not needed when:
1835
             a) Garbage collection has removed all references to the
1836
             symbol, or
1837
             b) We know for certain the symbol is defined in this
1838
             object, and it's not a weak definition, nor is the symbol
1839
             used by a plabel relocation.  Either this object is the
1840
             application or we are doing a shared symbolic link.  */
1841
 
1842
          eh->plt.offset = (bfd_vma) -1;
1843
          eh->needs_plt = 0;
1844
        }
1845
 
1846
      return TRUE;
1847
    }
1848
  else
1849
    eh->plt.offset = (bfd_vma) -1;
1850
 
1851
  /* If this is a weak symbol, and there is a real definition, the
1852
     processor independent code will have arranged for us to see the
1853
     real definition first, and we can just use the same value.  */
1854
  if (eh->u.weakdef != NULL)
1855
    {
1856
      if (eh->u.weakdef->root.type != bfd_link_hash_defined
1857
          && eh->u.weakdef->root.type != bfd_link_hash_defweak)
1858
        abort ();
1859
      eh->root.u.def.section = eh->u.weakdef->root.u.def.section;
1860
      eh->root.u.def.value = eh->u.weakdef->root.u.def.value;
1861
      if (ELIMINATE_COPY_RELOCS)
1862
        eh->non_got_ref = eh->u.weakdef->non_got_ref;
1863
      return TRUE;
1864
    }
1865
 
1866
  /* This is a reference to a symbol defined by a dynamic object which
1867
     is not a function.  */
1868
 
1869
  /* If we are creating a shared library, we must presume that the
1870
     only references to the symbol are via the global offset table.
1871
     For such cases we need not do anything here; the relocations will
1872
     be handled correctly by relocate_section.  */
1873
  if (info->shared)
1874
    return TRUE;
1875
 
1876
  /* If there are no references to this symbol that do not use the
1877
     GOT, we don't need to generate a copy reloc.  */
1878
  if (!eh->non_got_ref)
1879
    return TRUE;
1880
 
1881
  if (ELIMINATE_COPY_RELOCS)
1882
    {
1883
      struct elf32_hppa_link_hash_entry *hh;
1884
      struct elf32_hppa_dyn_reloc_entry *hdh_p;
1885
 
1886
      hh = hppa_elf_hash_entry (eh);
1887
      for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
1888
        {
1889
          sec = hdh_p->sec->output_section;
1890
          if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
1891
            break;
1892
        }
1893
 
1894
      /* If we didn't find any dynamic relocs in read-only sections, then
1895
         we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1896
      if (hdh_p == NULL)
1897
        {
1898
          eh->non_got_ref = 0;
1899
          return TRUE;
1900
        }
1901
    }
1902
 
1903
  if (eh->size == 0)
1904
    {
1905
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1906
                             eh->root.root.string);
1907
      return TRUE;
1908
    }
1909
 
1910
  /* We must allocate the symbol in our .dynbss section, which will
1911
     become part of the .bss section of the executable.  There will be
1912
     an entry for this symbol in the .dynsym section.  The dynamic
1913
     object will contain position independent code, so all references
1914
     from the dynamic object to this symbol will go through the global
1915
     offset table.  The dynamic linker will use the .dynsym entry to
1916
     determine the address it must put in the global offset table, so
1917
     both the dynamic object and the regular object will refer to the
1918
     same memory location for the variable.  */
1919
 
1920
  htab = hppa_link_hash_table (info);
1921
  if (htab == NULL)
1922
    return FALSE;
1923
 
1924
  /* We must generate a COPY reloc to tell the dynamic linker to
1925
     copy the initial value out of the dynamic object and into the
1926
     runtime process image.  */
1927
  if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0)
1928
    {
1929
      htab->srelbss->size += sizeof (Elf32_External_Rela);
1930
      eh->needs_copy = 1;
1931
    }
1932
 
1933
  sec = htab->sdynbss;
1934
 
1935
  return _bfd_elf_adjust_dynamic_copy (eh, sec);
1936
}
1937
 
1938
/* Allocate space in the .plt for entries that won't have relocations.
1939
   ie. plabel entries.  */
1940
 
1941
static bfd_boolean
1942
allocate_plt_static (struct elf_link_hash_entry *eh, void *inf)
1943
{
1944
  struct bfd_link_info *info;
1945
  struct elf32_hppa_link_hash_table *htab;
1946
  struct elf32_hppa_link_hash_entry *hh;
1947
  asection *sec;
1948
 
1949
  if (eh->root.type == bfd_link_hash_indirect)
1950
    return TRUE;
1951
 
1952
  if (eh->root.type == bfd_link_hash_warning)
1953
    eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
1954
 
1955
  info = (struct bfd_link_info *) inf;
1956
  hh = hppa_elf_hash_entry (eh);
1957
  htab = hppa_link_hash_table (info);
1958
  if (htab == NULL)
1959
    return FALSE;
1960
 
1961
  if (htab->etab.dynamic_sections_created
1962
      && eh->plt.refcount > 0)
1963
    {
1964
      /* Make sure this symbol is output as a dynamic symbol.
1965
         Undefined weak syms won't yet be marked as dynamic.  */
1966
      if (eh->dynindx == -1
1967
          && !eh->forced_local
1968
          && eh->type != STT_PARISC_MILLI)
1969
        {
1970
          if (! bfd_elf_link_record_dynamic_symbol (info, eh))
1971
            return FALSE;
1972
        }
1973
 
1974
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, eh))
1975
        {
1976
          /* Allocate these later.  From this point on, h->plabel
1977
             means that the plt entry is only used by a plabel.
1978
             We'll be using a normal plt entry for this symbol, so
1979
             clear the plabel indicator.  */
1980
 
1981
          hh->plabel = 0;
1982
        }
1983
      else if (hh->plabel)
1984
        {
1985
          /* Make an entry in the .plt section for plabel references
1986
             that won't have a .plt entry for other reasons.  */
1987
          sec = htab->splt;
1988
          eh->plt.offset = sec->size;
1989
          sec->size += PLT_ENTRY_SIZE;
1990
        }
1991
      else
1992
        {
1993
          /* No .plt entry needed.  */
1994
          eh->plt.offset = (bfd_vma) -1;
1995
          eh->needs_plt = 0;
1996
        }
1997
    }
1998
  else
1999
    {
2000
      eh->plt.offset = (bfd_vma) -1;
2001
      eh->needs_plt = 0;
2002
    }
2003
 
2004
  return TRUE;
2005
}
2006
 
2007
/* Allocate space in .plt, .got and associated reloc sections for
2008
   global syms.  */
2009
 
2010
static bfd_boolean
2011
allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
2012
{
2013
  struct bfd_link_info *info;
2014
  struct elf32_hppa_link_hash_table *htab;
2015
  asection *sec;
2016
  struct elf32_hppa_link_hash_entry *hh;
2017
  struct elf32_hppa_dyn_reloc_entry *hdh_p;
2018
 
2019
  if (eh->root.type == bfd_link_hash_indirect)
2020
    return TRUE;
2021
 
2022
  if (eh->root.type == bfd_link_hash_warning)
2023
    eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
2024
 
2025
  info = inf;
2026
  htab = hppa_link_hash_table (info);
2027
  if (htab == NULL)
2028
    return FALSE;
2029
 
2030
  hh = hppa_elf_hash_entry (eh);
2031
 
2032
  if (htab->etab.dynamic_sections_created
2033
      && eh->plt.offset != (bfd_vma) -1
2034
      && !hh->plabel
2035
      && eh->plt.refcount > 0)
2036
    {
2037
      /* Make an entry in the .plt section.  */
2038
      sec = htab->splt;
2039
      eh->plt.offset = sec->size;
2040
      sec->size += PLT_ENTRY_SIZE;
2041
 
2042
      /* We also need to make an entry in the .rela.plt section.  */
2043
      htab->srelplt->size += sizeof (Elf32_External_Rela);
2044
      htab->need_plt_stub = 1;
2045
    }
2046
 
2047
  if (eh->got.refcount > 0)
2048
    {
2049
      /* Make sure this symbol is output as a dynamic symbol.
2050
         Undefined weak syms won't yet be marked as dynamic.  */
2051
      if (eh->dynindx == -1
2052
          && !eh->forced_local
2053
          && eh->type != STT_PARISC_MILLI)
2054
        {
2055
          if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2056
            return FALSE;
2057
        }
2058
 
2059
      sec = htab->sgot;
2060
      eh->got.offset = sec->size;
2061
      sec->size += GOT_ENTRY_SIZE;
2062
      /* R_PARISC_TLS_GD* needs two GOT entries */
2063
      if ((hh->tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE))
2064
        sec->size += GOT_ENTRY_SIZE * 2;
2065
      else if ((hh->tls_type & GOT_TLS_GD) == GOT_TLS_GD)
2066
        sec->size += GOT_ENTRY_SIZE;
2067
      if (htab->etab.dynamic_sections_created
2068
          && (info->shared
2069
              || (eh->dynindx != -1
2070
                  && !eh->forced_local)))
2071
        {
2072
          htab->srelgot->size += sizeof (Elf32_External_Rela);
2073
          if ((hh->tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE))
2074
            htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
2075
          else if ((hh->tls_type & GOT_TLS_GD) == GOT_TLS_GD)
2076
            htab->srelgot->size += sizeof (Elf32_External_Rela);
2077
        }
2078
    }
2079
  else
2080
    eh->got.offset = (bfd_vma) -1;
2081
 
2082
  if (hh->dyn_relocs == NULL)
2083
    return TRUE;
2084
 
2085
  /* If this is a -Bsymbolic shared link, then we need to discard all
2086
     space allocated for dynamic pc-relative relocs against symbols
2087
     defined in a regular object.  For the normal shared case, discard
2088
     space for relocs that have become local due to symbol visibility
2089
     changes.  */
2090
  if (info->shared)
2091
    {
2092
#if RELATIVE_DYNRELOCS
2093
      if (SYMBOL_CALLS_LOCAL (info, eh))
2094
        {
2095
          struct elf32_hppa_dyn_reloc_entry **hdh_pp;
2096
 
2097
          for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
2098
            {
2099
              hdh_p->count -= hdh_p->relative_count;
2100
              hdh_p->relative_count = 0;
2101
              if (hdh_p->count == 0)
2102
                *hdh_pp = hdh_p->hdh_next;
2103
              else
2104
                hdh_pp = &hdh_p->hdh_next;
2105
            }
2106
        }
2107
#endif
2108
 
2109
      /* Also discard relocs on undefined weak syms with non-default
2110
         visibility.  */
2111
      if (hh->dyn_relocs != NULL
2112
          && eh->root.type == bfd_link_hash_undefweak)
2113
        {
2114
          if (ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT)
2115
            hh->dyn_relocs = NULL;
2116
 
2117
          /* Make sure undefined weak symbols are output as a dynamic
2118
             symbol in PIEs.  */
2119
          else if (eh->dynindx == -1
2120
                   && !eh->forced_local)
2121
            {
2122
              if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2123
                return FALSE;
2124
            }
2125
        }
2126
    }
2127
  else
2128
    {
2129
      /* For the non-shared case, discard space for relocs against
2130
         symbols which turn out to need copy relocs or are not
2131
         dynamic.  */
2132
 
2133
      if (!eh->non_got_ref
2134
          && ((ELIMINATE_COPY_RELOCS
2135
               && eh->def_dynamic
2136
               && !eh->def_regular)
2137
               || (htab->etab.dynamic_sections_created
2138
                   && (eh->root.type == bfd_link_hash_undefweak
2139
                       || eh->root.type == bfd_link_hash_undefined))))
2140
        {
2141
          /* Make sure this symbol is output as a dynamic symbol.
2142
             Undefined weak syms won't yet be marked as dynamic.  */
2143
          if (eh->dynindx == -1
2144
              && !eh->forced_local
2145
              && eh->type != STT_PARISC_MILLI)
2146
            {
2147
              if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2148
                return FALSE;
2149
            }
2150
 
2151
          /* If that succeeded, we know we'll be keeping all the
2152
             relocs.  */
2153
          if (eh->dynindx != -1)
2154
            goto keep;
2155
        }
2156
 
2157
      hh->dyn_relocs = NULL;
2158
      return TRUE;
2159
 
2160
    keep: ;
2161
    }
2162
 
2163
  /* Finally, allocate space.  */
2164
  for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
2165
    {
2166
      asection *sreloc = elf_section_data (hdh_p->sec)->sreloc;
2167
      sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela);
2168
    }
2169
 
2170
  return TRUE;
2171
}
2172
 
2173
/* This function is called via elf_link_hash_traverse to force
2174
   millicode symbols local so they do not end up as globals in the
2175
   dynamic symbol table.  We ought to be able to do this in
2176
   adjust_dynamic_symbol, but our adjust_dynamic_symbol is not called
2177
   for all dynamic symbols.  Arguably, this is a bug in
2178
   elf_adjust_dynamic_symbol.  */
2179
 
2180
static bfd_boolean
2181
clobber_millicode_symbols (struct elf_link_hash_entry *eh,
2182
                           struct bfd_link_info *info)
2183
{
2184
  if (eh->root.type == bfd_link_hash_warning)
2185
    eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
2186
 
2187
  if (eh->type == STT_PARISC_MILLI
2188
      && !eh->forced_local)
2189
    {
2190
      elf32_hppa_hide_symbol (info, eh, TRUE);
2191
    }
2192
  return TRUE;
2193
}
2194
 
2195
/* Find any dynamic relocs that apply to read-only sections.  */
2196
 
2197
static bfd_boolean
2198
readonly_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
2199
{
2200
  struct elf32_hppa_link_hash_entry *hh;
2201
  struct elf32_hppa_dyn_reloc_entry *hdh_p;
2202
 
2203
  if (eh->root.type == bfd_link_hash_warning)
2204
    eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
2205
 
2206
  hh = hppa_elf_hash_entry (eh);
2207
  for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
2208
    {
2209
      asection *sec = hdh_p->sec->output_section;
2210
 
2211
      if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
2212
        {
2213
          struct bfd_link_info *info = inf;
2214
 
2215
          info->flags |= DF_TEXTREL;
2216
 
2217
          /* Not an error, just cut short the traversal.  */
2218
          return FALSE;
2219
        }
2220
    }
2221
  return TRUE;
2222
}
2223
 
2224
/* Set the sizes of the dynamic sections.  */
2225
 
2226
static bfd_boolean
2227
elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2228
                                  struct bfd_link_info *info)
2229
{
2230
  struct elf32_hppa_link_hash_table *htab;
2231
  bfd *dynobj;
2232
  bfd *ibfd;
2233
  asection *sec;
2234
  bfd_boolean relocs;
2235
 
2236
  htab = hppa_link_hash_table (info);
2237
  if (htab == NULL)
2238
    return FALSE;
2239
 
2240
  dynobj = htab->etab.dynobj;
2241
  if (dynobj == NULL)
2242
    abort ();
2243
 
2244
  if (htab->etab.dynamic_sections_created)
2245
    {
2246
      /* Set the contents of the .interp section to the interpreter.  */
2247
      if (info->executable)
2248
        {
2249
          sec = bfd_get_section_by_name (dynobj, ".interp");
2250
          if (sec == NULL)
2251
            abort ();
2252
          sec->size = sizeof ELF_DYNAMIC_INTERPRETER;
2253
          sec->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2254
        }
2255
 
2256
      /* Force millicode symbols local.  */
2257
      elf_link_hash_traverse (&htab->etab,
2258
                              clobber_millicode_symbols,
2259
                              info);
2260
    }
2261
 
2262
  /* Set up .got and .plt offsets for local syms, and space for local
2263
     dynamic relocs.  */
2264
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2265
    {
2266
      bfd_signed_vma *local_got;
2267
      bfd_signed_vma *end_local_got;
2268
      bfd_signed_vma *local_plt;
2269
      bfd_signed_vma *end_local_plt;
2270
      bfd_size_type locsymcount;
2271
      Elf_Internal_Shdr *symtab_hdr;
2272
      asection *srel;
2273
      char *local_tls_type;
2274
 
2275
      if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2276
        continue;
2277
 
2278
      for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2279
        {
2280
          struct elf32_hppa_dyn_reloc_entry *hdh_p;
2281
 
2282
          for (hdh_p = ((struct elf32_hppa_dyn_reloc_entry *)
2283
                    elf_section_data (sec)->local_dynrel);
2284
               hdh_p != NULL;
2285
               hdh_p = hdh_p->hdh_next)
2286
            {
2287
              if (!bfd_is_abs_section (hdh_p->sec)
2288
                  && bfd_is_abs_section (hdh_p->sec->output_section))
2289
                {
2290
                  /* Input section has been discarded, either because
2291
                     it is a copy of a linkonce section or due to
2292
                     linker script /DISCARD/, so we'll be discarding
2293
                     the relocs too.  */
2294
                }
2295
              else if (hdh_p->count != 0)
2296
                {
2297
                  srel = elf_section_data (hdh_p->sec)->sreloc;
2298
                  srel->size += hdh_p->count * sizeof (Elf32_External_Rela);
2299
                  if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0)
2300
                    info->flags |= DF_TEXTREL;
2301
                }
2302
            }
2303
        }
2304
 
2305
      local_got = elf_local_got_refcounts (ibfd);
2306
      if (!local_got)
2307
        continue;
2308
 
2309
      symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2310
      locsymcount = symtab_hdr->sh_info;
2311
      end_local_got = local_got + locsymcount;
2312
      local_tls_type = hppa_elf_local_got_tls_type (ibfd);
2313
      sec = htab->sgot;
2314
      srel = htab->srelgot;
2315
      for (; local_got < end_local_got; ++local_got)
2316
        {
2317
          if (*local_got > 0)
2318
            {
2319
              *local_got = sec->size;
2320
              sec->size += GOT_ENTRY_SIZE;
2321
              if ((*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE))
2322
                sec->size += 2 * GOT_ENTRY_SIZE;
2323
              else if ((*local_tls_type & GOT_TLS_GD) == GOT_TLS_GD)
2324
                sec->size += GOT_ENTRY_SIZE;
2325
              if (info->shared)
2326
                {
2327
                  srel->size += sizeof (Elf32_External_Rela);
2328
                  if ((*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE))
2329
                    srel->size += 2 * sizeof (Elf32_External_Rela);
2330
                  else if ((*local_tls_type & GOT_TLS_GD) == GOT_TLS_GD)
2331
                    srel->size += sizeof (Elf32_External_Rela);
2332
                }
2333
            }
2334
          else
2335
            *local_got = (bfd_vma) -1;
2336
 
2337
          ++local_tls_type;
2338
        }
2339
 
2340
      local_plt = end_local_got;
2341
      end_local_plt = local_plt + locsymcount;
2342
      if (! htab->etab.dynamic_sections_created)
2343
        {
2344
          /* Won't be used, but be safe.  */
2345
          for (; local_plt < end_local_plt; ++local_plt)
2346
            *local_plt = (bfd_vma) -1;
2347
        }
2348
      else
2349
        {
2350
          sec = htab->splt;
2351
          srel = htab->srelplt;
2352
          for (; local_plt < end_local_plt; ++local_plt)
2353
            {
2354
              if (*local_plt > 0)
2355
                {
2356
                  *local_plt = sec->size;
2357
                  sec->size += PLT_ENTRY_SIZE;
2358
                  if (info->shared)
2359
                    srel->size += sizeof (Elf32_External_Rela);
2360
                }
2361
              else
2362
                *local_plt = (bfd_vma) -1;
2363
            }
2364
        }
2365
    }
2366
 
2367
  if (htab->tls_ldm_got.refcount > 0)
2368
    {
2369
      /* Allocate 2 got entries and 1 dynamic reloc for
2370
         R_PARISC_TLS_DTPMOD32 relocs.  */
2371
      htab->tls_ldm_got.offset = htab->sgot->size;
2372
      htab->sgot->size += (GOT_ENTRY_SIZE * 2);
2373
      htab->srelgot->size += sizeof (Elf32_External_Rela);
2374
    }
2375
  else
2376
    htab->tls_ldm_got.offset = -1;
2377
 
2378
  /* Do all the .plt entries without relocs first.  The dynamic linker
2379
     uses the last .plt reloc to find the end of the .plt (and hence
2380
     the start of the .got) for lazy linking.  */
2381
  elf_link_hash_traverse (&htab->etab, allocate_plt_static, info);
2382
 
2383
  /* Allocate global sym .plt and .got entries, and space for global
2384
     sym dynamic relocs.  */
2385
  elf_link_hash_traverse (&htab->etab, allocate_dynrelocs, info);
2386
 
2387
  /* The check_relocs and adjust_dynamic_symbol entry points have
2388
     determined the sizes of the various dynamic sections.  Allocate
2389
     memory for them.  */
2390
  relocs = FALSE;
2391
  for (sec = dynobj->sections; sec != NULL; sec = sec->next)
2392
    {
2393
      if ((sec->flags & SEC_LINKER_CREATED) == 0)
2394
        continue;
2395
 
2396
      if (sec == htab->splt)
2397
        {
2398
          if (htab->need_plt_stub)
2399
            {
2400
              /* Make space for the plt stub at the end of the .plt
2401
                 section.  We want this stub right at the end, up
2402
                 against the .got section.  */
2403
              int gotalign = bfd_section_alignment (dynobj, htab->sgot);
2404
              int pltalign = bfd_section_alignment (dynobj, sec);
2405
              bfd_size_type mask;
2406
 
2407
              if (gotalign > pltalign)
2408
                bfd_set_section_alignment (dynobj, sec, gotalign);
2409
              mask = ((bfd_size_type) 1 << gotalign) - 1;
2410
              sec->size = (sec->size + sizeof (plt_stub) + mask) & ~mask;
2411
            }
2412
        }
2413
      else if (sec == htab->sgot
2414
               || sec == htab->sdynbss)
2415
        ;
2416
      else if (CONST_STRNEQ (bfd_get_section_name (dynobj, sec), ".rela"))
2417
        {
2418
          if (sec->size != 0)
2419
            {
2420
              /* Remember whether there are any reloc sections other
2421
                 than .rela.plt.  */
2422
              if (sec != htab->srelplt)
2423
                relocs = TRUE;
2424
 
2425
              /* We use the reloc_count field as a counter if we need
2426
                 to copy relocs into the output file.  */
2427
              sec->reloc_count = 0;
2428
            }
2429
        }
2430
      else
2431
        {
2432
          /* It's not one of our sections, so don't allocate space.  */
2433
          continue;
2434
        }
2435
 
2436
      if (sec->size == 0)
2437
        {
2438
          /* If we don't need this section, strip it from the
2439
             output file.  This is mostly to handle .rela.bss and
2440
             .rela.plt.  We must create both sections in
2441
             create_dynamic_sections, because they must be created
2442
             before the linker maps input sections to output
2443
             sections.  The linker does that before
2444
             adjust_dynamic_symbol is called, and it is that
2445
             function which decides whether anything needs to go
2446
             into these sections.  */
2447
          sec->flags |= SEC_EXCLUDE;
2448
          continue;
2449
        }
2450
 
2451
      if ((sec->flags & SEC_HAS_CONTENTS) == 0)
2452
        continue;
2453
 
2454
      /* Allocate memory for the section contents.  Zero it, because
2455
         we may not fill in all the reloc sections.  */
2456
      sec->contents = bfd_zalloc (dynobj, sec->size);
2457
      if (sec->contents == NULL)
2458
        return FALSE;
2459
    }
2460
 
2461
  if (htab->etab.dynamic_sections_created)
2462
    {
2463
      /* Like IA-64 and HPPA64, always create a DT_PLTGOT.  It
2464
         actually has nothing to do with the PLT, it is how we
2465
         communicate the LTP value of a load module to the dynamic
2466
         linker.  */
2467
#define add_dynamic_entry(TAG, VAL) \
2468
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2469
 
2470
      if (!add_dynamic_entry (DT_PLTGOT, 0))
2471
        return FALSE;
2472
 
2473
      /* Add some entries to the .dynamic section.  We fill in the
2474
         values later, in elf32_hppa_finish_dynamic_sections, but we
2475
         must add the entries now so that we get the correct size for
2476
         the .dynamic section.  The DT_DEBUG entry is filled in by the
2477
         dynamic linker and used by the debugger.  */
2478
      if (info->executable)
2479
        {
2480
          if (!add_dynamic_entry (DT_DEBUG, 0))
2481
            return FALSE;
2482
        }
2483
 
2484
      if (htab->srelplt->size != 0)
2485
        {
2486
          if (!add_dynamic_entry (DT_PLTRELSZ, 0)
2487
              || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2488
              || !add_dynamic_entry (DT_JMPREL, 0))
2489
            return FALSE;
2490
        }
2491
 
2492
      if (relocs)
2493
        {
2494
          if (!add_dynamic_entry (DT_RELA, 0)
2495
              || !add_dynamic_entry (DT_RELASZ, 0)
2496
              || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2497
            return FALSE;
2498
 
2499
          /* If any dynamic relocs apply to a read-only section,
2500
             then we need a DT_TEXTREL entry.  */
2501
          if ((info->flags & DF_TEXTREL) == 0)
2502
            elf_link_hash_traverse (&htab->etab, readonly_dynrelocs, info);
2503
 
2504
          if ((info->flags & DF_TEXTREL) != 0)
2505
            {
2506
              if (!add_dynamic_entry (DT_TEXTREL, 0))
2507
                return FALSE;
2508
            }
2509
        }
2510
    }
2511
#undef add_dynamic_entry
2512
 
2513
  return TRUE;
2514
}
2515
 
2516
/* External entry points for sizing and building linker stubs.  */
2517
 
2518
/* Set up various things so that we can make a list of input sections
2519
   for each output section included in the link.  Returns -1 on error,
2520
 
2521
 
2522
int
2523
elf32_hppa_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
2524
{
2525
  bfd *input_bfd;
2526
  unsigned int bfd_count;
2527
  int top_id, top_index;
2528
  asection *section;
2529
  asection **input_list, **list;
2530
  bfd_size_type amt;
2531
  struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2532
 
2533
  if (htab == NULL)
2534
    return -1;
2535
 
2536
  /* Count the number of input BFDs and find the top input section id.  */
2537
  for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2538
       input_bfd != NULL;
2539
       input_bfd = input_bfd->link_next)
2540
    {
2541
      bfd_count += 1;
2542
      for (section = input_bfd->sections;
2543
           section != NULL;
2544
           section = section->next)
2545
        {
2546
          if (top_id < section->id)
2547
            top_id = section->id;
2548
        }
2549
    }
2550
  htab->bfd_count = bfd_count;
2551
 
2552
  amt = sizeof (struct map_stub) * (top_id + 1);
2553
  htab->stub_group = bfd_zmalloc (amt);
2554
  if (htab->stub_group == NULL)
2555
    return -1;
2556
 
2557
  /* We can't use output_bfd->section_count here to find the top output
2558
     section index as some sections may have been removed, and
2559
     strip_excluded_output_sections doesn't renumber the indices.  */
2560
  for (section = output_bfd->sections, top_index = 0;
2561
       section != NULL;
2562
       section = section->next)
2563
    {
2564
      if (top_index < section->index)
2565
        top_index = section->index;
2566
    }
2567
 
2568
  htab->top_index = top_index;
2569
  amt = sizeof (asection *) * (top_index + 1);
2570
  input_list = bfd_malloc (amt);
2571
  htab->input_list = input_list;
2572
  if (input_list == NULL)
2573
    return -1;
2574
 
2575
  /* For sections we aren't interested in, mark their entries with a
2576
     value we can check later.  */
2577
  list = input_list + top_index;
2578
  do
2579
    *list = bfd_abs_section_ptr;
2580
  while (list-- != input_list);
2581
 
2582
  for (section = output_bfd->sections;
2583
       section != NULL;
2584
       section = section->next)
2585
    {
2586
      if ((section->flags & SEC_CODE) != 0)
2587
        input_list[section->index] = NULL;
2588
    }
2589
 
2590
  return 1;
2591
}
2592
 
2593
/* The linker repeatedly calls this function for each input section,
2594
   in the order that input sections are linked into output sections.
2595
   Build lists of input sections to determine groupings between which
2596
   we may insert linker stubs.  */
2597
 
2598
void
2599
elf32_hppa_next_input_section (struct bfd_link_info *info, asection *isec)
2600
{
2601
  struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2602
 
2603
  if (htab == NULL)
2604
    return;
2605
 
2606
  if (isec->output_section->index <= htab->top_index)
2607
    {
2608
      asection **list = htab->input_list + isec->output_section->index;
2609
      if (*list != bfd_abs_section_ptr)
2610
        {
2611
          /* Steal the link_sec pointer for our list.  */
2612
#define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
2613
          /* This happens to make the list in reverse order,
2614
             which is what we want.  */
2615
          PREV_SEC (isec) = *list;
2616
          *list = isec;
2617
        }
2618
    }
2619
}
2620
 
2621
/* See whether we can group stub sections together.  Grouping stub
2622
   sections may result in fewer stubs.  More importantly, we need to
2623
   put all .init* and .fini* stubs at the beginning of the .init or
2624
   .fini output sections respectively, because glibc splits the
2625
   _init and _fini functions into multiple parts.  Putting a stub in
2626
   the middle of a function is not a good idea.  */
2627
 
2628
static void
2629
group_sections (struct elf32_hppa_link_hash_table *htab,
2630
                bfd_size_type stub_group_size,
2631
                bfd_boolean stubs_always_before_branch)
2632
{
2633
  asection **list = htab->input_list + htab->top_index;
2634
  do
2635
    {
2636
      asection *tail = *list;
2637
      if (tail == bfd_abs_section_ptr)
2638
        continue;
2639
      while (tail != NULL)
2640
        {
2641
          asection *curr;
2642
          asection *prev;
2643
          bfd_size_type total;
2644
          bfd_boolean big_sec;
2645
 
2646
          curr = tail;
2647
          total = tail->size;
2648
          big_sec = total >= stub_group_size;
2649
 
2650
          while ((prev = PREV_SEC (curr)) != NULL
2651
                 && ((total += curr->output_offset - prev->output_offset)
2652
                     < stub_group_size))
2653
            curr = prev;
2654
 
2655
          /* OK, the size from the start of CURR to the end is less
2656
             than 240000 bytes and thus can be handled by one stub
2657
             section.  (or the tail section is itself larger than
2658
             240000 bytes, in which case we may be toast.)
2659
             We should really be keeping track of the total size of
2660
             stubs added here, as stubs contribute to the final output
2661
             section size.  That's a little tricky, and this way will
2662
             only break if stubs added total more than 22144 bytes, or
2663
             2768 long branch stubs.  It seems unlikely for more than
2664
             2768 different functions to be called, especially from
2665
             code only 240000 bytes long.  This limit used to be
2666
             250000, but c++ code tends to generate lots of little
2667
             functions, and sometimes violated the assumption.  */
2668
          do
2669
            {
2670
              prev = PREV_SEC (tail);
2671
              /* Set up this stub group.  */
2672
              htab->stub_group[tail->id].link_sec = curr;
2673
            }
2674
          while (tail != curr && (tail = prev) != NULL);
2675
 
2676
          /* But wait, there's more!  Input sections up to 240000
2677
             bytes before the stub section can be handled by it too.
2678
             Don't do this if we have a really large section after the
2679
             stubs, as adding more stubs increases the chance that
2680
             branches may not reach into the stub section.  */
2681
          if (!stubs_always_before_branch && !big_sec)
2682
            {
2683
              total = 0;
2684
              while (prev != NULL
2685
                     && ((total += tail->output_offset - prev->output_offset)
2686
                         < stub_group_size))
2687
                {
2688
                  tail = prev;
2689
                  prev = PREV_SEC (tail);
2690
                  htab->stub_group[tail->id].link_sec = curr;
2691
                }
2692
            }
2693
          tail = prev;
2694
        }
2695
    }
2696
  while (list-- != htab->input_list);
2697
  free (htab->input_list);
2698
#undef PREV_SEC
2699
}
2700
 
2701
/* Read in all local syms for all input bfds, and create hash entries
2702
   for export stubs if we are building a multi-subspace shared lib.
2703
   Returns -1 on error, 1 if export stubs created, 0 otherwise.  */
2704
 
2705
static int
2706
get_local_syms (bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *info)
2707
{
2708
  unsigned int bfd_indx;
2709
  Elf_Internal_Sym *local_syms, **all_local_syms;
2710
  int stub_changed = 0;
2711
  struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2712
 
2713
  if (htab == NULL)
2714
    return -1;
2715
 
2716
  /* We want to read in symbol extension records only once.  To do this
2717
     we need to read in the local symbols in parallel and save them for
2718
     later use; so hold pointers to the local symbols in an array.  */
2719
  bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2720
  all_local_syms = bfd_zmalloc (amt);
2721
  htab->all_local_syms = all_local_syms;
2722
  if (all_local_syms == NULL)
2723
    return -1;
2724
 
2725
  /* Walk over all the input BFDs, swapping in local symbols.
2726
     If we are creating a shared library, create hash entries for the
2727
     export stubs.  */
2728
  for (bfd_indx = 0;
2729
       input_bfd != NULL;
2730
       input_bfd = input_bfd->link_next, bfd_indx++)
2731
    {
2732
      Elf_Internal_Shdr *symtab_hdr;
2733
 
2734
      /* We'll need the symbol table in a second.  */
2735
      symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2736
      if (symtab_hdr->sh_info == 0)
2737
        continue;
2738
 
2739
      /* We need an array of the local symbols attached to the input bfd.  */
2740
      local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2741
      if (local_syms == NULL)
2742
        {
2743
          local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2744
                                             symtab_hdr->sh_info, 0,
2745
                                             NULL, NULL, NULL);
2746
          /* Cache them for elf_link_input_bfd.  */
2747
          symtab_hdr->contents = (unsigned char *) local_syms;
2748
        }
2749
      if (local_syms == NULL)
2750
        return -1;
2751
 
2752
      all_local_syms[bfd_indx] = local_syms;
2753
 
2754
      if (info->shared && htab->multi_subspace)
2755
        {
2756
          struct elf_link_hash_entry **eh_syms;
2757
          struct elf_link_hash_entry **eh_symend;
2758
          unsigned int symcount;
2759
 
2760
          symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2761
                      - symtab_hdr->sh_info);
2762
          eh_syms = (struct elf_link_hash_entry **) elf_sym_hashes (input_bfd);
2763
          eh_symend = (struct elf_link_hash_entry **) (eh_syms + symcount);
2764
 
2765
          /* Look through the global syms for functions;  We need to
2766
             build export stubs for all globally visible functions.  */
2767
          for (; eh_syms < eh_symend; eh_syms++)
2768
            {
2769
              struct elf32_hppa_link_hash_entry *hh;
2770
 
2771
              hh = hppa_elf_hash_entry (*eh_syms);
2772
 
2773
              while (hh->eh.root.type == bfd_link_hash_indirect
2774
                     || hh->eh.root.type == bfd_link_hash_warning)
2775
                   hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
2776
 
2777
              /* At this point in the link, undefined syms have been
2778
                 resolved, so we need to check that the symbol was
2779
                 defined in this BFD.  */
2780
              if ((hh->eh.root.type == bfd_link_hash_defined
2781
                   || hh->eh.root.type == bfd_link_hash_defweak)
2782
                  && hh->eh.type == STT_FUNC
2783
                  && hh->eh.root.u.def.section->output_section != NULL
2784
                  && (hh->eh.root.u.def.section->output_section->owner
2785
                      == output_bfd)
2786
                  && hh->eh.root.u.def.section->owner == input_bfd
2787
                  && hh->eh.def_regular
2788
                  && !hh->eh.forced_local
2789
                  && ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT)
2790
                {
2791
                  asection *sec;
2792
                  const char *stub_name;
2793
                  struct elf32_hppa_stub_hash_entry *hsh;
2794
 
2795
                  sec = hh->eh.root.u.def.section;
2796
                  stub_name = hh_name (hh);
2797
                  hsh = hppa_stub_hash_lookup (&htab->bstab,
2798
                                                      stub_name,
2799
                                                      FALSE, FALSE);
2800
                  if (hsh == NULL)
2801
                    {
2802
                      hsh = hppa_add_stub (stub_name, sec, htab);
2803
                      if (!hsh)
2804
                        return -1;
2805
 
2806
                      hsh->target_value = hh->eh.root.u.def.value;
2807
                      hsh->target_section = hh->eh.root.u.def.section;
2808
                      hsh->stub_type = hppa_stub_export;
2809
                      hsh->hh = hh;
2810
                      stub_changed = 1;
2811
                    }
2812
                  else
2813
                    {
2814
                      (*_bfd_error_handler) (_("%B: duplicate export stub %s"),
2815
                                             input_bfd,
2816
                                             stub_name);
2817
                    }
2818
                }
2819
            }
2820
        }
2821
    }
2822
 
2823
  return stub_changed;
2824
}
2825
 
2826
/* Determine and set the size of the stub section for a final link.
2827
 
2828
   The basic idea here is to examine all the relocations looking for
2829
   PC-relative calls to a target that is unreachable with a "bl"
2830
   instruction.  */
2831
 
2832
bfd_boolean
2833
elf32_hppa_size_stubs
2834
  (bfd *output_bfd, bfd *stub_bfd, struct bfd_link_info *info,
2835
   bfd_boolean multi_subspace, bfd_signed_vma group_size,
2836
   asection * (*add_stub_section) (const char *, asection *),
2837
   void (*layout_sections_again) (void))
2838
{
2839
  bfd_size_type stub_group_size;
2840
  bfd_boolean stubs_always_before_branch;
2841
  bfd_boolean stub_changed;
2842
  struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2843
 
2844
  if (htab == NULL)
2845
    return FALSE;
2846
 
2847
  /* Stash our params away.  */
2848
  htab->stub_bfd = stub_bfd;
2849
  htab->multi_subspace = multi_subspace;
2850
  htab->add_stub_section = add_stub_section;
2851
  htab->layout_sections_again = layout_sections_again;
2852
  stubs_always_before_branch = group_size < 0;
2853
  if (group_size < 0)
2854
    stub_group_size = -group_size;
2855
  else
2856
    stub_group_size = group_size;
2857
  if (stub_group_size == 1)
2858
    {
2859
      /* Default values.  */
2860
      if (stubs_always_before_branch)
2861
        {
2862
          stub_group_size = 7680000;
2863
          if (htab->has_17bit_branch || htab->multi_subspace)
2864
            stub_group_size = 240000;
2865
          if (htab->has_12bit_branch)
2866
            stub_group_size = 7500;
2867
        }
2868
      else
2869
        {
2870
          stub_group_size = 6971392;
2871
          if (htab->has_17bit_branch || htab->multi_subspace)
2872
            stub_group_size = 217856;
2873
          if (htab->has_12bit_branch)
2874
            stub_group_size = 6808;
2875
        }
2876
    }
2877
 
2878
  group_sections (htab, stub_group_size, stubs_always_before_branch);
2879
 
2880
  switch (get_local_syms (output_bfd, info->input_bfds, info))
2881
    {
2882
    default:
2883
      if (htab->all_local_syms)
2884
        goto error_ret_free_local;
2885
      return FALSE;
2886
 
2887
    case 0:
2888
      stub_changed = FALSE;
2889
      break;
2890
 
2891
    case 1:
2892
      stub_changed = TRUE;
2893
      break;
2894
    }
2895
 
2896
  while (1)
2897
    {
2898
      bfd *input_bfd;
2899
      unsigned int bfd_indx;
2900
      asection *stub_sec;
2901
 
2902
      for (input_bfd = info->input_bfds, bfd_indx = 0;
2903
           input_bfd != NULL;
2904
           input_bfd = input_bfd->link_next, bfd_indx++)
2905
        {
2906
          Elf_Internal_Shdr *symtab_hdr;
2907
          asection *section;
2908
          Elf_Internal_Sym *local_syms;
2909
 
2910
          /* We'll need the symbol table in a second.  */
2911
          symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2912
          if (symtab_hdr->sh_info == 0)
2913
            continue;
2914
 
2915
          local_syms = htab->all_local_syms[bfd_indx];
2916
 
2917
          /* Walk over each section attached to the input bfd.  */
2918
          for (section = input_bfd->sections;
2919
               section != NULL;
2920
               section = section->next)
2921
            {
2922
              Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2923
 
2924
              /* If there aren't any relocs, then there's nothing more
2925
                 to do.  */
2926
              if ((section->flags & SEC_RELOC) == 0
2927
                  || section->reloc_count == 0)
2928
                continue;
2929
 
2930
              /* If this section is a link-once section that will be
2931
                 discarded, then don't create any stubs.  */
2932
              if (section->output_section == NULL
2933
                  || section->output_section->owner != output_bfd)
2934
                continue;
2935
 
2936
              /* Get the relocs.  */
2937
              internal_relocs
2938
                = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2939
                                             info->keep_memory);
2940
              if (internal_relocs == NULL)
2941
                goto error_ret_free_local;
2942
 
2943
              /* Now examine each relocation.  */
2944
              irela = internal_relocs;
2945
              irelaend = irela + section->reloc_count;
2946
              for (; irela < irelaend; irela++)
2947
                {
2948
                  unsigned int r_type, r_indx;
2949
                  enum elf32_hppa_stub_type stub_type;
2950
                  struct elf32_hppa_stub_hash_entry *hsh;
2951
                  asection *sym_sec;
2952
                  bfd_vma sym_value;
2953
                  bfd_vma destination;
2954
                  struct elf32_hppa_link_hash_entry *hh;
2955
                  char *stub_name;
2956
                  const asection *id_sec;
2957
 
2958
                  r_type = ELF32_R_TYPE (irela->r_info);
2959
                  r_indx = ELF32_R_SYM (irela->r_info);
2960
 
2961
                  if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
2962
                    {
2963
                      bfd_set_error (bfd_error_bad_value);
2964
                    error_ret_free_internal:
2965
                      if (elf_section_data (section)->relocs == NULL)
2966
                        free (internal_relocs);
2967
                      goto error_ret_free_local;
2968
                    }
2969
 
2970
                  /* Only look for stubs on call instructions.  */
2971
                  if (r_type != (unsigned int) R_PARISC_PCREL12F
2972
                      && r_type != (unsigned int) R_PARISC_PCREL17F
2973
                      && r_type != (unsigned int) R_PARISC_PCREL22F)
2974
                    continue;
2975
 
2976
                  /* Now determine the call target, its name, value,
2977
                     section.  */
2978
                  sym_sec = NULL;
2979
                  sym_value = 0;
2980
                  destination = 0;
2981
                  hh = NULL;
2982
                  if (r_indx < symtab_hdr->sh_info)
2983
                    {
2984
                      /* It's a local symbol.  */
2985
                      Elf_Internal_Sym *sym;
2986
                      Elf_Internal_Shdr *hdr;
2987
                      unsigned int shndx;
2988
 
2989
                      sym = local_syms + r_indx;
2990
                      if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2991
                        sym_value = sym->st_value;
2992
                      shndx = sym->st_shndx;
2993
                      if (shndx < elf_numsections (input_bfd))
2994
                        {
2995
                          hdr = elf_elfsections (input_bfd)[shndx];
2996
                          sym_sec = hdr->bfd_section;
2997
                          destination = (sym_value + irela->r_addend
2998
                                         + sym_sec->output_offset
2999
                                         + sym_sec->output_section->vma);
3000
                        }
3001
                    }
3002
                  else
3003
                    {
3004
                      /* It's an external symbol.  */
3005
                      int e_indx;
3006
 
3007
                      e_indx = r_indx - symtab_hdr->sh_info;
3008
                      hh = hppa_elf_hash_entry (elf_sym_hashes (input_bfd)[e_indx]);
3009
 
3010
                      while (hh->eh.root.type == bfd_link_hash_indirect
3011
                             || hh->eh.root.type == bfd_link_hash_warning)
3012
                        hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
3013
 
3014
                      if (hh->eh.root.type == bfd_link_hash_defined
3015
                          || hh->eh.root.type == bfd_link_hash_defweak)
3016
                        {
3017
                          sym_sec = hh->eh.root.u.def.section;
3018
                          sym_value = hh->eh.root.u.def.value;
3019
                          if (sym_sec->output_section != NULL)
3020
                            destination = (sym_value + irela->r_addend
3021
                                           + sym_sec->output_offset
3022
                                           + sym_sec->output_section->vma);
3023
                        }
3024
                      else if (hh->eh.root.type == bfd_link_hash_undefweak)
3025
                        {
3026
                          if (! info->shared)
3027
                            continue;
3028
                        }
3029
                      else if (hh->eh.root.type == bfd_link_hash_undefined)
3030
                        {
3031
                          if (! (info->unresolved_syms_in_objects == RM_IGNORE
3032
                                 && (ELF_ST_VISIBILITY (hh->eh.other)
3033
                                     == STV_DEFAULT)
3034
                                 && hh->eh.type != STT_PARISC_MILLI))
3035
                            continue;
3036
                        }
3037
                      else
3038
                        {
3039
                          bfd_set_error (bfd_error_bad_value);
3040
                          goto error_ret_free_internal;
3041
                        }
3042
                    }
3043
 
3044
                  /* Determine what (if any) linker stub is needed.  */
3045
                  stub_type = hppa_type_of_stub (section, irela, hh,
3046
                                                 destination, info);
3047
                  if (stub_type == hppa_stub_none)
3048
                    continue;
3049
 
3050
                  /* Support for grouping stub sections.  */
3051
                  id_sec = htab->stub_group[section->id].link_sec;
3052
 
3053
                  /* Get the name of this stub.  */
3054
                  stub_name = hppa_stub_name (id_sec, sym_sec, hh, irela);
3055
                  if (!stub_name)
3056
                    goto error_ret_free_internal;
3057
 
3058
                  hsh = hppa_stub_hash_lookup (&htab->bstab,
3059
                                                      stub_name,
3060
                                                      FALSE, FALSE);
3061
                  if (hsh != NULL)
3062
                    {
3063
                      /* The proper stub has already been created.  */
3064
                      free (stub_name);
3065
                      continue;
3066
                    }
3067
 
3068
                  hsh = hppa_add_stub (stub_name, section, htab);
3069
                  if (hsh == NULL)
3070
                    {
3071
                      free (stub_name);
3072
                      goto error_ret_free_internal;
3073
                    }
3074
 
3075
                  hsh->target_value = sym_value;
3076
                  hsh->target_section = sym_sec;
3077
                  hsh->stub_type = stub_type;
3078
                  if (info->shared)
3079
                    {
3080
                      if (stub_type == hppa_stub_import)
3081
                        hsh->stub_type = hppa_stub_import_shared;
3082
                      else if (stub_type == hppa_stub_long_branch)
3083
                        hsh->stub_type = hppa_stub_long_branch_shared;
3084
                    }
3085
                  hsh->hh = hh;
3086
                  stub_changed = TRUE;
3087
                }
3088
 
3089
              /* We're done with the internal relocs, free them.  */
3090
              if (elf_section_data (section)->relocs == NULL)
3091
                free (internal_relocs);
3092
            }
3093
        }
3094
 
3095
      if (!stub_changed)
3096
        break;
3097
 
3098
      /* OK, we've added some stubs.  Find out the new size of the
3099
         stub sections.  */
3100
      for (stub_sec = htab->stub_bfd->sections;
3101
           stub_sec != NULL;
3102
           stub_sec = stub_sec->next)
3103
        stub_sec->size = 0;
3104
 
3105
      bfd_hash_traverse (&htab->bstab, hppa_size_one_stub, htab);
3106
 
3107
      /* Ask the linker to do its stuff.  */
3108
      (*htab->layout_sections_again) ();
3109
      stub_changed = FALSE;
3110
    }
3111
 
3112
  free (htab->all_local_syms);
3113
  return TRUE;
3114
 
3115
 error_ret_free_local:
3116
  free (htab->all_local_syms);
3117
  return FALSE;
3118
}
3119
 
3120
/* For a final link, this function is called after we have sized the
3121
   stubs to provide a value for __gp.  */
3122
 
3123
bfd_boolean
3124
elf32_hppa_set_gp (bfd *abfd, struct bfd_link_info *info)
3125
{
3126
  struct bfd_link_hash_entry *h;
3127
  asection *sec = NULL;
3128
  bfd_vma gp_val = 0;
3129
  struct elf32_hppa_link_hash_table *htab;
3130
 
3131
  htab = hppa_link_hash_table (info);
3132
  if (htab == NULL)
3133
    return FALSE;
3134
 
3135
  h = bfd_link_hash_lookup (&htab->etab.root, "$global$", FALSE, FALSE, FALSE);
3136
 
3137
  if (h != NULL
3138
      && (h->type == bfd_link_hash_defined
3139
          || h->type == bfd_link_hash_defweak))
3140
    {
3141
      gp_val = h->u.def.value;
3142
      sec = h->u.def.section;
3143
    }
3144
  else
3145
    {
3146
      asection *splt = bfd_get_section_by_name (abfd, ".plt");
3147
      asection *sgot = bfd_get_section_by_name (abfd, ".got");
3148
 
3149
      /* Choose to point our LTP at, in this order, one of .plt, .got,
3150
         or .data, if these sections exist.  In the case of choosing
3151
         .plt try to make the LTP ideal for addressing anywhere in the
3152
         .plt or .got with a 14 bit signed offset.  Typically, the end
3153
         of the .plt is the start of the .got, so choose .plt + 0x2000
3154
         if either the .plt or .got is larger than 0x2000.  If both
3155
         the .plt and .got are smaller than 0x2000, choose the end of
3156
         the .plt section.  */
3157
      sec = strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0
3158
          ? NULL : splt;
3159
      if (sec != NULL)
3160
        {
3161
          gp_val = sec->size;
3162
          if (gp_val > 0x2000 || (sgot && sgot->size > 0x2000))
3163
            {
3164
              gp_val = 0x2000;
3165
            }
3166
        }
3167
      else
3168
        {
3169
          sec = sgot;
3170
          if (sec != NULL)
3171
            {
3172
              if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") != 0)
3173
                {
3174
                  /* We know we don't have a .plt.  If .got is large,
3175
                     offset our LTP.  */
3176
                  if (sec->size > 0x2000)
3177
                    gp_val = 0x2000;
3178
                }
3179
            }
3180
          else
3181
            {
3182
              /* No .plt or .got.  Who cares what the LTP is?  */
3183
              sec = bfd_get_section_by_name (abfd, ".data");
3184
            }
3185
        }
3186
 
3187
      if (h != NULL)
3188
        {
3189
          h->type = bfd_link_hash_defined;
3190
          h->u.def.value = gp_val;
3191
          if (sec != NULL)
3192
            h->u.def.section = sec;
3193
          else
3194
            h->u.def.section = bfd_abs_section_ptr;
3195
        }
3196
    }
3197
 
3198
  if (sec != NULL && sec->output_section != NULL)
3199
    gp_val += sec->output_section->vma + sec->output_offset;
3200
 
3201
  elf_gp (abfd) = gp_val;
3202
  return TRUE;
3203
}
3204
 
3205
/* Build all the stubs associated with the current output file.  The
3206
   stubs are kept in a hash table attached to the main linker hash
3207
   table.  We also set up the .plt entries for statically linked PIC
3208
   functions here.  This function is called via hppaelf_finish in the
3209
   linker.  */
3210
 
3211
bfd_boolean
3212
elf32_hppa_build_stubs (struct bfd_link_info *info)
3213
{
3214
  asection *stub_sec;
3215
  struct bfd_hash_table *table;
3216
  struct elf32_hppa_link_hash_table *htab;
3217
 
3218
  htab = hppa_link_hash_table (info);
3219
  if (htab == NULL)
3220
    return FALSE;
3221
 
3222
  for (stub_sec = htab->stub_bfd->sections;
3223
       stub_sec != NULL;
3224
       stub_sec = stub_sec->next)
3225
    {
3226
      bfd_size_type size;
3227
 
3228
      /* Allocate memory to hold the linker stubs.  */
3229
      size = stub_sec->size;
3230
      stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3231
      if (stub_sec->contents == NULL && size != 0)
3232
        return FALSE;
3233
      stub_sec->size = 0;
3234
    }
3235
 
3236
  /* Build the stubs as directed by the stub hash table.  */
3237
  table = &htab->bstab;
3238
  bfd_hash_traverse (table, hppa_build_one_stub, info);
3239
 
3240
  return TRUE;
3241
}
3242
 
3243
/* Return the base vma address which should be subtracted from the real
3244
   address when resolving a dtpoff relocation.
3245
   This is PT_TLS segment p_vaddr.  */
3246
 
3247
static bfd_vma
3248
dtpoff_base (struct bfd_link_info *info)
3249
{
3250
  /* If tls_sec is NULL, we should have signalled an error already.  */
3251
  if (elf_hash_table (info)->tls_sec == NULL)
3252
    return 0;
3253
  return elf_hash_table (info)->tls_sec->vma;
3254
}
3255
 
3256
/* Return the relocation value for R_PARISC_TLS_TPOFF*..  */
3257
 
3258
static bfd_vma
3259
tpoff (struct bfd_link_info *info, bfd_vma address)
3260
{
3261
  struct elf_link_hash_table *htab = elf_hash_table (info);
3262
 
3263
  /* If tls_sec is NULL, we should have signalled an error already.  */
3264
  if (htab->tls_sec == NULL)
3265
    return 0;
3266
  /* hppa TLS ABI is variant I and static TLS block start just after
3267
     tcbhead structure which has 2 pointer fields.  */
3268
  return (address - htab->tls_sec->vma
3269
          + align_power ((bfd_vma) 8, htab->tls_sec->alignment_power));
3270
}
3271
 
3272
/* Perform a final link.  */
3273
 
3274
static bfd_boolean
3275
elf32_hppa_final_link (bfd *abfd, struct bfd_link_info *info)
3276
{
3277
  /* Invoke the regular ELF linker to do all the work.  */
3278
  if (!bfd_elf_final_link (abfd, info))
3279
    return FALSE;
3280
 
3281
  /* If we're producing a final executable, sort the contents of the
3282
     unwind section.  */
3283
  if (info->relocatable)
3284
    return TRUE;
3285
 
3286
  return elf_hppa_sort_unwind (abfd);
3287
}
3288
 
3289
/* Record the lowest address for the data and text segments.  */
3290
 
3291
static void
3292
hppa_record_segment_addr (bfd *abfd, asection *section, void *data)
3293
{
3294
  struct elf32_hppa_link_hash_table *htab;
3295
 
3296
  htab = (struct elf32_hppa_link_hash_table*) data;
3297
  if (htab == NULL)
3298
    return;
3299
 
3300
  if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3301
    {
3302
      bfd_vma value;
3303
      Elf_Internal_Phdr *p;
3304
 
3305
      p = _bfd_elf_find_segment_containing_section (abfd, section->output_section);
3306
      BFD_ASSERT (p != NULL);
3307
      value = p->p_vaddr;
3308
 
3309
      if ((section->flags & SEC_READONLY) != 0)
3310
        {
3311
          if (value < htab->text_segment_base)
3312
            htab->text_segment_base = value;
3313
        }
3314
      else
3315
        {
3316
          if (value < htab->data_segment_base)
3317
            htab->data_segment_base = value;
3318
        }
3319
    }
3320
}
3321
 
3322
/* Perform a relocation as part of a final link.  */
3323
 
3324
static bfd_reloc_status_type
3325
final_link_relocate (asection *input_section,
3326
                     bfd_byte *contents,
3327
                     const Elf_Internal_Rela *rela,
3328
                     bfd_vma value,
3329
                     struct elf32_hppa_link_hash_table *htab,
3330
                     asection *sym_sec,
3331
                     struct elf32_hppa_link_hash_entry *hh,
3332
                     struct bfd_link_info *info)
3333
{
3334
  int insn;
3335
  unsigned int r_type = ELF32_R_TYPE (rela->r_info);
3336
  unsigned int orig_r_type = r_type;
3337
  reloc_howto_type *howto = elf_hppa_howto_table + r_type;
3338
  int r_format = howto->bitsize;
3339
  enum hppa_reloc_field_selector_type_alt r_field;
3340
  bfd *input_bfd = input_section->owner;
3341
  bfd_vma offset = rela->r_offset;
3342
  bfd_vma max_branch_offset = 0;
3343
  bfd_byte *hit_data = contents + offset;
3344
  bfd_signed_vma addend = rela->r_addend;
3345
  bfd_vma location;
3346
  struct elf32_hppa_stub_hash_entry *hsh = NULL;
3347
  int val;
3348
 
3349
  if (r_type == R_PARISC_NONE)
3350
    return bfd_reloc_ok;
3351
 
3352
  insn = bfd_get_32 (input_bfd, hit_data);
3353
 
3354
  /* Find out where we are and where we're going.  */
3355
  location = (offset +
3356
              input_section->output_offset +
3357
              input_section->output_section->vma);
3358
 
3359
  /* If we are not building a shared library, convert DLTIND relocs to
3360
     DPREL relocs.  */
3361
  if (!info->shared)
3362
    {
3363
      switch (r_type)
3364
        {
3365
          case R_PARISC_DLTIND21L:
3366
            r_type = R_PARISC_DPREL21L;
3367
            break;
3368
 
3369
          case R_PARISC_DLTIND14R:
3370
            r_type = R_PARISC_DPREL14R;
3371
            break;
3372
 
3373
          case R_PARISC_DLTIND14F:
3374
            r_type = R_PARISC_DPREL14F;
3375
            break;
3376
        }
3377
    }
3378
 
3379
  switch (r_type)
3380
    {
3381
    case R_PARISC_PCREL12F:
3382
    case R_PARISC_PCREL17F:
3383
    case R_PARISC_PCREL22F:
3384
      /* If this call should go via the plt, find the import stub in
3385
         the stub hash.  */
3386
      if (sym_sec == NULL
3387
          || sym_sec->output_section == NULL
3388
          || (hh != NULL
3389
              && hh->eh.plt.offset != (bfd_vma) -1
3390
              && hh->eh.dynindx != -1
3391
              && !hh->plabel
3392
              && (info->shared
3393
                  || !hh->eh.def_regular
3394
                  || hh->eh.root.type == bfd_link_hash_defweak)))
3395
        {
3396
          hsh = hppa_get_stub_entry (input_section, sym_sec,
3397
                                            hh, rela, htab);
3398
          if (hsh != NULL)
3399
            {
3400
              value = (hsh->stub_offset
3401
                       + hsh->stub_sec->output_offset
3402
                       + hsh->stub_sec->output_section->vma);
3403
              addend = 0;
3404
            }
3405
          else if (sym_sec == NULL && hh != NULL
3406
                   && hh->eh.root.type == bfd_link_hash_undefweak)
3407
            {
3408
              /* It's OK if undefined weak.  Calls to undefined weak
3409
                 symbols behave as if the "called" function
3410
                 immediately returns.  We can thus call to a weak
3411
                 function without first checking whether the function
3412
                 is defined.  */
3413
              value = location;
3414
              addend = 8;
3415
            }
3416
          else
3417
            return bfd_reloc_undefined;
3418
        }
3419
      /* Fall thru.  */
3420
 
3421
    case R_PARISC_PCREL21L:
3422
    case R_PARISC_PCREL17C:
3423
    case R_PARISC_PCREL17R:
3424
    case R_PARISC_PCREL14R:
3425
    case R_PARISC_PCREL14F:
3426
    case R_PARISC_PCREL32:
3427
      /* Make it a pc relative offset.  */
3428
      value -= location;
3429
      addend -= 8;
3430
      break;
3431
 
3432
    case R_PARISC_DPREL21L:
3433
    case R_PARISC_DPREL14R:
3434
    case R_PARISC_DPREL14F:
3435
    case R_PARISC_TLS_GD21L:
3436
    case R_PARISC_TLS_LDM21L:
3437
    case R_PARISC_TLS_IE21L:
3438
      /* Convert instructions that use the linkage table pointer (r19) to
3439
         instructions that use the global data pointer (dp).  This is the
3440
         most efficient way of using PIC code in an incomplete executable,
3441
         but the user must follow the standard runtime conventions for
3442
         accessing data for this to work.  */
3443
      if (orig_r_type == R_PARISC_DLTIND21L
3444
          || (!info->shared
3445
              && (r_type == R_PARISC_TLS_GD21L
3446
                  || r_type == R_PARISC_TLS_LDM21L
3447
                  || r_type == R_PARISC_TLS_IE21L)))
3448
        {
3449
          /* Convert addil instructions if the original reloc was a
3450
             DLTIND21L.  GCC sometimes uses a register other than r19 for
3451
             the operation, so we must convert any addil instruction
3452
             that uses this relocation.  */
3453
          if ((insn & 0xfc000000) == ((int) OP_ADDIL << 26))
3454
            insn = ADDIL_DP;
3455
          else
3456
            /* We must have a ldil instruction.  It's too hard to find
3457
               and convert the associated add instruction, so issue an
3458
               error.  */
3459
            (*_bfd_error_handler)
3460
              (_("%B(%A+0x%lx): %s fixup for insn 0x%x is not supported in a non-shared link"),
3461
               input_bfd,
3462
               input_section,
3463
               (long) offset,
3464
               howto->name,
3465
               insn);
3466
        }
3467
      else if (orig_r_type == R_PARISC_DLTIND14F)
3468
        {
3469
          /* This must be a format 1 load/store.  Change the base
3470
             register to dp.  */
3471
          insn = (insn & 0xfc1ffff) | (27 << 21);
3472
        }
3473
 
3474
    /* For all the DP relative relocations, we need to examine the symbol's
3475
       section.  If it has no section or if it's a code section, then
3476
       "data pointer relative" makes no sense.  In that case we don't
3477
       adjust the "value", and for 21 bit addil instructions, we change the
3478
       source addend register from %dp to %r0.  This situation commonly
3479
       arises for undefined weak symbols and when a variable's "constness"
3480
       is declared differently from the way the variable is defined.  For
3481
       instance: "extern int foo" with foo defined as "const int foo".  */
3482
      if (sym_sec == NULL || (sym_sec->flags & SEC_CODE) != 0)
3483
        {
3484
          if ((insn & ((0x3f << 26) | (0x1f << 21)))
3485
              == (((int) OP_ADDIL << 26) | (27 << 21)))
3486
            {
3487
              insn &= ~ (0x1f << 21);
3488
            }
3489
          /* Now try to make things easy for the dynamic linker.  */
3490
 
3491
          break;
3492
        }
3493
      /* Fall thru.  */
3494
 
3495
    case R_PARISC_DLTIND21L:
3496
    case R_PARISC_DLTIND14R:
3497
    case R_PARISC_DLTIND14F:
3498
    case R_PARISC_TLS_GD14R:
3499
    case R_PARISC_TLS_LDM14R:
3500
    case R_PARISC_TLS_IE14R:
3501
      value -= elf_gp (input_section->output_section->owner);
3502
      break;
3503
 
3504
    case R_PARISC_SEGREL32:
3505
      if ((sym_sec->flags & SEC_CODE) != 0)
3506
        value -= htab->text_segment_base;
3507
      else
3508
        value -= htab->data_segment_base;
3509
      break;
3510
 
3511
    default:
3512
      break;
3513
    }
3514
 
3515
  switch (r_type)
3516
    {
3517
    case R_PARISC_DIR32:
3518
    case R_PARISC_DIR14F:
3519
    case R_PARISC_DIR17F:
3520
    case R_PARISC_PCREL17C:
3521
    case R_PARISC_PCREL14F:
3522
    case R_PARISC_PCREL32:
3523
    case R_PARISC_DPREL14F:
3524
    case R_PARISC_PLABEL32:
3525
    case R_PARISC_DLTIND14F:
3526
    case R_PARISC_SEGBASE:
3527
    case R_PARISC_SEGREL32:
3528
    case R_PARISC_TLS_DTPMOD32:
3529
    case R_PARISC_TLS_DTPOFF32:
3530
    case R_PARISC_TLS_TPREL32:
3531
      r_field = e_fsel;
3532
      break;
3533
 
3534
    case R_PARISC_DLTIND21L:
3535
    case R_PARISC_PCREL21L:
3536
    case R_PARISC_PLABEL21L:
3537
      r_field = e_lsel;
3538
      break;
3539
 
3540
    case R_PARISC_DIR21L:
3541
    case R_PARISC_DPREL21L:
3542
    case R_PARISC_TLS_GD21L:
3543
    case R_PARISC_TLS_LDM21L:
3544
    case R_PARISC_TLS_LDO21L:
3545
    case R_PARISC_TLS_IE21L:
3546
    case R_PARISC_TLS_LE21L:
3547
      r_field = e_lrsel;
3548
      break;
3549
 
3550
    case R_PARISC_PCREL17R:
3551
    case R_PARISC_PCREL14R:
3552
    case R_PARISC_PLABEL14R:
3553
    case R_PARISC_DLTIND14R:
3554
      r_field = e_rsel;
3555
      break;
3556
 
3557
    case R_PARISC_DIR17R:
3558
    case R_PARISC_DIR14R:
3559
    case R_PARISC_DPREL14R:
3560
    case R_PARISC_TLS_GD14R:
3561
    case R_PARISC_TLS_LDM14R:
3562
    case R_PARISC_TLS_LDO14R:
3563
    case R_PARISC_TLS_IE14R:
3564
    case R_PARISC_TLS_LE14R:
3565
      r_field = e_rrsel;
3566
      break;
3567
 
3568
    case R_PARISC_PCREL12F:
3569
    case R_PARISC_PCREL17F:
3570
    case R_PARISC_PCREL22F:
3571
      r_field = e_fsel;
3572
 
3573
      if (r_type == (unsigned int) R_PARISC_PCREL17F)
3574
        {
3575
          max_branch_offset = (1 << (17-1)) << 2;
3576
        }
3577
      else if (r_type == (unsigned int) R_PARISC_PCREL12F)
3578
        {
3579
          max_branch_offset = (1 << (12-1)) << 2;
3580
        }
3581
      else
3582
        {
3583
          max_branch_offset = (1 << (22-1)) << 2;
3584
        }
3585
 
3586
      /* sym_sec is NULL on undefined weak syms or when shared on
3587
         undefined syms.  We've already checked for a stub for the
3588
         shared undefined case.  */
3589
      if (sym_sec == NULL)
3590
        break;
3591
 
3592
      /* If the branch is out of reach, then redirect the
3593
         call to the local stub for this function.  */
3594
      if (value + addend + max_branch_offset >= 2*max_branch_offset)
3595
        {
3596
          hsh = hppa_get_stub_entry (input_section, sym_sec,
3597
                                            hh, rela, htab);
3598
          if (hsh == NULL)
3599
            return bfd_reloc_undefined;
3600
 
3601
          /* Munge up the value and addend so that we call the stub
3602
             rather than the procedure directly.  */
3603
          value = (hsh->stub_offset
3604
                   + hsh->stub_sec->output_offset
3605
                   + hsh->stub_sec->output_section->vma
3606
                   - location);
3607
          addend = -8;
3608
        }
3609
      break;
3610
 
3611
    /* Something we don't know how to handle.  */
3612
    default:
3613
      return bfd_reloc_notsupported;
3614
    }
3615
 
3616
  /* Make sure we can reach the stub.  */
3617
  if (max_branch_offset != 0
3618
      && value + addend + max_branch_offset >= 2*max_branch_offset)
3619
    {
3620
      (*_bfd_error_handler)
3621
        (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
3622
         input_bfd,
3623
         input_section,
3624
         (long) offset,
3625
         hsh->bh_root.string);
3626
      bfd_set_error (bfd_error_bad_value);
3627
      return bfd_reloc_notsupported;
3628
    }
3629
 
3630
  val = hppa_field_adjust (value, addend, r_field);
3631
 
3632
  switch (r_type)
3633
    {
3634
    case R_PARISC_PCREL12F:
3635
    case R_PARISC_PCREL17C:
3636
    case R_PARISC_PCREL17F:
3637
    case R_PARISC_PCREL17R:
3638
    case R_PARISC_PCREL22F:
3639
    case R_PARISC_DIR17F:
3640
    case R_PARISC_DIR17R:
3641
      /* This is a branch.  Divide the offset by four.
3642
         Note that we need to decide whether it's a branch or
3643
         otherwise by inspecting the reloc.  Inspecting insn won't
3644
         work as insn might be from a .word directive.  */
3645
      val >>= 2;
3646
      break;
3647
 
3648
    default:
3649
      break;
3650
    }
3651
 
3652
  insn = hppa_rebuild_insn (insn, val, r_format);
3653
 
3654
  /* Update the instruction word.  */
3655
  bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
3656
  return bfd_reloc_ok;
3657
}
3658
 
3659
/* Relocate an HPPA ELF section.  */
3660
 
3661
static bfd_boolean
3662
elf32_hppa_relocate_section (bfd *output_bfd,
3663
                             struct bfd_link_info *info,
3664
                             bfd *input_bfd,
3665
                             asection *input_section,
3666
                             bfd_byte *contents,
3667
                             Elf_Internal_Rela *relocs,
3668
                             Elf_Internal_Sym *local_syms,
3669
                             asection **local_sections)
3670
{
3671
  bfd_vma *local_got_offsets;
3672
  struct elf32_hppa_link_hash_table *htab;
3673
  Elf_Internal_Shdr *symtab_hdr;
3674
  Elf_Internal_Rela *rela;
3675
  Elf_Internal_Rela *relend;
3676
 
3677
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3678
 
3679
  htab = hppa_link_hash_table (info);
3680
  if (htab == NULL)
3681
    return FALSE;
3682
 
3683
  local_got_offsets = elf_local_got_offsets (input_bfd);
3684
 
3685
  rela = relocs;
3686
  relend = relocs + input_section->reloc_count;
3687
  for (; rela < relend; rela++)
3688
    {
3689
      unsigned int r_type;
3690
      reloc_howto_type *howto;
3691
      unsigned int r_symndx;
3692
      struct elf32_hppa_link_hash_entry *hh;
3693
      Elf_Internal_Sym *sym;
3694
      asection *sym_sec;
3695
      bfd_vma relocation;
3696
      bfd_reloc_status_type rstatus;
3697
      const char *sym_name;
3698
      bfd_boolean plabel;
3699
      bfd_boolean warned_undef;
3700
 
3701
      r_type = ELF32_R_TYPE (rela->r_info);
3702
      if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
3703
        {
3704
          bfd_set_error (bfd_error_bad_value);
3705
          return FALSE;
3706
        }
3707
      if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
3708
          || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
3709
        continue;
3710
 
3711
      r_symndx = ELF32_R_SYM (rela->r_info);
3712
      hh = NULL;
3713
      sym = NULL;
3714
      sym_sec = NULL;
3715
      warned_undef = FALSE;
3716
      if (r_symndx < symtab_hdr->sh_info)
3717
        {
3718
          /* This is a local symbol, h defaults to NULL.  */
3719
          sym = local_syms + r_symndx;
3720
          sym_sec = local_sections[r_symndx];
3721
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rela);
3722
        }
3723
      else
3724
        {
3725
          struct elf_link_hash_entry *eh;
3726
          bfd_boolean unresolved_reloc;
3727
          struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
3728
 
3729
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rela,
3730
                                   r_symndx, symtab_hdr, sym_hashes,
3731
                                   eh, sym_sec, relocation,
3732
                                   unresolved_reloc, warned_undef);
3733
 
3734
          if (!info->relocatable
3735
              && relocation == 0
3736
              && eh->root.type != bfd_link_hash_defined
3737
              && eh->root.type != bfd_link_hash_defweak
3738
              && eh->root.type != bfd_link_hash_undefweak)
3739
            {
3740
              if (info->unresolved_syms_in_objects == RM_IGNORE
3741
                  && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT
3742
                  && eh->type == STT_PARISC_MILLI)
3743
                {
3744
                  if (! info->callbacks->undefined_symbol
3745
                      (info, eh_name (eh), input_bfd,
3746
                       input_section, rela->r_offset, FALSE))
3747
                    return FALSE;
3748
                  warned_undef = TRUE;
3749
                }
3750
            }
3751
          hh = hppa_elf_hash_entry (eh);
3752
        }
3753
 
3754
      if (sym_sec != NULL && elf_discarded_section (sym_sec))
3755
        {
3756
          /* For relocs against symbols from removed linkonce
3757
             sections, or sections discarded by a linker script,
3758
             we just want the section contents zeroed.  Avoid any
3759
             special processing.  */
3760
          _bfd_clear_contents (elf_hppa_howto_table + r_type, input_bfd,
3761
                               contents + rela->r_offset);
3762
          rela->r_info = 0;
3763
          rela->r_addend = 0;
3764
          continue;
3765
        }
3766
 
3767
      if (info->relocatable)
3768
        continue;
3769
 
3770
      /* Do any required modifications to the relocation value, and
3771
         determine what types of dynamic info we need to output, if
3772
         any.  */
3773
      plabel = 0;
3774
      switch (r_type)
3775
        {
3776
        case R_PARISC_DLTIND14F:
3777
        case R_PARISC_DLTIND14R:
3778
        case R_PARISC_DLTIND21L:
3779
          {
3780
            bfd_vma off;
3781
            bfd_boolean do_got = 0;
3782
 
3783
            /* Relocation is to the entry for this symbol in the
3784
               global offset table.  */
3785
            if (hh != NULL)
3786
              {
3787
                bfd_boolean dyn;
3788
 
3789
                off = hh->eh.got.offset;
3790
                dyn = htab->etab.dynamic_sections_created;
3791
                if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
3792
                                                       &hh->eh))
3793
                  {
3794
                    /* If we aren't going to call finish_dynamic_symbol,
3795
                       then we need to handle initialisation of the .got
3796
                       entry and create needed relocs here.  Since the
3797
                       offset must always be a multiple of 4, we use the
3798
                       least significant bit to record whether we have
3799
                       initialised it already.  */
3800
                    if ((off & 1) != 0)
3801
                      off &= ~1;
3802
                    else
3803
                      {
3804
                        hh->eh.got.offset |= 1;
3805
                        do_got = 1;
3806
                      }
3807
                  }
3808
              }
3809
            else
3810
              {
3811
                /* Local symbol case.  */
3812
                if (local_got_offsets == NULL)
3813
                  abort ();
3814
 
3815
                off = local_got_offsets[r_symndx];
3816
 
3817
                /* The offset must always be a multiple of 4.  We use
3818
                   the least significant bit to record whether we have
3819
                   already generated the necessary reloc.  */
3820
                if ((off & 1) != 0)
3821
                  off &= ~1;
3822
                else
3823
                  {
3824
                    local_got_offsets[r_symndx] |= 1;
3825
                    do_got = 1;
3826
                  }
3827
              }
3828
 
3829
            if (do_got)
3830
              {
3831
                if (info->shared)
3832
                  {
3833
                    /* Output a dynamic relocation for this GOT entry.
3834
                       In this case it is relative to the base of the
3835
                       object because the symbol index is zero.  */
3836
                    Elf_Internal_Rela outrel;
3837
                    bfd_byte *loc;
3838
                    asection *sec = htab->srelgot;
3839
 
3840
                    outrel.r_offset = (off
3841
                                       + htab->sgot->output_offset
3842
                                       + htab->sgot->output_section->vma);
3843
                    outrel.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
3844
                    outrel.r_addend = relocation;
3845
                    loc = sec->contents;
3846
                    loc += sec->reloc_count++ * sizeof (Elf32_External_Rela);
3847
                    bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3848
                  }
3849
                else
3850
                  bfd_put_32 (output_bfd, relocation,
3851
                              htab->sgot->contents + off);
3852
              }
3853
 
3854
            if (off >= (bfd_vma) -2)
3855
              abort ();
3856
 
3857
            /* Add the base of the GOT to the relocation value.  */
3858
            relocation = (off
3859
                          + htab->sgot->output_offset
3860
                          + htab->sgot->output_section->vma);
3861
          }
3862
          break;
3863
 
3864
        case R_PARISC_SEGREL32:
3865
          /* If this is the first SEGREL relocation, then initialize
3866
             the segment base values.  */
3867
          if (htab->text_segment_base == (bfd_vma) -1)
3868
            bfd_map_over_sections (output_bfd, hppa_record_segment_addr, htab);
3869
          break;
3870
 
3871
        case R_PARISC_PLABEL14R:
3872
        case R_PARISC_PLABEL21L:
3873
        case R_PARISC_PLABEL32:
3874
          if (htab->etab.dynamic_sections_created)
3875
            {
3876
              bfd_vma off;
3877
              bfd_boolean do_plt = 0;
3878
              /* If we have a global symbol with a PLT slot, then
3879
                 redirect this relocation to it.  */
3880
              if (hh != NULL)
3881
                {
3882
                  off = hh->eh.plt.offset;
3883
                  if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared,
3884
                                                         &hh->eh))
3885
                    {
3886
                      /* In a non-shared link, adjust_dynamic_symbols
3887
                         isn't called for symbols forced local.  We
3888
                         need to write out the plt entry here.  */
3889
                      if ((off & 1) != 0)
3890
                        off &= ~1;
3891
                      else
3892
                        {
3893
                          hh->eh.plt.offset |= 1;
3894
                          do_plt = 1;
3895
                        }
3896
                    }
3897
                }
3898
              else
3899
                {
3900
                  bfd_vma *local_plt_offsets;
3901
 
3902
                  if (local_got_offsets == NULL)
3903
                    abort ();
3904
 
3905
                  local_plt_offsets = local_got_offsets + symtab_hdr->sh_info;
3906
                  off = local_plt_offsets[r_symndx];
3907
 
3908
                  /* As for the local .got entry case, we use the last
3909
                     bit to record whether we've already initialised
3910
                     this local .plt entry.  */
3911
                  if ((off & 1) != 0)
3912
                    off &= ~1;
3913
                  else
3914
                    {
3915
                      local_plt_offsets[r_symndx] |= 1;
3916
                      do_plt = 1;
3917
                    }
3918
                }
3919
 
3920
              if (do_plt)
3921
                {
3922
                  if (info->shared)
3923
                    {
3924
                      /* Output a dynamic IPLT relocation for this
3925
                         PLT entry.  */
3926
                      Elf_Internal_Rela outrel;
3927
                      bfd_byte *loc;
3928
                      asection *s = htab->srelplt;
3929
 
3930
                      outrel.r_offset = (off
3931
                                         + htab->splt->output_offset
3932
                                         + htab->splt->output_section->vma);
3933
                      outrel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
3934
                      outrel.r_addend = relocation;
3935
                      loc = s->contents;
3936
                      loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
3937
                      bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3938
                    }
3939
                  else
3940
                    {
3941
                      bfd_put_32 (output_bfd,
3942
                                  relocation,
3943
                                  htab->splt->contents + off);
3944
                      bfd_put_32 (output_bfd,
3945
                                  elf_gp (htab->splt->output_section->owner),
3946
                                  htab->splt->contents + off + 4);
3947
                    }
3948
                }
3949
 
3950
              if (off >= (bfd_vma) -2)
3951
                abort ();
3952
 
3953
              /* PLABELs contain function pointers.  Relocation is to
3954
                 the entry for the function in the .plt.  The magic +2
3955
                 offset signals to $$dyncall that the function pointer
3956
                 is in the .plt and thus has a gp pointer too.
3957
                 Exception:  Undefined PLABELs should have a value of
3958
                 zero.  */
3959
              if (hh == NULL
3960
                  || (hh->eh.root.type != bfd_link_hash_undefweak
3961
                      && hh->eh.root.type != bfd_link_hash_undefined))
3962
                {
3963
                  relocation = (off
3964
                                + htab->splt->output_offset
3965
                                + htab->splt->output_section->vma
3966
                                + 2);
3967
                }
3968
              plabel = 1;
3969
            }
3970
          /* Fall through and possibly emit a dynamic relocation.  */
3971
 
3972
        case R_PARISC_DIR17F:
3973
        case R_PARISC_DIR17R:
3974
        case R_PARISC_DIR14F:
3975
        case R_PARISC_DIR14R:
3976
        case R_PARISC_DIR21L:
3977
        case R_PARISC_DPREL14F:
3978
        case R_PARISC_DPREL14R:
3979
        case R_PARISC_DPREL21L:
3980
        case R_PARISC_DIR32:
3981
          if ((input_section->flags & SEC_ALLOC) == 0)
3982
            break;
3983
 
3984
          /* The reloc types handled here and this conditional
3985
             expression must match the code in ..check_relocs and
3986
             allocate_dynrelocs.  ie. We need exactly the same condition
3987
             as in ..check_relocs, with some extra conditions (dynindx
3988
             test in this case) to cater for relocs removed by
3989
             allocate_dynrelocs.  If you squint, the non-shared test
3990
             here does indeed match the one in ..check_relocs, the
3991
             difference being that here we test DEF_DYNAMIC as well as
3992
             !DEF_REGULAR.  All common syms end up with !DEF_REGULAR,
3993
             which is why we can't use just that test here.
3994
             Conversely, DEF_DYNAMIC can't be used in check_relocs as
3995
             there all files have not been loaded.  */
3996
          if ((info->shared
3997
               && (hh == NULL
3998
                   || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT
3999
                   || hh->eh.root.type != bfd_link_hash_undefweak)
4000
               && (IS_ABSOLUTE_RELOC (r_type)
4001
                   || !SYMBOL_CALLS_LOCAL (info, &hh->eh)))
4002
              || (!info->shared
4003
                  && hh != NULL
4004
                  && hh->eh.dynindx != -1
4005
                  && !hh->eh.non_got_ref
4006
                  && ((ELIMINATE_COPY_RELOCS
4007
                       && hh->eh.def_dynamic
4008
                       && !hh->eh.def_regular)
4009
                      || hh->eh.root.type == bfd_link_hash_undefweak
4010
                      || hh->eh.root.type == bfd_link_hash_undefined)))
4011
            {
4012
              Elf_Internal_Rela outrel;
4013
              bfd_boolean skip;
4014
              asection *sreloc;
4015
              bfd_byte *loc;
4016
 
4017
              /* When generating a shared object, these relocations
4018
                 are copied into the output file to be resolved at run
4019
                 time.  */
4020
 
4021
              outrel.r_addend = rela->r_addend;
4022
              outrel.r_offset =
4023
                _bfd_elf_section_offset (output_bfd, info, input_section,
4024
                                         rela->r_offset);
4025
              skip = (outrel.r_offset == (bfd_vma) -1
4026
                      || outrel.r_offset == (bfd_vma) -2);
4027
              outrel.r_offset += (input_section->output_offset
4028
                                  + input_section->output_section->vma);
4029
 
4030
              if (skip)
4031
                {
4032
                  memset (&outrel, 0, sizeof (outrel));
4033
                }
4034
              else if (hh != NULL
4035
                       && hh->eh.dynindx != -1
4036
                       && (plabel
4037
                           || !IS_ABSOLUTE_RELOC (r_type)
4038
                           || !info->shared
4039
                           || !info->symbolic
4040
                           || !hh->eh.def_regular))
4041
                {
4042
                  outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type);
4043
                }
4044
              else /* It's a local symbol, or one marked to become local.  */
4045
                {
4046
                  int indx = 0;
4047
 
4048
                  /* Add the absolute offset of the symbol.  */
4049
                  outrel.r_addend += relocation;
4050
 
4051
                  /* Global plabels need to be processed by the
4052
                     dynamic linker so that functions have at most one
4053
                     fptr.  For this reason, we need to differentiate
4054
                     between global and local plabels, which we do by
4055
                     providing the function symbol for a global plabel
4056
                     reloc, and no symbol for local plabels.  */
4057
                  if (! plabel
4058
                      && sym_sec != NULL
4059
                      && sym_sec->output_section != NULL
4060
                      && ! bfd_is_abs_section (sym_sec))
4061
                    {
4062
                      asection *osec;
4063
 
4064
                      osec = sym_sec->output_section;
4065
                      indx = elf_section_data (osec)->dynindx;
4066
                      if (indx == 0)
4067
                        {
4068
                          osec = htab->etab.text_index_section;
4069
                          indx = elf_section_data (osec)->dynindx;
4070
                        }
4071
                      BFD_ASSERT (indx != 0);
4072
 
4073
                      /* We are turning this relocation into one
4074
                         against a section symbol, so subtract out the
4075
                         output section's address but not the offset
4076
                         of the input section in the output section.  */
4077
                      outrel.r_addend -= osec->vma;
4078
                    }
4079
 
4080
                  outrel.r_info = ELF32_R_INFO (indx, r_type);
4081
                }
4082
              sreloc = elf_section_data (input_section)->sreloc;
4083
              if (sreloc == NULL)
4084
                abort ();
4085
 
4086
              loc = sreloc->contents;
4087
              loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4088
              bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4089
            }
4090
          break;
4091
 
4092
        case R_PARISC_TLS_LDM21L:
4093
        case R_PARISC_TLS_LDM14R:
4094
          {
4095
            bfd_vma off;
4096
 
4097
            off = htab->tls_ldm_got.offset;
4098
            if (off & 1)
4099
              off &= ~1;
4100
            else
4101
              {
4102
                Elf_Internal_Rela outrel;
4103
                bfd_byte *loc;
4104
 
4105
                outrel.r_offset = (off
4106
                                   + htab->sgot->output_section->vma
4107
                                   + htab->sgot->output_offset);
4108
                outrel.r_addend = 0;
4109
                outrel.r_info = ELF32_R_INFO (0, R_PARISC_TLS_DTPMOD32);
4110
                loc = htab->srelgot->contents;
4111
                loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
4112
 
4113
                bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4114
                htab->tls_ldm_got.offset |= 1;
4115
              }
4116
 
4117
            /* Add the base of the GOT to the relocation value.  */
4118
            relocation = (off
4119
                          + htab->sgot->output_offset
4120
                          + htab->sgot->output_section->vma);
4121
 
4122
            break;
4123
          }
4124
 
4125
        case R_PARISC_TLS_LDO21L:
4126
        case R_PARISC_TLS_LDO14R:
4127
          relocation -= dtpoff_base (info);
4128
          break;
4129
 
4130
        case R_PARISC_TLS_GD21L:
4131
        case R_PARISC_TLS_GD14R:
4132
        case R_PARISC_TLS_IE21L:
4133
        case R_PARISC_TLS_IE14R:
4134
          {
4135
            bfd_vma off;
4136
            int indx;
4137
            char tls_type;
4138
 
4139
            indx = 0;
4140
            if (hh != NULL)
4141
              {
4142
                bfd_boolean dyn;
4143
                dyn = htab->etab.dynamic_sections_created;
4144
 
4145
                if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &hh->eh)
4146
                    && (!info->shared
4147
                        || !SYMBOL_REFERENCES_LOCAL (info, &hh->eh)))
4148
                  {
4149
                    indx = hh->eh.dynindx;
4150
                  }
4151
                off = hh->eh.got.offset;
4152
                tls_type = hh->tls_type;
4153
              }
4154
            else
4155
              {
4156
                off = local_got_offsets[r_symndx];
4157
                tls_type = hppa_elf_local_got_tls_type (input_bfd)[r_symndx];
4158
              }
4159
 
4160
            if (tls_type == GOT_UNKNOWN)
4161
              abort ();
4162
 
4163
            if ((off & 1) != 0)
4164
              off &= ~1;
4165
            else
4166
              {
4167
                bfd_boolean need_relocs = FALSE;
4168
                Elf_Internal_Rela outrel;
4169
                bfd_byte *loc = NULL;
4170
                int cur_off = off;
4171
 
4172
                /* The GOT entries have not been initialized yet.  Do it
4173
                   now, and emit any relocations.  If both an IE GOT and a
4174
                   GD GOT are necessary, we emit the GD first.  */
4175
 
4176
                if ((info->shared || indx != 0)
4177
                    && (hh == NULL
4178
                        || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT
4179
                        || hh->eh.root.type != bfd_link_hash_undefweak))
4180
                  {
4181
                    need_relocs = TRUE;
4182
                    loc = htab->srelgot->contents;
4183
                    /* FIXME (CAO): Should this be reloc_count++ ? */
4184
                    loc += htab->srelgot->reloc_count * sizeof (Elf32_External_Rela);
4185
                  }
4186
 
4187
                if (tls_type & GOT_TLS_GD)
4188
                  {
4189
                    if (need_relocs)
4190
                      {
4191
                        outrel.r_offset = (cur_off
4192
                                           + htab->sgot->output_section->vma
4193
                                           + htab->sgot->output_offset);
4194
                        outrel.r_info = ELF32_R_INFO (indx,R_PARISC_TLS_DTPMOD32);
4195
                        outrel.r_addend = 0;
4196
                        bfd_put_32 (output_bfd, 0, htab->sgot->contents + cur_off);
4197
                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4198
                        htab->srelgot->reloc_count++;
4199
                        loc += sizeof (Elf32_External_Rela);
4200
 
4201
                        if (indx == 0)
4202
                          bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
4203
                                      htab->sgot->contents + cur_off + 4);
4204
                        else
4205
                          {
4206
                            bfd_put_32 (output_bfd, 0,
4207
                                        htab->sgot->contents + cur_off + 4);
4208
                            outrel.r_info = ELF32_R_INFO (indx, R_PARISC_TLS_DTPOFF32);
4209
                            outrel.r_offset += 4;
4210
                            bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
4211
                            htab->srelgot->reloc_count++;
4212
                            loc += sizeof (Elf32_External_Rela);
4213
                          }
4214
                      }
4215
                    else
4216
                      {
4217
                        /* If we are not emitting relocations for a
4218
                           general dynamic reference, then we must be in a
4219
                           static link or an executable link with the
4220
                           symbol binding locally.  Mark it as belonging
4221
                           to module 1, the executable.  */
4222
                        bfd_put_32 (output_bfd, 1,
4223
                                    htab->sgot->contents + cur_off);
4224
                        bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
4225
                                    htab->sgot->contents + cur_off + 4);
4226
                      }
4227
 
4228
 
4229
                    cur_off += 8;
4230
                  }
4231
 
4232
                if (tls_type & GOT_TLS_IE)
4233
                  {
4234
                    if (need_relocs)
4235
                      {
4236
                        outrel.r_offset = (cur_off
4237
                                           + htab->sgot->output_section->vma
4238
                                           + htab->sgot->output_offset);
4239
                        outrel.r_info = ELF32_R_INFO (indx, R_PARISC_TLS_TPREL32);
4240
 
4241
                        if (indx == 0)
4242
                          outrel.r_addend = relocation - dtpoff_base (info);
4243
                        else
4244
                          outrel.r_addend = 0;
4245
 
4246
                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4247
                        htab->srelgot->reloc_count++;
4248
                        loc += sizeof (Elf32_External_Rela);
4249
                      }
4250
                    else
4251
                      bfd_put_32 (output_bfd, tpoff (info, relocation),
4252
                                  htab->sgot->contents + cur_off);
4253
 
4254
                    cur_off += 4;
4255
                  }
4256
 
4257
                if (hh != NULL)
4258
                  hh->eh.got.offset |= 1;
4259
                else
4260
                  local_got_offsets[r_symndx] |= 1;
4261
              }
4262
 
4263
            if ((tls_type & GOT_TLS_GD)
4264
                && r_type != R_PARISC_TLS_GD21L
4265
                && r_type != R_PARISC_TLS_GD14R)
4266
              off += 2 * GOT_ENTRY_SIZE;
4267
 
4268
            /* Add the base of the GOT to the relocation value.  */
4269
            relocation = (off
4270
                          + htab->sgot->output_offset
4271
                          + htab->sgot->output_section->vma);
4272
 
4273
            break;
4274
          }
4275
 
4276
        case R_PARISC_TLS_LE21L:
4277
        case R_PARISC_TLS_LE14R:
4278
          {
4279
            relocation = tpoff (info, relocation);
4280
            break;
4281
          }
4282
          break;
4283
 
4284
        default:
4285
          break;
4286
        }
4287
 
4288
      rstatus = final_link_relocate (input_section, contents, rela, relocation,
4289
                               htab, sym_sec, hh, info);
4290
 
4291
      if (rstatus == bfd_reloc_ok)
4292
        continue;
4293
 
4294
      if (hh != NULL)
4295
        sym_name = hh_name (hh);
4296
      else
4297
        {
4298
          sym_name = bfd_elf_string_from_elf_section (input_bfd,
4299
                                                      symtab_hdr->sh_link,
4300
                                                      sym->st_name);
4301
          if (sym_name == NULL)
4302
            return FALSE;
4303
          if (*sym_name == '\0')
4304
            sym_name = bfd_section_name (input_bfd, sym_sec);
4305
        }
4306
 
4307
      howto = elf_hppa_howto_table + r_type;
4308
 
4309
      if (rstatus == bfd_reloc_undefined || rstatus == bfd_reloc_notsupported)
4310
        {
4311
          if (rstatus == bfd_reloc_notsupported || !warned_undef)
4312
            {
4313
              (*_bfd_error_handler)
4314
                (_("%B(%A+0x%lx): cannot handle %s for %s"),
4315
                 input_bfd,
4316
                 input_section,
4317
                 (long) rela->r_offset,
4318
                 howto->name,
4319
                 sym_name);
4320
              bfd_set_error (bfd_error_bad_value);
4321
              return FALSE;
4322
            }
4323
        }
4324
      else
4325
        {
4326
          if (!((*info->callbacks->reloc_overflow)
4327
                (info, (hh ? &hh->eh.root : NULL), sym_name, howto->name,
4328
                 (bfd_vma) 0, input_bfd, input_section, rela->r_offset)))
4329
            return FALSE;
4330
        }
4331
    }
4332
 
4333
  return TRUE;
4334
}
4335
 
4336
/* Finish up dynamic symbol handling.  We set the contents of various
4337
   dynamic sections here.  */
4338
 
4339
static bfd_boolean
4340
elf32_hppa_finish_dynamic_symbol (bfd *output_bfd,
4341
                                  struct bfd_link_info *info,
4342
                                  struct elf_link_hash_entry *eh,
4343
                                  Elf_Internal_Sym *sym)
4344
{
4345
  struct elf32_hppa_link_hash_table *htab;
4346
  Elf_Internal_Rela rela;
4347
  bfd_byte *loc;
4348
 
4349
  htab = hppa_link_hash_table (info);
4350
  if (htab == NULL)
4351
    return FALSE;
4352
 
4353
  if (eh->plt.offset != (bfd_vma) -1)
4354
    {
4355
      bfd_vma value;
4356
 
4357
      if (eh->plt.offset & 1)
4358
        abort ();
4359
 
4360
      /* This symbol has an entry in the procedure linkage table.  Set
4361
         it up.
4362
 
4363
         The format of a plt entry is
4364
         <funcaddr>
4365
         <__gp>
4366
      */
4367
      value = 0;
4368
      if (eh->root.type == bfd_link_hash_defined
4369
          || eh->root.type == bfd_link_hash_defweak)
4370
        {
4371
          value = eh->root.u.def.value;
4372
          if (eh->root.u.def.section->output_section != NULL)
4373
            value += (eh->root.u.def.section->output_offset
4374
                      + eh->root.u.def.section->output_section->vma);
4375
        }
4376
 
4377
      /* Create a dynamic IPLT relocation for this entry.  */
4378
      rela.r_offset = (eh->plt.offset
4379
                      + htab->splt->output_offset
4380
                      + htab->splt->output_section->vma);
4381
      if (eh->dynindx != -1)
4382
        {
4383
          rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_IPLT);
4384
          rela.r_addend = 0;
4385
        }
4386
      else
4387
        {
4388
          /* This symbol has been marked to become local, and is
4389
             used by a plabel so must be kept in the .plt.  */
4390
          rela.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
4391
          rela.r_addend = value;
4392
        }
4393
 
4394
      loc = htab->srelplt->contents;
4395
      loc += htab->srelplt->reloc_count++ * sizeof (Elf32_External_Rela);
4396
      bfd_elf32_swap_reloca_out (htab->splt->output_section->owner, &rela, loc);
4397
 
4398
      if (!eh->def_regular)
4399
        {
4400
          /* Mark the symbol as undefined, rather than as defined in
4401
             the .plt section.  Leave the value alone.  */
4402
          sym->st_shndx = SHN_UNDEF;
4403
        }
4404
    }
4405
 
4406
  if (eh->got.offset != (bfd_vma) -1
4407
      && (hppa_elf_hash_entry (eh)->tls_type & GOT_TLS_GD) == 0
4408
      && (hppa_elf_hash_entry (eh)->tls_type & GOT_TLS_IE) == 0)
4409
    {
4410
      /* This symbol has an entry in the global offset table.  Set it
4411
         up.  */
4412
 
4413
      rela.r_offset = ((eh->got.offset &~ (bfd_vma) 1)
4414
                      + htab->sgot->output_offset
4415
                      + htab->sgot->output_section->vma);
4416
 
4417
      /* If this is a -Bsymbolic link and the symbol is defined
4418
         locally or was forced to be local because of a version file,
4419
         we just want to emit a RELATIVE reloc.  The entry in the
4420
         global offset table will already have been initialized in the
4421
         relocate_section function.  */
4422
      if (info->shared
4423
          && (info->symbolic || eh->dynindx == -1)
4424
          && eh->def_regular)
4425
        {
4426
          rela.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
4427
          rela.r_addend = (eh->root.u.def.value
4428
                          + eh->root.u.def.section->output_offset
4429
                          + eh->root.u.def.section->output_section->vma);
4430
        }
4431
      else
4432
        {
4433
          if ((eh->got.offset & 1) != 0)
4434
            abort ();
4435
 
4436
          bfd_put_32 (output_bfd, 0, htab->sgot->contents + (eh->got.offset & ~1));
4437
          rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_DIR32);
4438
          rela.r_addend = 0;
4439
        }
4440
 
4441
      loc = htab->srelgot->contents;
4442
      loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
4443
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4444
    }
4445
 
4446
  if (eh->needs_copy)
4447
    {
4448
      asection *sec;
4449
 
4450
      /* This symbol needs a copy reloc.  Set it up.  */
4451
 
4452
      if (! (eh->dynindx != -1
4453
             && (eh->root.type == bfd_link_hash_defined
4454
                 || eh->root.type == bfd_link_hash_defweak)))
4455
        abort ();
4456
 
4457
      sec = htab->srelbss;
4458
 
4459
      rela.r_offset = (eh->root.u.def.value
4460
                      + eh->root.u.def.section->output_offset
4461
                      + eh->root.u.def.section->output_section->vma);
4462
      rela.r_addend = 0;
4463
      rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_COPY);
4464
      loc = sec->contents + sec->reloc_count++ * sizeof (Elf32_External_Rela);
4465
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4466
    }
4467
 
4468
  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
4469
  if (eh_name (eh)[0] == '_'
4470
      && (strcmp (eh_name (eh), "_DYNAMIC") == 0
4471
          || eh == htab->etab.hgot))
4472
    {
4473
      sym->st_shndx = SHN_ABS;
4474
    }
4475
 
4476
  return TRUE;
4477
}
4478
 
4479
/* Used to decide how to sort relocs in an optimal manner for the
4480
   dynamic linker, before writing them out.  */
4481
 
4482
static enum elf_reloc_type_class
4483
elf32_hppa_reloc_type_class (const Elf_Internal_Rela *rela)
4484
{
4485
  /* Handle TLS relocs first; we don't want them to be marked
4486
     relative by the "if (ELF32_R_SYM (rela->r_info) == 0)"
4487
     check below.  */
4488
  switch ((int) ELF32_R_TYPE (rela->r_info))
4489
    {
4490
      case R_PARISC_TLS_DTPMOD32:
4491
      case R_PARISC_TLS_DTPOFF32:
4492
      case R_PARISC_TLS_TPREL32:
4493
        return reloc_class_normal;
4494
    }
4495
 
4496
  if (ELF32_R_SYM (rela->r_info) == 0)
4497
    return reloc_class_relative;
4498
 
4499
  switch ((int) ELF32_R_TYPE (rela->r_info))
4500
    {
4501
    case R_PARISC_IPLT:
4502
      return reloc_class_plt;
4503
    case R_PARISC_COPY:
4504
      return reloc_class_copy;
4505
    default:
4506
      return reloc_class_normal;
4507
    }
4508
}
4509
 
4510
/* Finish up the dynamic sections.  */
4511
 
4512
static bfd_boolean
4513
elf32_hppa_finish_dynamic_sections (bfd *output_bfd,
4514
                                    struct bfd_link_info *info)
4515
{
4516
  bfd *dynobj;
4517
  struct elf32_hppa_link_hash_table *htab;
4518
  asection *sdyn;
4519
 
4520
  htab = hppa_link_hash_table (info);
4521
  if (htab == NULL)
4522
    return FALSE;
4523
 
4524
  dynobj = htab->etab.dynobj;
4525
 
4526
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4527
 
4528
  if (htab->etab.dynamic_sections_created)
4529
    {
4530
      Elf32_External_Dyn *dyncon, *dynconend;
4531
 
4532
      if (sdyn == NULL)
4533
        abort ();
4534
 
4535
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
4536
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4537
      for (; dyncon < dynconend; dyncon++)
4538
        {
4539
          Elf_Internal_Dyn dyn;
4540
          asection *s;
4541
 
4542
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4543
 
4544
          switch (dyn.d_tag)
4545
            {
4546
            default:
4547
              continue;
4548
 
4549
            case DT_PLTGOT:
4550
              /* Use PLTGOT to set the GOT register.  */
4551
              dyn.d_un.d_ptr = elf_gp (output_bfd);
4552
              break;
4553
 
4554
            case DT_JMPREL:
4555
              s = htab->srelplt;
4556
              dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4557
              break;
4558
 
4559
            case DT_PLTRELSZ:
4560
              s = htab->srelplt;
4561
              dyn.d_un.d_val = s->size;
4562
              break;
4563
 
4564
            case DT_RELASZ:
4565
              /* Don't count procedure linkage table relocs in the
4566
                 overall reloc count.  */
4567
              s = htab->srelplt;
4568
              if (s == NULL)
4569
                continue;
4570
              dyn.d_un.d_val -= s->size;
4571
              break;
4572
 
4573
            case DT_RELA:
4574
              /* We may not be using the standard ELF linker script.
4575
                 If .rela.plt is the first .rela section, we adjust
4576
                 DT_RELA to not include it.  */
4577
              s = htab->srelplt;
4578
              if (s == NULL)
4579
                continue;
4580
              if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
4581
                continue;
4582
              dyn.d_un.d_ptr += s->size;
4583
              break;
4584
            }
4585
 
4586
          bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4587
        }
4588
    }
4589
 
4590
  if (htab->sgot != NULL && htab->sgot->size != 0)
4591
    {
4592
      /* Fill in the first entry in the global offset table.
4593
         We use it to point to our dynamic section, if we have one.  */
4594
      bfd_put_32 (output_bfd,
4595
                  sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0,
4596
                  htab->sgot->contents);
4597
 
4598
      /* The second entry is reserved for use by the dynamic linker.  */
4599
      memset (htab->sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
4600
 
4601
      /* Set .got entry size.  */
4602
      elf_section_data (htab->sgot->output_section)
4603
        ->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
4604
    }
4605
 
4606
  if (htab->splt != NULL && htab->splt->size != 0)
4607
    {
4608
      /* Set plt entry size.  */
4609
      elf_section_data (htab->splt->output_section)
4610
        ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
4611
 
4612
      if (htab->need_plt_stub)
4613
        {
4614
          /* Set up the .plt stub.  */
4615
          memcpy (htab->splt->contents
4616
                  + htab->splt->size - sizeof (plt_stub),
4617
                  plt_stub, sizeof (plt_stub));
4618
 
4619
          if ((htab->splt->output_offset
4620
               + htab->splt->output_section->vma
4621
               + htab->splt->size)
4622
              != (htab->sgot->output_offset
4623
                  + htab->sgot->output_section->vma))
4624
            {
4625
              (*_bfd_error_handler)
4626
                (_(".got section not immediately after .plt section"));
4627
              return FALSE;
4628
            }
4629
        }
4630
    }
4631
 
4632
  return TRUE;
4633
}
4634
 
4635
/* Called when writing out an object file to decide the type of a
4636
   symbol.  */
4637
static int
4638
elf32_hppa_elf_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
4639
{
4640
  if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)
4641
    return STT_PARISC_MILLI;
4642
  else
4643
    return type;
4644
}
4645
 
4646
/* Misc BFD support code.  */
4647
#define bfd_elf32_bfd_is_local_label_name    elf_hppa_is_local_label_name
4648
#define bfd_elf32_bfd_reloc_type_lookup      elf_hppa_reloc_type_lookup
4649
#define bfd_elf32_bfd_reloc_name_lookup      elf_hppa_reloc_name_lookup
4650
#define elf_info_to_howto                    elf_hppa_info_to_howto
4651
#define elf_info_to_howto_rel                elf_hppa_info_to_howto_rel
4652
 
4653
/* Stuff for the BFD linker.  */
4654
#define bfd_elf32_mkobject                   elf32_hppa_mkobject
4655
#define bfd_elf32_bfd_final_link             elf32_hppa_final_link
4656
#define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create
4657
#define bfd_elf32_bfd_link_hash_table_free   elf32_hppa_link_hash_table_free
4658
#define elf_backend_adjust_dynamic_symbol    elf32_hppa_adjust_dynamic_symbol
4659
#define elf_backend_copy_indirect_symbol     elf32_hppa_copy_indirect_symbol
4660
#define elf_backend_check_relocs             elf32_hppa_check_relocs
4661
#define elf_backend_create_dynamic_sections  elf32_hppa_create_dynamic_sections
4662
#define elf_backend_fake_sections            elf_hppa_fake_sections
4663
#define elf_backend_relocate_section         elf32_hppa_relocate_section
4664
#define elf_backend_hide_symbol              elf32_hppa_hide_symbol
4665
#define elf_backend_finish_dynamic_symbol    elf32_hppa_finish_dynamic_symbol
4666
#define elf_backend_finish_dynamic_sections  elf32_hppa_finish_dynamic_sections
4667
#define elf_backend_size_dynamic_sections    elf32_hppa_size_dynamic_sections
4668
#define elf_backend_init_index_section       _bfd_elf_init_1_index_section
4669
#define elf_backend_gc_mark_hook             elf32_hppa_gc_mark_hook
4670
#define elf_backend_gc_sweep_hook            elf32_hppa_gc_sweep_hook
4671
#define elf_backend_grok_prstatus            elf32_hppa_grok_prstatus
4672
#define elf_backend_grok_psinfo              elf32_hppa_grok_psinfo
4673
#define elf_backend_object_p                 elf32_hppa_object_p
4674
#define elf_backend_final_write_processing   elf_hppa_final_write_processing
4675
#define elf_backend_post_process_headers     _bfd_elf_set_osabi
4676
#define elf_backend_get_symbol_type          elf32_hppa_elf_get_symbol_type
4677
#define elf_backend_reloc_type_class         elf32_hppa_reloc_type_class
4678
#define elf_backend_action_discarded         elf_hppa_action_discarded
4679
 
4680
#define elf_backend_can_gc_sections          1
4681
#define elf_backend_can_refcount             1
4682
#define elf_backend_plt_alignment            2
4683
#define elf_backend_want_got_plt             0
4684
#define elf_backend_plt_readonly             0
4685
#define elf_backend_want_plt_sym             0
4686
#define elf_backend_got_header_size          8
4687
#define elf_backend_rela_normal              1
4688
 
4689
#define TARGET_BIG_SYM          bfd_elf32_hppa_vec
4690
#define TARGET_BIG_NAME         "elf32-hppa"
4691
#define ELF_ARCH                bfd_arch_hppa
4692
#define ELF_MACHINE_CODE        EM_PARISC
4693
#define ELF_MAXPAGESIZE         0x1000
4694
#define ELF_OSABI               ELFOSABI_HPUX
4695
#define elf32_bed               elf32_hppa_hpux_bed
4696
 
4697
#include "elf32-target.h"
4698
 
4699
#undef TARGET_BIG_SYM
4700
#define TARGET_BIG_SYM          bfd_elf32_hppa_linux_vec
4701
#undef TARGET_BIG_NAME
4702
#define TARGET_BIG_NAME         "elf32-hppa-linux"
4703
#undef ELF_OSABI
4704
#define ELF_OSABI               ELFOSABI_LINUX
4705
#undef elf32_bed
4706
#define elf32_bed               elf32_hppa_linux_bed
4707
 
4708
#include "elf32-target.h"
4709
 
4710
#undef TARGET_BIG_SYM
4711
#define TARGET_BIG_SYM          bfd_elf32_hppa_nbsd_vec
4712
#undef TARGET_BIG_NAME
4713
#define TARGET_BIG_NAME         "elf32-hppa-netbsd"
4714
#undef ELF_OSABI
4715
#define ELF_OSABI               ELFOSABI_NETBSD
4716
#undef elf32_bed
4717
#define elf32_bed               elf32_hppa_netbsd_bed
4718
 
4719
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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