projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* Makefile.in (install-info): Find files to install in either the build
[deliverable/binutils-gdb.git] / bfd / elf32-hppa.c
CommitLineData
252b5132 1/* BFD back-end for HP PA-RISC ELF files.
43cbcf28 2 Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
252b5132
RH		 3 Free Software Foundation, Inc.
4
5 Written by
6
7 Center for Software Science
8 Department of Computer Science
9 University of Utah
10
11This file is part of BFD, the Binary File Descriptor library.
12
13This program is free software; you can redistribute it and/or modify
14it under the terms of the GNU General Public License as published by
15the Free Software Foundation; either version 2 of the License, or
16(at your option) any later version.
17
18This program is distributed in the hope that it will be useful,
19but WITHOUT ANY WARRANTY; without even the implied warranty of
20MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21GNU General Public License for more details.
22
23You should have received a copy of the GNU General Public License
24along with this program; if not, write to the Free Software
25Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26
27#include "bfd.h"
28#include "sysdep.h"
252b5132
RH		 29#include "libbfd.h"
30#include "elf-bfd.h"
9e103c9c
JL		 31#include "elf/hppa.h"
32#include "libhppa.h"
33#include "elf32-hppa.h"
34#define ARCH_SIZE 32
35#include "elf-hppa.h"
36
252b5132 37
252b5132
RH		 38/* We use three different hash tables to hold information for
39 linking PA ELF objects.
40
41 The first is the elf32_hppa_link_hash_table which is derived
42 from the standard ELF linker hash table. We use this as a place to
43 attach other hash tables and static information.
44
45 The second is the stub hash table which is derived from the
46 base BFD hash table. The stub hash table holds the information
31bd8f25 47 necessary to build the linker stubs during a link. */
252b5132
RH		 48
49/* Hash table for linker stubs. */
50
51struct elf32_hppa_stub_hash_entry
52{
53 /* Base hash table entry structure, we can get the name of the stub
54 (and thus know exactly what actions it performs) from the base
55 hash table entry. */
56 struct bfd_hash_entry root;
57
58 /* Offset of the beginning of this stub. */
59 bfd_vma offset;
60
61 /* Given the symbol's value and its section we can determine its final
62 value when building the stubs (so the stub knows where to jump. */
63 symvalue target_value;
64 asection *target_section;
65};
66
67struct elf32_hppa_stub_hash_table
68{
69 /* The hash table itself. */
70 struct bfd_hash_table root;
71
72 /* The stub BFD. */
73 bfd *stub_bfd;
74
75 /* Where to place the next stub. */
76 bfd_byte *location;
77
78 /* Current offset in the stub section. */
79 unsigned int offset;
80
81};
82
252b5132
RH		 83struct elf32_hppa_link_hash_entry
84{
85 struct elf_link_hash_entry root;
86};
87
88struct elf32_hppa_link_hash_table
89{
90 /* The main hash table. */
91 struct elf_link_hash_table root;
92
93 /* The stub hash table. */
94 struct elf32_hppa_stub_hash_table *stub_hash_table;
95
252b5132
RH		 96 /* A count of the number of output symbols. */
97 unsigned int output_symbol_count;
98
99 /* Stuff so we can handle DP relative relocations. */
100 long global_value;
101 int global_sym_defined;
102};
103
252b5132
RH		 104/* ELF32/HPPA relocation support
105
106 This file contains ELF32/HPPA relocation support as specified
107 in the Stratus FTX/Golf Object File Format (SED-1762) dated
108 February 1994. */
109
110#include "elf32-hppa.h"
111#include "hppa_stubs.h"
112
252b5132
RH		 113static unsigned long hppa_elf_relocate_insn
114 PARAMS ((bfd *, asection *, unsigned long, unsigned long, long,
115 long, unsigned long, unsigned long, unsigned long));
116
252b5132
RH		 117static boolean elf32_hppa_add_symbol_hook
118 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
119 const char **, flagword *, asection **, bfd_vma *));
120
121static bfd_reloc_status_type elf32_hppa_bfd_final_link_relocate
122 PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *,
123 bfd_byte *, bfd_vma, bfd_vma, bfd_vma, struct bfd_link_info *,
124 asection *, const char *, int));
125
126static struct bfd_link_hash_table *elf32_hppa_link_hash_table_create
127 PARAMS ((bfd *));
128
129static struct bfd_hash_entry *
130elf32_hppa_stub_hash_newfunc
131 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
132
252b5132
RH		 133static boolean
134elf32_hppa_relocate_section
135 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
136 bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
137
138static boolean
139elf32_hppa_stub_hash_table_init
140 PARAMS ((struct elf32_hppa_stub_hash_table *, bfd *,
141 struct bfd_hash_entry *(*) PARAMS ((struct bfd_hash_entry *,
142 struct bfd_hash_table *,
143 const char *))));
144
145static boolean
146elf32_hppa_build_one_stub PARAMS ((struct bfd_hash_entry *, PTR));
147
252b5132 148static unsigned int elf32_hppa_size_of_stub
31bd8f25 149 PARAMS ((bfd_vma, bfd_vma, const char *));
252b5132
RH		 150
151static void elf32_hppa_name_of_stub
31bd8f25 152 PARAMS ((bfd_vma, bfd_vma, char *));
252b5132
RH		 153
154/* For linker stub hash tables. */
155#define elf32_hppa_stub_hash_lookup(table, string, create, copy) \
156 ((struct elf32_hppa_stub_hash_entry *) \
157 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
158
159#define elf32_hppa_stub_hash_traverse(table, func, info) \
160 (bfd_hash_traverse \
161 (&(table)->root, \
162 (boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func), \
163 (info)))
164
252b5132
RH		 165/* For HPPA linker hash table. */
166
167#define elf32_hppa_link_hash_lookup(table, string, create, copy, follow)\
168 ((struct elf32_hppa_link_hash_entry *) \
169 elf_link_hash_lookup (&(table)->root, (string), (create), \
170 (copy), (follow)))
171
172#define elf32_hppa_link_hash_traverse(table, func, info) \
173 (elf_link_hash_traverse \
174 (&(table)->root, \
175 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
176 (info)))
177
178/* Get the PA ELF linker hash table from a link_info structure. */
179
180#define elf32_hppa_hash_table(p) \
181 ((struct elf32_hppa_link_hash_table *) ((p)->hash))
182
183
252b5132
RH		 184/* Assorted hash table functions. */
185
186/* Initialize an entry in the stub hash table. */
187
188static struct bfd_hash_entry *
189elf32_hppa_stub_hash_newfunc (entry, table, string)
190 struct bfd_hash_entry *entry;
191 struct bfd_hash_table *table;
192 const char *string;
193{
194 struct elf32_hppa_stub_hash_entry *ret;
195
196 ret = (struct elf32_hppa_stub_hash_entry *) entry;
197
198 /* Allocate the structure if it has not already been allocated by a
199 subclass. */
200 if (ret == NULL)
201 ret = ((struct elf32_hppa_stub_hash_entry *)
202 bfd_hash_allocate (table,
203 sizeof (struct elf32_hppa_stub_hash_entry)));
204 if (ret == NULL)
205 return NULL;
206
207 /* Call the allocation method of the superclass. */
208 ret = ((struct elf32_hppa_stub_hash_entry *)
209 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
210
211 if (ret)
212 {
213 /* Initialize the local fields. */
214 ret->offset = 0;
215 ret->target_value = 0;
216 ret->target_section = NULL;
217 }
218
219 return (struct bfd_hash_entry *) ret;
220}
221
222/* Initialize a stub hash table. */
223
224static boolean
225elf32_hppa_stub_hash_table_init (table, stub_bfd, newfunc)
226 struct elf32_hppa_stub_hash_table *table;
227 bfd *stub_bfd;
228 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
229 struct bfd_hash_table *,
230 const char *));
231{
232 table->offset = 0;
233 table->location = 0;
234 table->stub_bfd = stub_bfd;
235 return (bfd_hash_table_init (&table->root, newfunc));
236}
237
252b5132
RH		 238/* Create the derived linker hash table. The PA ELF port uses the derived
239 hash table to keep information specific to the PA ELF linker (without
240 using static variables). */
241
242static struct bfd_link_hash_table *
243elf32_hppa_link_hash_table_create (abfd)
244 bfd *abfd;
245{
246 struct elf32_hppa_link_hash_table *ret;
247
248 ret = ((struct elf32_hppa_link_hash_table *)
249 bfd_alloc (abfd, sizeof (struct elf32_hppa_link_hash_table)));
250 if (ret == NULL)
251 return NULL;
252 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
253 _bfd_elf_link_hash_newfunc))
254 {
255 bfd_release (abfd, ret);
256 return NULL;
257 }
258 ret->stub_hash_table = NULL;
252b5132
RH		 259 ret->output_symbol_count = 0;
260 ret->global_value = 0;
261 ret->global_sym_defined = 0;
262
263 return &ret->root.root;
264}
265
266/* Relocate the given INSN given the various input parameters.
267
268 FIXME: endianness and sizeof (long) issues abound here. */
269
270static unsigned long
271hppa_elf_relocate_insn (abfd, input_sect, insn, address, sym_value,
272 r_addend, r_format, r_field, pcrel)
273 bfd *abfd;
274 asection *input_sect;
275 unsigned long insn;
276 unsigned long address;
277 long sym_value;
278 long r_addend;
279 unsigned long r_format;
280 unsigned long r_field;
281 unsigned long pcrel;
282{
283 unsigned char opcode = get_opcode (insn);
284 long constant_value;
285
286 switch (opcode)
287 {
288 case LDO:
289 case LDB:
290 case LDH:
291 case LDW:
292 case LDWM:
293 case STB:
294 case STH:
295 case STW:
296 case STWM:
297 case COMICLR:
298 case SUBI:
299 case ADDIT:
300 case ADDI:
301 case LDIL:
302 case ADDIL:
303 constant_value = HPPA_R_CONSTANT (r_addend);
304
305 if (pcrel)
306 sym_value -= address;
307
308 sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
309 return hppa_rebuild_insn (abfd, insn, sym_value, r_format);
310
311 case BL:
312 case BE:
313 case BLE:
3f9b03b5 314 /* XXX r_addend ignored ???. */
252b5132
RH		 315 constant_value = assemble_17 ((insn & 0x001f0000) >> 16,
316 (insn & 0x00001ffc) >> 2,
317 insn & 1);
318
3f9b03b5
AM		 319 constant_value = (constant_value << (BFD_ARCH_SIZE-17))
320 >> (BFD_ARCH_SIZE-17);
252b5132
RH		 321 if (pcrel)
322 {
3f9b03b5
AM		 323 sym_value -= (address + input_sect->output_offset
324 + input_sect->output_section->vma);
252b5132
RH		 325 sym_value = hppa_field_adjust (sym_value, -8, r_field);
326 }
327 else
328 sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
329
330 return hppa_rebuild_insn (abfd, insn, sym_value >> 2, r_format);
331
332 default:
333 if (opcode == 0)
334 {
335 constant_value = HPPA_R_CONSTANT (r_addend);
336
337 if (pcrel)
338 sym_value -= address;
339
340 return hppa_field_adjust (sym_value, constant_value, r_field);
341 }
342 else
343 abort ();
344 }
345}
346
347/* Relocate an HPPA ELF section. */
348
349static boolean
350elf32_hppa_relocate_section (output_bfd, info, input_bfd, input_section,
351 contents, relocs, local_syms, local_sections)
352 bfd *output_bfd;
353 struct bfd_link_info *info;
354 bfd *input_bfd;
355 asection *input_section;
356 bfd_byte *contents;
357 Elf_Internal_Rela *relocs;
358 Elf_Internal_Sym *local_syms;
359 asection **local_sections;
360{
361 Elf_Internal_Shdr *symtab_hdr;
362 Elf_Internal_Rela *rel;
363 Elf_Internal_Rela *relend;
364
365 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
366
367 rel = relocs;
368 relend = relocs + input_section->reloc_count;
369 for (; rel < relend; rel++)
370 {
371 int r_type;
372 reloc_howto_type *howto;
373 unsigned long r_symndx;
374 struct elf_link_hash_entry *h;
375 Elf_Internal_Sym *sym;
376 asection *sym_sec;
377 bfd_vma relocation;
378 bfd_reloc_status_type r;
379 const char *sym_name;
380
381 r_type = ELF32_R_TYPE (rel->r_info);
382 if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
383 {
384 bfd_set_error (bfd_error_bad_value);
385 return false;
386 }
387 howto = elf_hppa_howto_table + r_type;
388
389 r_symndx = ELF32_R_SYM (rel->r_info);
390
391 if (info->relocateable)
392 {
393 /* This is a relocateable link. We don't have to change
394 anything, unless the reloc is against a section symbol,
395 in which case we have to adjust according to where the
396 section symbol winds up in the output section. */
397 if (r_symndx < symtab_hdr->sh_info)
398 {
399 sym = local_syms + r_symndx;
400 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
401 {
402 sym_sec = local_sections[r_symndx];
403 rel->r_addend += sym_sec->output_offset;
404 }
405 }
406
407 continue;
408 }
409
410 /* This is a final link. */
411 h = NULL;
412 sym = NULL;
413 sym_sec = NULL;
414 if (r_symndx < symtab_hdr->sh_info)
415 {
416 sym = local_syms + r_symndx;
417 sym_sec = local_sections[r_symndx];
418 relocation = ((ELF_ST_TYPE (sym->st_info) == STT_SECTION
419 ? 0 : sym->st_value)
420 + sym_sec->output_offset
421 + sym_sec->output_section->vma);
422 }
423 else
424 {
425 long indx;
426
427 indx = r_symndx - symtab_hdr->sh_info;
428 h = elf_sym_hashes (input_bfd)[indx];
429 while (h->root.type == bfd_link_hash_indirect
430 || h->root.type == bfd_link_hash_warning)
431 h = (struct elf_link_hash_entry *) h->root.u.i.link;
432 if (h->root.type == bfd_link_hash_defined
433 || h->root.type == bfd_link_hash_defweak)
434 {
435 sym_sec = h->root.u.def.section;
436 relocation = (h->root.u.def.value
437 + sym_sec->output_offset
438 + sym_sec->output_section->vma);
439 }
440 else if (h->root.type == bfd_link_hash_undefweak)
441 relocation = 0;
442 else
443 {
444 if (!((*info->callbacks->undefined_symbol)
445 (info, h->root.root.string, input_bfd,
5cc7c785 446 input_section, rel->r_offset, true)))
252b5132
RH		 447 return false;
448 break;
449 }
450 }
451
452 if (h != NULL)
453 sym_name = h->root.root.string;
454 else
455 {
456 sym_name = bfd_elf_string_from_elf_section (input_bfd,
457 symtab_hdr->sh_link,
458 sym->st_name);
459 if (sym_name == NULL)
460 return false;
461 if (*sym_name == '\0')
462 sym_name = bfd_section_name (input_bfd, sym_sec);
463 }
464
252b5132
RH		 465 r = elf32_hppa_bfd_final_link_relocate (howto, input_bfd, output_bfd,
466 input_section, contents,
467 rel->r_offset, relocation,
468 rel->r_addend, info, sym_sec,
469 sym_name, h == NULL);
470
471 if (r != bfd_reloc_ok)
472 {
473 switch (r)
474 {
475 /* This can happen for DP relative relocs if $global$ is
476 undefined. This is a panic situation so we don't try
477 to continue. */
478 case bfd_reloc_undefined:
479 case bfd_reloc_notsupported:
480 if (!((*info->callbacks->undefined_symbol)
481 (info, "$global$", input_bfd,
5cc7c785 482 input_section, rel->r_offset, true)))
252b5132
RH		 483 return false;
484 return false;
485 case bfd_reloc_dangerous:
486 {
487 /* We use this return value to indicate that we performed
488 a "dangerous" relocation. This doesn't mean we did
489 the wrong thing, it just means there may be some cleanup
490 that needs to be done here.
491
492 In particular we had to swap the last call insn and its
493 delay slot. If the delay slot insn needed a relocation,
494 then we'll need to adjust the next relocation entry's
495 offset to account for the fact that the insn moved.
496
497 This hair wouldn't be necessary if we inserted stubs
498 between procedures and used a "bl" to get to the stub. */
499 if (rel != relend)
500 {
501 Elf_Internal_Rela *next_rel = rel + 1;
502
503 if (rel->r_offset + 4 == next_rel->r_offset)
504 next_rel->r_offset -= 4;
505 }
506 break;
507 }
508 default:
509 case bfd_reloc_outofrange:
510 case bfd_reloc_overflow:
511 {
512 if (!((*info->callbacks->reloc_overflow)
513 (info, sym_name, howto->name, (bfd_vma) 0,
514 input_bfd, input_section, rel->r_offset)))
515 return false;
516 }
517 break;
518 }
519 }
520 }
521
522 return true;
523}
524
252b5132
RH		 525/* Actually perform a relocation as part of a final link. This can get
526 rather hairy when linker stubs are needed. */
527
528static bfd_reloc_status_type
529elf32_hppa_bfd_final_link_relocate (howto, input_bfd, output_bfd,
530 input_section, contents, offset, value,
531 addend, info, sym_sec, sym_name, is_local)
532 reloc_howto_type *howto;
533 bfd *input_bfd;
5f771d47 534 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 535 asection *input_section;
536 bfd_byte *contents;
537 bfd_vma offset;
538 bfd_vma value;
539 bfd_vma addend;
540 struct bfd_link_info *info;
541 asection *sym_sec;
542 const char *sym_name;
543 int is_local;
544{
545 unsigned long insn;
546 unsigned long r_type = howto->type;
547 unsigned long r_format = howto->bitsize;
548 unsigned long r_field = e_fsel;
549 bfd_byte *hit_data = contents + offset;
550 boolean r_pcrel = howto->pc_relative;
551
552 insn = bfd_get_32 (input_bfd, hit_data);
553
554 /* Make sure we have a value for $global$. FIXME isn't this effectively
555 just like the gp pointer on MIPS? Can we use those routines for this
556 purpose? */
557 if (!elf32_hppa_hash_table (info)->global_sym_defined)
558 {
559 struct elf_link_hash_entry *h;
560 asection *sec;
561
562 h = elf_link_hash_lookup (elf_hash_table (info), "$global$", false,
563 false, false);
564
565 /* If there isn't a $global$, then we're in deep trouble. */
566 if (h == NULL)
567 return bfd_reloc_notsupported;
568
569 /* If $global$ isn't a defined symbol, then we're still in deep
570 trouble. */
571 if (h->root.type != bfd_link_hash_defined)
572 return bfd_reloc_undefined;
573
574 sec = h->root.u.def.section;
575 elf32_hppa_hash_table (info)->global_value = (h->root.u.def.value
576 + sec->output_section->vma
577 + sec->output_offset);
578 elf32_hppa_hash_table (info)->global_sym_defined = 1;
579 }
580
581 switch (r_type)
582 {
583 case R_PARISC_NONE:
584 break;
585
586 case R_PARISC_DIR32:
587 case R_PARISC_DIR17F:
588 case R_PARISC_PCREL17C:
589 r_field = e_fsel;
590 goto do_basic_type_1;
591 case R_PARISC_DIR21L:
592 case R_PARISC_PCREL21L:
593 r_field = e_lrsel;
594 goto do_basic_type_1;
595 case R_PARISC_DIR17R:
596 case R_PARISC_PCREL17R:
597 case R_PARISC_DIR14R:
598 case R_PARISC_PCREL14R:
599 r_field = e_rrsel;
600 goto do_basic_type_1;
601
602 /* For all the DP relative relocations, we need to examine the symbol's
603 section. If it's a code section, then "data pointer relative" makes
604 no sense. In that case we don't adjust the "value", and for 21 bit
605 addil instructions, we change the source addend register from %dp to
606 %r0. */
607 case R_PARISC_DPREL21L:
608 r_field = e_lrsel;
609 if (sym_sec->flags & SEC_CODE)
610 {
611 if ((insn & 0xfc000000) >> 26 == 0xa
612 && (insn & 0x03e00000) >> 21 == 0x1b)
613 insn &= ~0x03e00000;
614 }
615 else
616 value -= elf32_hppa_hash_table (info)->global_value;
617 goto do_basic_type_1;
618 case R_PARISC_DPREL14R:
619 r_field = e_rrsel;
620 if ((sym_sec->flags & SEC_CODE) == 0)
621 value -= elf32_hppa_hash_table (info)->global_value;
622 goto do_basic_type_1;
623 case R_PARISC_DPREL14F:
624 r_field = e_fsel;
625 if ((sym_sec->flags & SEC_CODE) == 0)
626 value -= elf32_hppa_hash_table (info)->global_value;
627 goto do_basic_type_1;
628
629 /* These cases are separate as they may involve a lot more work
630 to deal with linker stubs. */
631 case R_PARISC_PLABEL32:
632 case R_PARISC_PLABEL21L:
633 case R_PARISC_PLABEL14R:
634 case R_PARISC_PCREL17F:
635 {
636 bfd_vma location;
e049a0de 637 unsigned int len;
252b5132
RH		 638 char *new_name, *stub_name;
639
640 /* Get the field selector right. We'll need it in a minute. */
641 if (r_type == R_PARISC_PCREL17F
642 || r_type == R_PARISC_PLABEL32)
643 r_field = e_fsel;
644 else if (r_type == R_PARISC_PLABEL21L)
645 r_field = e_lrsel;
646 else if (r_type == R_PARISC_PLABEL14R)
647 r_field = e_rrsel;
648
649 /* Find out where we are and where we're going. */
650 location = (offset +
651 input_section->output_offset +
652 input_section->output_section->vma);
653
252b5132
RH		 654 len = strlen (sym_name) + 1;
655 if (is_local)
656 len += 9;
657 new_name = bfd_malloc (len);
658 if (!new_name)
659 return bfd_reloc_notsupported;
660 strcpy (new_name, sym_name);
661
662 /* Local symbols have unique IDs. */
663 if (is_local)
664 sprintf (new_name + len - 10, "_%08x", (int)sym_sec);
665
252b5132
RH		 666 /* Any kind of linker stub needed? */
667 if (((int)(value - location) > 0x3ffff)
43cbcf28 668 || ((int)(value - location) < -0x40000))
252b5132
RH		 669 {
670 struct elf32_hppa_stub_hash_table *stub_hash_table;
671 struct elf32_hppa_stub_hash_entry *stub_hash;
672 asection *stub_section;
673
674 /* Build a name for the stub. */
675
676 len = strlen (new_name);
677 len += 23;
678 stub_name = bfd_malloc (len);
679 if (!stub_name)
680 return bfd_reloc_notsupported;
31bd8f25 681 elf32_hppa_name_of_stub (location, value, stub_name);
252b5132
RH		 682 strcat (stub_name, new_name);
683 free (new_name);
684
685 stub_hash_table = elf32_hppa_hash_table (info)->stub_hash_table;
686
687 stub_hash
688 = elf32_hppa_stub_hash_lookup (stub_hash_table, stub_name,
689 false, false);
690
691 /* We're done with that name. */
692 free (stub_name);
693
694 /* The stub BFD only has one section. */
695 stub_section = stub_hash_table->stub_bfd->sections;
696
697 if (stub_hash != NULL)
698 {
252b5132
RH		 699 if (r_type == R_PARISC_PCREL17F)
700 {
701 unsigned long delay_insn;
702 unsigned int opcode, rtn_reg, ldo_target_reg, ldo_src_reg;
703
704 /* We'll need to peek at the next insn. */
705 delay_insn = bfd_get_32 (input_bfd, hit_data + 4);
706 opcode = get_opcode (delay_insn);
707
708 /* We also need to know the return register for this
709 call. */
710 rtn_reg = (insn & 0x03e00000) >> 21;
711
712 ldo_src_reg = (delay_insn & 0x03e00000) >> 21;
713 ldo_target_reg = (delay_insn & 0x001f0000) >> 16;
714
715 /* Munge up the value and other parameters for
716 hppa_elf_relocate_insn. */
717
718 value = (stub_hash->offset
719 + stub_section->output_offset
720 + stub_section->output_section->vma);
721
722 r_format = 17;
723 r_field = e_fsel;
724 r_pcrel = 0;
725 addend = 0;
726
727 /* We need to peek at the delay insn and determine if
728 we'll need to swap the branch and its delay insn. */
729 if ((insn & 2)
730 || (opcode == LDO
731 && ldo_target_reg == rtn_reg)
732 || (delay_insn == 0x08000240))
733 {
734 /* No need to swap the branch and its delay slot, but
735 we do need to make sure to jump past the return
736 pointer update in the stub. */
737 value += 4;
738
739 /* If the delay insn does a return pointer adjustment,
740 then we have to make sure it stays valid. */
741 if (opcode == LDO
742 && ldo_target_reg == rtn_reg)
743 {
744 delay_insn &= 0xfc00ffff;
745 delay_insn |= ((31 << 21) | (31 << 16));
746 bfd_put_32 (input_bfd, delay_insn, hit_data + 4);
747 }
748 /* Use a BLE to reach the stub. */
749 insn = BLE_SR4_R0;
750 }
751 else
752 {
753 /* Wonderful, we have to swap the call insn and its
754 delay slot. */
755 bfd_put_32 (input_bfd, delay_insn, hit_data);
756 /* Use a BLE,n to reach the stub. */
757 insn = (BLE_SR4_R0 | 0x2);
758 bfd_put_32 (input_bfd, insn, hit_data + 4);
759 insn = hppa_elf_relocate_insn (input_bfd,
760 input_section,
761 insn, offset + 4,
762 value, addend,
763 r_format, r_field,
764 r_pcrel);
765 /* Update the instruction word. */
766 bfd_put_32 (input_bfd, insn, hit_data + 4);
767 return bfd_reloc_dangerous;
768 }
769 }
31bd8f25
JL		 770 else
771 return bfd_reloc_notsupported;
772 }
252b5132
RH		 773 }
774 goto do_basic_type_1;
775 }
776
777do_basic_type_1:
778 insn = hppa_elf_relocate_insn (input_bfd, input_section, insn,
779 offset, value, addend, r_format,
780 r_field, r_pcrel);
781 break;
782
783 /* Something we don't know how to handle. */
784 default:
785 return bfd_reloc_notsupported;
786 }
787
788 /* Update the instruction word. */
789 bfd_put_32 (input_bfd, insn, hit_data);
790 return (bfd_reloc_ok);
791}
792
252b5132
RH		 793/* Undo the generic ELF code's subtraction of section->vma from the
794 value of each external symbol. */
795
796static boolean
797elf32_hppa_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
5f771d47
ILT		 798 bfd *abfd ATTRIBUTE_UNUSED;
799 struct bfd_link_info *info ATTRIBUTE_UNUSED;
800 const Elf_Internal_Sym *sym ATTRIBUTE_UNUSED;
801 const char **namep ATTRIBUTE_UNUSED;
802 flagword *flagsp ATTRIBUTE_UNUSED;
252b5132
RH		 803 asection **secp;
804 bfd_vma *valp;
805{
806 *valp += (*secp)->vma;
807 return true;
808}
809
810/* Determine the name of the stub needed to perform a call assuming the
811 argument relocation bits for caller and callee are in CALLER and CALLEE
812 for a call from LOCATION to DESTINATION. Copy the name into STUB_NAME. */
813
814static void
31bd8f25 815elf32_hppa_name_of_stub (location, destination, stub_name)
5f771d47
ILT		 816 bfd_vma location ATTRIBUTE_UNUSED;
817 bfd_vma destination ATTRIBUTE_UNUSED;
252b5132
RH		 818 char *stub_name;
819{
31bd8f25 820 strcpy (stub_name, "_____long_branch_stub_");
252b5132
RH		 821}
822
823/* Compute the size of the stub needed to call from LOCATION to DESTINATION
824 (a function named SYM_NAME), with argument relocation bits CALLER and
825 CALLEE. Return zero if no stub is needed to perform such a call. */
826
827static unsigned int
31bd8f25 828elf32_hppa_size_of_stub (location, destination, sym_name)
252b5132
RH		 829 bfd_vma location, destination;
830 const char *sym_name;
831{
31bd8f25 832 /* Determine if a long branch stub is needed. */
252b5132 833 if (!(((int)(location - destination) > 0x3ffff)
43cbcf28 834 || ((int)(location - destination) < -0x40000)))
252b5132
RH		 835 return 0;
836
31bd8f25 837 if (!strncmp ("$$", sym_name, 2)
252b5132
RH		 838 && strcmp ("$$dyncall", sym_name))
839 return 12;
840 else
841 return 16;
842}
843
844/* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
845 IN_ARGS contains the stub BFD and link info pointers. */
846
847static boolean
848elf32_hppa_build_one_stub (gen_entry, in_args)
849 struct bfd_hash_entry *gen_entry;
850 PTR in_args;
851{
852 void **args = (void **)in_args;
853 bfd *stub_bfd = (bfd *)args[0];
854 struct bfd_link_info *info = (struct bfd_link_info *)args[1];
855 struct elf32_hppa_stub_hash_entry *entry;
856 struct elf32_hppa_stub_hash_table *stub_hash_table;
857 bfd_byte *loc;
858 symvalue sym_value;
859 const char *sym_name;
860
861 /* Initialize pointers to the stub hash table, the particular entry we
862 are building a stub for, and where (in memory) we should place the stub
863 instructions. */
864 entry = (struct elf32_hppa_stub_hash_entry *)gen_entry;
865 stub_hash_table = elf32_hppa_hash_table(info)->stub_hash_table;
866 loc = stub_hash_table->location;
867
868 /* Make a note of the offset within the stubs for this entry. */
869 entry->offset = stub_hash_table->offset;
870
871 /* The symbol's name starts at offset 22. */
872 sym_name = entry->root.string + 22;
873
874 sym_value = (entry->target_value
875 + entry->target_section->output_offset
876 + entry->target_section->output_section->vma);
877
31bd8f25 878 if (1)
252b5132
RH		 879 {
880 /* Create one of two variant long branch stubs. One for $$dyncall and
881 normal calls, the other for calls to millicode. */
882 unsigned long insn;
883 int millicode_call = 0;
884
885 if (!strncmp ("$$", sym_name, 2) && strcmp ("$$dyncall", sym_name))
886 millicode_call = 1;
887
888 /* First the return pointer adjustment. Depending on exact calling
889 sequence this instruction may be skipped. */
890 bfd_put_32 (stub_bfd, LDO_M4_R31_R31, loc);
891
892 /* The next two instructions are the long branch itself. A long branch
893 is formed with "ldil" loading the upper bits of the target address
894 into a register, then branching with "be" which adds in the lower bits.
895 Long branches to millicode nullify the delay slot of the "be". */
896 insn = hppa_rebuild_insn (stub_bfd, LDIL_R1,
897 hppa_field_adjust (sym_value, 0, e_lrsel), 21);
898 bfd_put_32 (stub_bfd, insn, loc + 4);
899 insn = hppa_rebuild_insn (stub_bfd, BE_SR4_R1 | (millicode_call ? 2 : 0),
900 hppa_field_adjust (sym_value, 0, e_rrsel) >> 2,
901 17);
902 bfd_put_32 (stub_bfd, insn, loc + 8);
903
904 if (!millicode_call)
905 {
906 /* The sequence to call this stub places the return pointer into %r31,
907 the final target expects the return pointer in %r2, so copy the
908 return pointer into the proper register. */
909 bfd_put_32 (stub_bfd, COPY_R31_R2, loc + 12);
910
911 /* Update the location and offsets. */
912 stub_hash_table->location += 16;
913 stub_hash_table->offset += 16;
914 }
915 else
916 {
917 /* Update the location and offsets. */
918 stub_hash_table->location += 12;
919 stub_hash_table->offset += 12;
920 }
921
922 }
923 return true;
924}
925
926/* External entry points for sizing and building linker stubs. */
927
928/* Build all the stubs associated with the current output file. The
929 stubs are kept in a hash table attached to the main linker hash
930 table. This is called via hppaelf_finish in the linker. */
931
932boolean
933elf32_hppa_build_stubs (stub_bfd, info)
934 bfd *stub_bfd;
935 struct bfd_link_info *info;
936{
937 /* The stub BFD only has one section. */
938 asection *stub_sec = stub_bfd->sections;
939 struct elf32_hppa_stub_hash_table *table;
940 unsigned int size;
941 void *args[2];
942
943 /* So we can pass both the BFD for the stubs and the link info
944 structure to the routine which actually builds stubs. */
945 args[0] = stub_bfd;
946 args[1] = info;
947
948 /* Allocate memory to hold the linker stubs. */
949 size = bfd_section_size (stub_bfd, stub_sec);
950 stub_sec->contents = (unsigned char *) bfd_zalloc (stub_bfd, size);
951 if (stub_sec->contents == NULL)
952 return false;
953 table = elf32_hppa_hash_table(info)->stub_hash_table;
954 table->location = stub_sec->contents;
955
956 /* Build the stubs as directed by the stub hash table. */
957 elf32_hppa_stub_hash_traverse (table, elf32_hppa_build_one_stub, args);
958
959 return true;
960}
961
962/* Determine and set the size of the stub section for a final link.
963
964 The basic idea here is to examine all the relocations looking for
965 PC-relative calls to a target that is unreachable with a "bl"
966 instruction or calls where the caller and callee disagree on the
967 location of their arguments or return value. */
968
969boolean
970elf32_hppa_size_stubs (stub_bfd, output_bfd, link_info)
971 bfd *stub_bfd;
5f771d47 972 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 973 struct bfd_link_info *link_info;
974{
975 bfd *input_bfd;
976 asection *section, *stub_sec = 0;
977 Elf_Internal_Shdr *symtab_hdr;
e049a0de 978 Elf_Internal_Sym *local_syms, **all_local_syms;
252b5132
RH		 979 unsigned int i, index, bfd_count = 0;
980 struct elf32_hppa_stub_hash_table *stub_hash_table = 0;
252b5132
RH		 981
982 /* Create and initialize the stub hash table. */
983 stub_hash_table = ((struct elf32_hppa_stub_hash_table *)
984 bfd_malloc (sizeof (struct elf32_hppa_stub_hash_table)));
985 if (!stub_hash_table)
986 goto error_return;
987
988 if (!elf32_hppa_stub_hash_table_init (stub_hash_table, stub_bfd,
989 elf32_hppa_stub_hash_newfunc))
990 goto error_return;
991
252b5132
RH		 992 /* Attach the hash tables to the main hash table. */
993 elf32_hppa_hash_table(link_info)->stub_hash_table = stub_hash_table;
252b5132
RH		 994
995 /* Count the number of input BFDs. */
996 for (input_bfd = link_info->input_bfds;
997 input_bfd != NULL;
998 input_bfd = input_bfd->link_next)
999 bfd_count++;
1000
252b5132
RH		 1001 /* Magic as we know the stub bfd only has one section. */
1002 stub_sec = stub_bfd->sections;
1003
1004 /* If generating a relocateable output file, then we don't
1005 have to examine the relocs. */
1006 if (link_info->relocateable)
1007 {
1008 for (i = 0; i < bfd_count; i++)
1009 if (all_local_syms[i])
1010 free (all_local_syms[i]);
1011 free (all_local_syms);
1012 return true;
1013 }
1014
1015 /* Now that we have argument location information for all the global
1016 functions we can start looking for stubs. */
1017 for (input_bfd = link_info->input_bfds, index = 0;
1018 input_bfd != NULL;
1019 input_bfd = input_bfd->link_next, index++)
1020 {
1021 /* We'll need the symbol table in a second. */
1022 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1023 if (symtab_hdr->sh_info == 0)
1024 continue;
1025
1026 local_syms = all_local_syms[index];
1027
1028 /* Walk over each section attached to the input bfd. */
1029 for (section = input_bfd->sections;
1030 section != NULL;
1031 section = section->next)
1032 {
1033 Elf_Internal_Shdr *input_rel_hdr;
1034 Elf32_External_Rela *external_relocs, *erelaend, *erela;
1035 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
1036
1037 /* If there aren't any relocs, then there's nothing to do. */
1038 if ((section->flags & SEC_RELOC) == 0
1039 || section->reloc_count == 0)
1040 continue;
1041
1042 /* Allocate space for the external relocations. */
1043 external_relocs
1044 = ((Elf32_External_Rela *)
1045 bfd_malloc (section->reloc_count
1046 * sizeof (Elf32_External_Rela)));
1047 if (external_relocs == NULL)
1048 {
1049 for (i = 0; i < bfd_count; i++)
1050 if (all_local_syms[i])
1051 free (all_local_syms[i]);
1052 free (all_local_syms);
1053 goto error_return;
1054 }
1055
1056 /* Likewise for the internal relocations. */
1057 internal_relocs
1058 = ((Elf_Internal_Rela *)
1059 bfd_malloc (section->reloc_count * sizeof (Elf_Internal_Rela)));
1060 if (internal_relocs == NULL)
1061 {
1062 free (external_relocs);
1063 for (i = 0; i < bfd_count; i++)
1064 if (all_local_syms[i])
1065 free (all_local_syms[i]);
1066 free (all_local_syms);
1067 goto error_return;
1068 }
1069
1070 /* Read in the external relocs. */
1071 input_rel_hdr = &elf_section_data (section)->rel_hdr;
1072 if (bfd_seek (input_bfd, input_rel_hdr->sh_offset, SEEK_SET) != 0
1073 || bfd_read (external_relocs, 1, input_rel_hdr->sh_size,
1074 input_bfd) != input_rel_hdr->sh_size)
1075 {
1076 free (external_relocs);
1077 free (internal_relocs);
1078 for (i = 0; i < bfd_count; i++)
1079 if (all_local_syms[i])
1080 free (all_local_syms[i]);
1081 free (all_local_syms);
1082 goto error_return;
1083 }
1084
1085 /* Swap in the relocs. */
1086 erela = external_relocs;
1087 erelaend = erela + section->reloc_count;
1088 irela = internal_relocs;
1089 for (; erela < erelaend; erela++, irela++)
1090 bfd_elf32_swap_reloca_in (input_bfd, erela, irela);
1091
1092 /* We're done with the external relocs, free them. */
1093 free (external_relocs);
1094
1095 /* Now examine each relocation. */
1096 irela = internal_relocs;
1097 irelaend = irela + section->reloc_count;
1098 for (; irela < irelaend; irela++)
1099 {
31bd8f25 1100 long r_type, size_of_stub;
252b5132
RH		 1101 unsigned long r_index;
1102 struct elf_link_hash_entry *hash;
1103 struct elf32_hppa_stub_hash_entry *stub_hash;
252b5132
RH		 1104 Elf_Internal_Sym *sym;
1105 asection *sym_sec;
1106 const char *sym_name;
1107 symvalue sym_value;
1108 bfd_vma location, destination;
1109 char *new_name = NULL;
1110
1111 r_type = ELF32_R_TYPE (irela->r_info);
1112 r_index = ELF32_R_SYM (irela->r_info);
1113
1114 if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
1115 {
1116 bfd_set_error (bfd_error_bad_value);
1117 free (internal_relocs);
1118 for (i = 0; i < bfd_count; i++)
1119 if (all_local_syms[i])
1120 free (all_local_syms[i]);
1121 free (all_local_syms);
1122 goto error_return;
1123 }
1124
1125 /* Only look for stubs on call instructions or plabel
1126 references. */
1127 if (r_type != R_PARISC_PCREL17F
1128 && r_type != R_PARISC_PLABEL32
1129 && r_type != R_PARISC_PLABEL21L
1130 && r_type != R_PARISC_PLABEL14R)
1131 continue;
1132
1133 /* Now determine the call target, its name, value, section
1134 and argument relocation bits. */
1135 hash = NULL;
1136 sym = NULL;
1137 sym_sec = NULL;
1138 if (r_index < symtab_hdr->sh_info)
1139 {
1140 /* It's a local symbol. */
1141 Elf_Internal_Shdr *hdr;
1142
1143 sym = local_syms + r_index;
1144 hdr = elf_elfsections (input_bfd)[sym->st_shndx];
1145 sym_sec = hdr->bfd_section;
1146 sym_name = bfd_elf_string_from_elf_section (input_bfd,
1147 symtab_hdr->sh_link,
1148 sym->st_name);
1149 sym_value = (ELF_ST_TYPE (sym->st_info) == STT_SECTION
1150 ? 0 : sym->st_value);
1151 destination = (sym_value
1152 + sym_sec->output_offset
1153 + sym_sec->output_section->vma);
1154
1155 /* Tack on an ID so we can uniquely identify this local
1156 symbol in the stub or arg info hash tables. */
1157 new_name = bfd_malloc (strlen (sym_name) + 10);
1158 if (new_name == 0)
1159 {
1160 free (internal_relocs);
1161 for (i = 0; i < bfd_count; i++)
1162 if (all_local_syms[i])
1163 free (all_local_syms[i]);
1164 free (all_local_syms);
1165 goto error_return;
1166 }
1167 sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1168 sym_name = new_name;
1169 }
1170 else
1171 {
1172 /* It's an external symbol. */
1173 long index;
1174
1175 index = r_index - symtab_hdr->sh_info;
1176 hash = elf_sym_hashes (input_bfd)[index];
1177 if (hash->root.type == bfd_link_hash_defined
1178 || hash->root.type == bfd_link_hash_defweak)
1179 {
1180 sym_sec = hash->root.u.def.section;
1181 sym_name = hash->root.root.string;
1182 sym_value = hash->root.u.def.value;
1183 destination = (sym_value
1184 + sym_sec->output_offset
1185 + sym_sec->output_section->vma);
1186 }
1187 else
1188 {
1189 bfd_set_error (bfd_error_bad_value);
1190 free (internal_relocs);
1191 for (i = 0; i < bfd_count; i++)
1192 if (all_local_syms[i])
1193 free (all_local_syms[i]);
1194 free (all_local_syms);
1195 goto error_return;
1196 }
1197 }
1198
252b5132
RH		 1199 /* Now determine where the call point is. */
1200 location = (section->output_offset
1201 + section->output_section->vma
1202 + irela->r_offset);
1203
1204 /* We only care about the destination for PCREL function
1205 calls (eg. we don't care for PLABELS). */
1206 if (r_type != R_PARISC_PCREL17F)
1207 location = destination;
1208
1209 /* Determine what (if any) linker stub is needed and its
1210 size (in bytes). */
31bd8f25 1211 size_of_stub = elf32_hppa_size_of_stub (location,
252b5132
RH		 1212 destination,
1213 sym_name);
1214 if (size_of_stub != 0)
1215 {
1216 char *stub_name;
1217 unsigned int len;
1218
1219 /* Get the name of this stub. */
1220 len = strlen (sym_name);
1221 len += 23;
1222
1223 stub_name = bfd_malloc (len);
1224 if (!stub_name)
1225 {
1226 /* Because sym_name was mallocd above for local
1227 symbols. */
1228 if (r_index < symtab_hdr->sh_info)
1229 free (new_name);
1230
1231 free (internal_relocs);
1232 for (i = 0; i < bfd_count; i++)
1233 if (all_local_syms[i])
1234 free (all_local_syms[i]);
1235 free (all_local_syms);
1236 goto error_return;
1237 }
31bd8f25 1238 elf32_hppa_name_of_stub (location, destination, stub_name);
252b5132
RH		 1239 strcat (stub_name + 22, sym_name);
1240
1241 /* Because sym_name was malloced above for local symbols. */
1242 if (r_index < symtab_hdr->sh_info)
1243 free (new_name);
1244
1245 stub_hash
1246 = elf32_hppa_stub_hash_lookup (stub_hash_table, stub_name,
1247 false, false);
1248 if (stub_hash != NULL)
1249 {
1250 /* The proper stub has already been created, nothing
1251 else to do. */
1252 free (stub_name);
1253 }
1254 else
1255 {
1256 bfd_set_section_size (stub_bfd, stub_sec,
1257 (bfd_section_size (stub_bfd,
1258 stub_sec)
1259 + size_of_stub));
1260
1261 /* Enter this entry into the linker stub hash table. */
1262 stub_hash
1263 = elf32_hppa_stub_hash_lookup (stub_hash_table,
1264 stub_name, true, true);
1265 if (stub_hash == NULL)
1266 {
1267 free (stub_name);
1268 free (internal_relocs);
1269 for (i = 0; i < bfd_count; i++)
1270 if (all_local_syms[i])
1271 free (all_local_syms[i]);
1272 free (all_local_syms);
1273 goto error_return;
1274 }
1275
1276 /* We'll need these to determine the address that the
1277 stub will branch to. */
1278 stub_hash->target_value = sym_value;
1279 stub_hash->target_section = sym_sec;
1280 }
1281 free (stub_name);
1282 }
1283 }
1284 /* We're done with the internal relocs, free them. */
1285 free (internal_relocs);
1286 }
1287 }
1288 /* We're done with the local symbols, free them. */
1289 for (i = 0; i < bfd_count; i++)
1290 if (all_local_syms[i])
1291 free (all_local_syms[i]);
1292 free (all_local_syms);
1293 return true;
1294
1295error_return:
1296 /* Return gracefully, avoiding dangling references to the hash tables. */
1297 if (stub_hash_table)
1298 {
1299 elf32_hppa_hash_table(link_info)->stub_hash_table = NULL;
1300 free (stub_hash_table);
1301 }
252b5132
RH		 1302 /* Set the size of the stub section to zero since we're never going
1303 to create them. Avoids losing when we try to get its contents
1304 too. */
1305 bfd_set_section_size (stub_bfd, stub_sec, 0);
1306 return false;
1307}
1308
1309/* Misc BFD support code. */
1310#define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
1396cd2d 1311#define bfd_elf32_bfd_is_local_label_name elf_hppa_is_local_label_name
9e103c9c
JL		 1312#define elf_info_to_howto elf_hppa_info_to_howto
1313#define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
252b5132 1314
252b5132
RH		 1315/* Stuff for the BFD linker. */
1316#define elf_backend_relocate_section elf32_hppa_relocate_section
1317#define elf_backend_add_symbol_hook elf32_hppa_add_symbol_hook
252b5132
RH		 1318#define bfd_elf32_bfd_link_hash_table_create \
1319 elf32_hppa_link_hash_table_create
052e120f
JL		 1320#define elf_backend_fake_sections elf_hppa_fake_sections
1321
252b5132
RH		 1322
1323#define TARGET_BIG_SYM bfd_elf32_hppa_vec
1324#define TARGET_BIG_NAME "elf32-hppa"
1325#define ELF_ARCH bfd_arch_hppa
1326#define ELF_MACHINE_CODE EM_PARISC
1327#define ELF_MAXPAGESIZE 0x1000
1328
1329#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.104555 seconds and 4 git commands to generate.