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