]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/elf32-hppa.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
More patches from Jeff Law, plus a little cleanup of my own.
[thirdparty/binutils-gdb.git] / bfd / elf32-hppa.c
1 /* BFD back-end for HP PA-RISC ELF files.
2 Copyright (C) 1990-1991 Free Software Foundation, Inc.
3
4 Written by
5
6 Center for Software Science
7 Department of Computer Science
8 University of Utah
9
10 This file is part of BFD, the Binary File Descriptor library.
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
25
26 #include "bfd.h"
27 #include "sysdep.h"
28 #include "libbfd.h"
29 #include "obstack.h"
30 #include "libelf.h"
31
32 /* ELF32/HPPA relocation support
33
34 This file contains ELF32/HPPA relocation support as specified
35 in the Stratus FTX/Golf Object File Format (SED-1762) dated
36 November 19, 1992.
37 */
38
39 /*
40 Written by:
41
42 Center for Software Science
43 Department of Computer Science
44 University of Utah
45 */
46
47 #include "elf32-hppa.h"
48 #include "libhppa.h"
49 #include "aout/aout64.h"
50 #include "hppa_stubs.h"
51
52 /* ELF/PA relocation howto entries */
53
54 static bfd_reloc_status_type hppa_elf_reloc ();
55
56 static reloc_howto_type elf_hppa_howto_table[ELF_HOWTO_TABLE_SIZE] =
57 {
58 /* 'bitpos' and 'abs' are obsolete */
59 /* type rs sz bsz pcrel bpos abs ovrf sf name */
60 /* 9.3.4. Address relocation types */
61 {R_HPPA_NONE, 0, 3, 19, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_NONE"},
62 {R_HPPA_32, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_32"},
63 {R_HPPA_11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_11"},
64 {R_HPPA_14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_14"},
65 {R_HPPA_17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_17"},
66 {R_HPPA_L21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_L21"},
67 {R_HPPA_R11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_R11"},
68 {R_HPPA_R14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_R14"},
69 {R_HPPA_R17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_R17"},
70 {R_HPPA_LS21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LS21"},
71 {R_HPPA_RS11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RS11"},
72 {R_HPPA_RS14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RS14"},
73 {R_HPPA_RS17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RS17"},
74 {R_HPPA_LD21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LD21"},
75 {R_HPPA_RD11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RD11"},
76 {R_HPPA_RD14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RD14"},
77 {R_HPPA_RD17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RD17"},
78 {R_HPPA_LR21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LR21"},
79 {R_HPPA_RR14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RR14"},
80 {R_HPPA_RR17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RR17"},
81 /* 9.3.5. GOTOFF address relocation types */
82 {R_HPPA_GOTOFF_11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_11"},
83 {R_HPPA_GOTOFF_14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_14"},
84 {R_HPPA_GOTOFF_L21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_L21"},
85 {R_HPPA_GOTOFF_R11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_R11"},
86 {R_HPPA_GOTOFF_R14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_R14"},
87 {R_HPPA_GOTOFF_LS21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_LS21"},
88 {R_HPPA_GOTOFF_RS11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RS11"},
89 {R_HPPA_GOTOFF_RS14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RS14"},
90 {R_HPPA_GOTOFF_LD21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_LD21"},
91 {R_HPPA_GOTOFF_RD11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RD11"},
92 {R_HPPA_GOTOFF_RD14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RD14"},
93 {R_HPPA_GOTOFF_LR21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_LR21"},
94 {R_HPPA_GOTOFF_RR14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RR14"},
95 /* 9.3.6. Absolute call relocation types */
96 {R_HPPA_ABS_CALL_11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_11"},
97 {R_HPPA_ABS_CALL_14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_14"},
98 {R_HPPA_ABS_CALL_17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_17"},
99 {R_HPPA_ABS_CALL_L21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_L21"},
100 {R_HPPA_ABS_CALL_R11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_R11"},
101 {R_HPPA_ABS_CALL_R14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_R14"},
102 {R_HPPA_ABS_CALL_R17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_R17"},
103 {R_HPPA_ABS_CALL_LS21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_LS21"},
104 {R_HPPA_ABS_CALL_RS11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RS11"},
105 {R_HPPA_ABS_CALL_RS14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RS14"},
106 {R_HPPA_ABS_CALL_RS17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RS17"},
107 {R_HPPA_ABS_CALL_LD21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_LD21"},
108 {R_HPPA_ABS_CALL_RD11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RD11"},
109 {R_HPPA_ABS_CALL_RD14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RD14"},
110 {R_HPPA_ABS_CALL_RD17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RD17"},
111 {R_HPPA_ABS_CALL_LR21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_LR21"},
112 {R_HPPA_ABS_CALL_RR14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RR14"},
113 {R_HPPA_ABS_CALL_RR17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RR17"},
114 /* 9.3.7. PC-relative call relocation types */
115 {R_HPPA_PCREL_CALL_11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_11"},
116 {R_HPPA_PCREL_CALL_14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_14"},
117 {R_HPPA_PCREL_CALL_17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_17"},
118 {R_HPPA_PCREL_CALL_12, 0, 3, 12, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_12"},
119 {R_HPPA_PCREL_CALL_L21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_L21"},
120 {R_HPPA_PCREL_CALL_R11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_R11"},
121 {R_HPPA_PCREL_CALL_R14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_R14"},
122 {R_HPPA_PCREL_CALL_R17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_R17"},
123 {R_HPPA_PCREL_CALL_LS21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_LS21"},
124 {R_HPPA_PCREL_CALL_RS11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RS11"},
125 {R_HPPA_PCREL_CALL_RS14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RS14"},
126 {R_HPPA_PCREL_CALL_RS17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RS17"},
127 {R_HPPA_PCREL_CALL_LD21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_LD21"},
128 {R_HPPA_PCREL_CALL_RD11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RD11"},
129 {R_HPPA_PCREL_CALL_RD14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RD14"},
130 {R_HPPA_PCREL_CALL_RD17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RD17"},
131 {R_HPPA_PCREL_CALL_LR21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_LR21"},
132 {R_HPPA_PCREL_CALL_RR14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RR14"},
133 {R_HPPA_PCREL_CALL_RR17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RR17"},
134
135 /* 9.3.8. Plabel relocation types */
136 {R_HPPA_PLABEL_32, 0, 3, 32, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_32"},
137 {R_HPPA_PLABEL_11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_11"},
138 {R_HPPA_PLABEL_14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_14"},
139 {R_HPPA_PLABEL_L21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_L21"},
140 {R_HPPA_PLABEL_R11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_R11"},
141 {R_HPPA_PLABEL_R14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_R14"},
142
143 /* 9.3.9. Data linkage table (DLT) relocation types */
144 {R_HPPA_DLT_32, 0, 3, 32, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_32"},
145 {R_HPPA_DLT_11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_11"},
146 {R_HPPA_DLT_14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_14"},
147 {R_HPPA_DLT_L21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_L21"},
148 {R_HPPA_DLT_R11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_R11"},
149 {R_HPPA_DLT_R14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_R14"},
150
151 /* 9.3.10. Relocations for unwinder tables */
152 {R_HPPA_UNWIND_ENTRY, 0, 3, 32, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_UNWIND_ENTRY"},
153 {R_HPPA_UNWIND_ENTRIES, 0, 3, 32, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_UNWIND_ENTRIES"},
154
155 /* 9.3.11. Relocation types for complex expressions */
156 {R_HPPA_PUSH_CONST, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_CONST"},
157 {R_HPPA_PUSH_PC, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_PC"},
158 {R_HPPA_PUSH_SYM, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_SYM"},
159 {R_HPPA_PUSH_GOTOFF, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_GOTOFF"},
160 {R_HPPA_PUSH_ABS_CALL, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_ABS_CALL"},
161 {R_HPPA_PUSH_PCREL_CALL, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_PCREL_CALL"},
162 {R_HPPA_PUSH_PLABEL, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_PLABEL"},
163 {R_HPPA_MAX, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_MAX"},
164 {R_HPPA_MIN, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_MIN"},
165 {R_HPPA_ADD, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ADD"},
166 {R_HPPA_SUB, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_SUB"},
167 {R_HPPA_MULT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_MULT"},
168 {R_HPPA_DIV, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_DIV"},
169 {R_HPPA_MOD, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_MOD"},
170 {R_HPPA_AND, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_AND"},
171 {R_HPPA_OR, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_OR"},
172 {R_HPPA_XOR, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_XOR"},
173 {R_HPPA_NOT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_NOT"},
174 {R_HPPA_LSHIFT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LSHIFT"},
175 {R_HPPA_ARITH_RSHIFT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ARITH_RSHIFT"},
176 {R_HPPA_LOGIC_RSHIFT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LOGIC_RSHIFT"},
177 {R_HPPA_EXPR_F, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_L"},
178 {R_HPPA_EXPR_L, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_L"},
179 {R_HPPA_EXPR_R, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_R"},
180 {R_HPPA_EXPR_LS, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_LS"},
181 {R_HPPA_EXPR_RS, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_RS"},
182 {R_HPPA_EXPR_LD, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_LD"},
183 {R_HPPA_EXPR_RD, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_RD"},
184 {R_HPPA_EXPR_LR, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_LR"},
185 {R_HPPA_EXPR_RR, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_RR"},
186
187 {R_HPPA_EXPR_32, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_32"},
188 {R_HPPA_EXPR_21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_21"},
189 {R_HPPA_EXPR_11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_11"},
190 {R_HPPA_EXPR_14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_14"},
191 {R_HPPA_EXPR_17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_17"},
192 {R_HPPA_EXPR_12, 0, 3, 12, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_12"},
193 {R_HPPA_STUB_CALL_17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_STUB_CALL_17"},
194 {R_HPPA_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont, NULL, "R_HPPA_UNIMPLEMENTED"},
195 };
196
197 static symext_chainS *symext_rootP;
198 static symext_chainS *symext_lastP;
199
200 static unsigned long
201 DEFUN (hppa_elf_rebuild_insn, (abfd, insn, value, r_type, r_field, r_format),
202 bfd * abfd AND
203 unsigned long insn AND
204 unsigned long value AND
205 unsigned short r_type AND
206 unsigned short r_field AND
207 unsigned short r_format)
208 {
209 unsigned long const_part; /* part of the instruction that does not change */
210 unsigned long rebuilt_part;
211
212 switch (r_format)
213 {
214 case 11:
215 {
216 unsigned w1, w;
217
218 const_part = insn & 0xffffe002;
219 dis_assemble_12 (value, &w1, &w);
220 rebuilt_part = (w1 << 2) | w;
221 return const_part | rebuilt_part;
222 }
223
224 case 12:
225 {
226 unsigned w1, w;
227
228 const_part = insn & 0xffffe002;
229 dis_assemble_12 (value, &w1, &w);
230 rebuilt_part = (w1 << 2) | w;
231 return const_part | rebuilt_part;
232 }
233
234 case 14:
235 const_part = insn & 0xffffc000;
236 low_sign_unext (value, 14, &rebuilt_part);
237 return const_part | rebuilt_part;
238
239 case 17:
240 {
241 unsigned w1, w2, w;
242
243 const_part = insn & 0xffe0e002;
244 dis_assemble_17 (value, &w1, &w2, &w);
245 rebuilt_part = (w2 << 2) | (w1 << 16) | w;
246 return const_part | rebuilt_part;
247 }
248
249 case 21:
250 const_part = insn & 0xffe00000;
251 dis_assemble_21 (value, &rebuilt_part);
252 return const_part | rebuilt_part;
253
254 case 32:
255 const_part = 0;
256 return value;
257
258 default:
259 fprintf (stderr, "Relocation problem : ");
260 fprintf (stderr,
261 "Unrecognized reloc type %d (fmt=%d,fld=%d), in module %s\n",
262 r_type, r_format, r_field, abfd->filename);
263 }
264 return insn;
265 }
266
267 static unsigned long
268 DEFUN (hppa_elf_relocate_insn,
269 (abfd, input_sect,
270 insn, address, symp, sym_value, r_addend,
271 r_type, r_format, r_field, pcrel),
272 bfd * abfd AND
273 asection * input_sect AND
274 unsigned long insn AND
275 unsigned long address AND
276 asymbol * symp AND
277 long sym_value AND
278 long r_addend AND
279 unsigned short r_type AND
280 unsigned short r_format AND
281 unsigned short r_field AND
282 unsigned char pcrel)
283 {
284 unsigned char opcode = get_opcode (insn);
285 long constant_value;
286 unsigned arg_reloc;
287
288 switch (opcode)
289 {
290 case LDO:
291 case LDB:
292 case LDH:
293 case LDW:
294 case LDWM:
295 case STB:
296 case STH:
297 case STW:
298 case STWM:
299 constant_value = ELF32_HPPA_R_CONSTANT (r_addend);
300 BFD_ASSERT (r_format == 14);
301
302 if (pcrel)
303 sym_value -= address;
304 sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
305 return hppa_elf_rebuild_insn (abfd, insn, sym_value, r_type, r_field, r_format);
306
307 case COMICLR:
308 case SUBI: /* case SUBIO: */
309 case ADDIT: /* case ADDITO: */
310 case ADDI: /* case ADDIO: */
311 BFD_ASSERT (r_format == 11);
312
313 constant_value = ((insn & 0x1) << 10) | ((insn & 0xffe) >> 1);
314 sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
315 return hppa_elf_rebuild_insn (abfd, insn, sym_value, r_type, r_field, r_format);
316
317 case LDIL:
318 case ADDIL:
319 BFD_ASSERT (r_format == 21);
320
321 constant_value = assemble_21 (insn);
322 constant_value += ELF32_HPPA_R_CONSTANT (r_addend);
323 sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
324 return hppa_elf_rebuild_insn (abfd, insn, sym_value, r_type, r_field, r_format);
325
326 case BL:
327 case BE:
328 case BLE:
329 arg_reloc = ELF32_HPPA_R_ARG_RELOC (r_addend);
330
331 BFD_ASSERT (r_format == 17);
332
333 /* XXX computing constant_value is not needed??? */
334 constant_value = assemble_17 ((insn & 0x001f0000) >> 16,
335 (insn & 0x00001ffc) >> 2,
336 insn & 1);
337 /* @@ Assumes only 32 bits. */
338 constant_value = (constant_value << 15) >> 15;
339 if (pcrel)
340 {
341 sym_value -=
342 address + input_sect->output_offset
343 + input_sect->output_section->vma;
344 sym_value = hppa_field_adjust (sym_value, -8, r_field);
345 }
346 else
347 sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
348
349 return hppa_elf_rebuild_insn (abfd, insn, sym_value >> 2, r_type, r_field, r_format);
350
351 default:
352 if (opcode == 0)
353 {
354 BFD_ASSERT (r_format == 32);
355 constant_value = insn;
356 constant_value += ELF32_HPPA_R_CONSTANT (r_addend);
357
358 return hppa_field_adjust (sym_value, constant_value, r_field);
359 }
360 else
361 {
362 fprintf (stderr,
363 "Unrecognized opcode 0x%02x (fmt=%x,field=%x)\n",
364 opcode, r_format, r_field);
365 return insn;
366 }
367 }
368 }
369
370 static void
371 DEFUN (hppa_elf_relocate_unwind_table,
372 (abfd, input_sect,
373 data, address, symp, sym_value, r_addend,
374 r_type, r_format, r_field, pcrel),
375 bfd * abfd AND
376 asection * input_sect AND
377 PTR data AND
378 unsigned long address AND
379 asymbol * symp AND
380 long sym_value AND
381 long r_addend AND
382 unsigned short r_type AND
383 unsigned short r_format AND
384 unsigned short r_field AND
385 unsigned char pcrel)
386 {
387 bfd_byte *hit_data = address + (bfd_byte *) (data);
388 long start_offset;
389 long end_offset;
390 long relocated_value;
391 int i;
392
393 BFD_ASSERT (r_format == 32);
394 BFD_ASSERT (r_field == e_fsel);
395 switch (r_type)
396 {
397 case R_HPPA_UNWIND_ENTRY:
398 start_offset = bfd_get_32 (abfd, hit_data);
399 relocated_value = hppa_field_adjust (sym_value, start_offset, r_field);
400 bfd_put_32 (abfd, relocated_value, hit_data);
401
402 hit_data += sizeof (unsigned long);
403 end_offset = bfd_get_32 (abfd, hit_data);
404 relocated_value = hppa_field_adjust (sym_value, end_offset, r_field);
405 bfd_put_32 (abfd, relocated_value, hit_data);
406 break;
407
408 case R_HPPA_UNWIND_ENTRIES:
409 for (i = 0; i < r_addend; i++, hit_data += 3 * sizeof (unsigned long))
410 {
411 unsigned int adjustment;
412 start_offset = bfd_get_32 (abfd, hit_data);
413 /* Stuff the symbol value into the first word */
414 /* of the unwind descriptor */
415 bfd_put_32 (abfd, sym_value, hit_data);
416 adjustment = sym_value - start_offset;
417
418 hit_data += sizeof (unsigned long);
419 end_offset = adjustment + bfd_get_32 (abfd, hit_data);
420 bfd_put_32 (abfd, end_offset, hit_data);
421
422 /* If this is not the last unwind entry, */
423 /* adjust the symbol value. */
424 if (i + 1 < r_addend)
425 {
426 start_offset = bfd_get_32 (abfd, hit_data + 3 * sizeof (unsigned long));
427 sym_value = start_offset + adjustment;
428 }
429 }
430 break;
431
432 default:
433 fprintf (stderr,
434 "Unrecognized relocation type 0x%02x (fmt=%x,field=%x)\n",
435 r_type, r_format, r_field);
436 }
437 }
438
439 /* Provided the symbol, returns the value reffed */
440 static long
441 get_symbol_value (symbol)
442 asymbol *symbol;
443 {
444 long relocation = 0;
445
446 if (symbol == (asymbol *) NULL)
447 relocation = 0;
448 else if (symbol->section == &bfd_com_section)
449 {
450 relocation = 0;
451 }
452 else
453 {
454 relocation = symbol->value +
455 symbol->section->output_section->vma +
456 symbol->section->output_offset;
457 }
458
459 return (relocation);
460 }
461
462 /* This function provides a pretty straight-forward mapping between a */
463 /* base relocation type, format and field into the relocation type */
464 /* that will be emitted in an object file. The only wrinkle in the */
465 /* mapping is that when the T, TR, TL, P, PR, or PL expression */
466 /* prefixes are involved, the type gets promoted to a *_GOTOFF_* */
467 /* relocation (in the case of T, TR, and TL) or a PLABEL relocation */
468 /* (in the case of P, PR, and PL). */
469
470 /* NOTE: XXX the T, TR, TL, P, PR, and PL expression prefixes are not */
471 /* handled yet. */
472
473 static void
474 hppa_elf_gen_reloc_error (base_type, fmt, field)
475 elf32_hppa_reloc_type base_type;
476 int fmt;
477 int field;
478 {
479 fprintf (stderr, "undefined relocation: base=0x%x,fmt=0x%x,field=0x%x\n",
480 base_type, fmt, field);
481 }
482
483 elf32_hppa_reloc_type **
484 hppa_elf_gen_reloc_type (abfd, base_type, format, field)
485 bfd *abfd;
486 elf32_hppa_reloc_type base_type;
487 int format;
488 int field;
489 {
490 #define UNDEFINED hppa_elf_gen_reloc_error(base_type,format,field)
491
492 elf32_hppa_reloc_type *finaltype;
493 elf32_hppa_reloc_type **final_types;
494 int i;
495
496 final_types = (elf32_hppa_reloc_type **) bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type *) * 2);
497 BFD_ASSERT (final_types != 0);
498
499 finaltype = (elf32_hppa_reloc_type *) bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type));
500 BFD_ASSERT (finaltype != 0);
501
502 final_types[0] = finaltype;
503 final_types[1] = NULL;
504
505 #define final_type finaltype[0]
506
507 final_type = base_type;
508
509 switch (base_type)
510 {
511 case R_HPPA:
512 switch (format)
513 {
514 case 11:
515 switch (field)
516 {
517 case e_fsel:
518 final_type = R_HPPA_11;
519 break;
520 case e_rsel:
521 final_type = R_HPPA_R11;
522 break;
523 case e_rssel:
524 final_type = R_HPPA_RS11;
525 break;
526 case e_rdsel:
527 final_type = R_HPPA_RD11;
528 break;
529
530 case e_psel:
531 final_type = R_HPPA_PLABEL_11;
532 break;
533 case e_rpsel:
534 final_type = R_HPPA_PLABEL_R11;
535 break;
536 case e_lpsel:
537 case e_tsel:
538 case e_ltsel:
539 case e_rtsel:
540
541 case e_lsel:
542 case e_lrsel:
543 case e_lssel:
544 case e_rrsel:
545 default:
546 UNDEFINED;
547 final_type = base_type;
548 break;
549 }
550 break;
551 case 12:
552 UNDEFINED;
553 break;
554 case 14:
555 switch (field)
556 {
557 case e_rsel:
558 final_type = R_HPPA_R14;
559 break;
560 case e_rssel:
561 final_type = R_HPPA_RS14;
562 break;
563 case e_rdsel:
564 final_type = R_HPPA_RD14;
565 break;
566 case e_rrsel:
567 final_type = R_HPPA_RR14;
568 break;
569
570 case e_psel:
571 final_type = R_HPPA_PLABEL_14;
572 break;
573 case e_rpsel:
574 final_type = R_HPPA_PLABEL_R14;
575 break;
576 case e_lpsel:
577 case e_tsel:
578 case e_ltsel:
579 case e_rtsel:
580
581 case e_fsel:
582 case e_lsel:
583 case e_lssel:
584 case e_ldsel:
585 case e_lrsel:
586 default:
587 UNDEFINED;
588 final_type = base_type;
589 break;
590 }
591 break;
592 case 17:
593 switch (field)
594 {
595 case e_fsel:
596 final_type = R_HPPA_17;
597 break;
598 case e_rsel:
599 final_type = R_HPPA_R17;
600 break;
601 case e_rssel:
602 final_type = R_HPPA_RS17;
603 break;
604 case e_rdsel:
605 final_type = R_HPPA_RD17;
606 break;
607 case e_rrsel:
608 final_type = R_HPPA_RR17;
609 break;
610 case e_lsel:
611 case e_lssel:
612 case e_ldsel:
613 case e_lrsel:
614 default:
615 UNDEFINED;
616 final_type = base_type;
617 break;
618 }
619 break;
620 case 21:
621 switch (field)
622 {
623 case e_lsel:
624 final_type = R_HPPA_L21;
625 break;
626 case e_lssel:
627 final_type = R_HPPA_LS21;
628 break;
629 case e_ldsel:
630 final_type = R_HPPA_LD21;
631 break;
632 case e_lrsel:
633 final_type = R_HPPA_LR21;
634 break;
635 case e_lpsel:
636 final_type = R_HPPA_PLABEL_L21;
637 break;
638 case e_rsel:
639 case e_rssel:
640 case e_rdsel:
641 case e_rrsel:
642 case e_fsel:
643 default:
644 UNDEFINED;
645 final_type = base_type;
646 break;
647 }
648 break;
649 case 32:
650 switch (field)
651 {
652 case e_fsel:
653 final_type = R_HPPA_32;
654 break;
655 case e_psel:
656 final_type = R_HPPA_PLABEL_32;
657 break;
658 default:
659 UNDEFINED;
660 final_type = base_type;
661 break;
662 }
663 break;
664 default:
665 UNDEFINED;
666 final_type = base_type;
667 break;
668 }
669 break;
670 case R_HPPA_GOTOFF:
671 switch (format)
672 {
673 case 11:
674 switch (field)
675 {
676 case e_rsel:
677 final_type = R_HPPA_GOTOFF_R11;
678 break;
679 case e_rssel:
680 final_type = R_HPPA_GOTOFF_RS11;
681 break;
682 case e_rdsel:
683 final_type = R_HPPA_GOTOFF_RD11;
684 break;
685 case e_fsel:
686 final_type = R_HPPA_GOTOFF_11;
687 break;
688 case e_lsel:
689 case e_lrsel:
690 case e_lssel:
691 case e_rrsel:
692 default:
693 UNDEFINED;
694 final_type = base_type;
695 break;
696 }
697 break;
698 case 12:
699 UNDEFINED;
700 final_type = base_type;
701 break;
702 case 14:
703 switch (field)
704 {
705 case e_rsel:
706 final_type = R_HPPA_GOTOFF_R14;
707 break;
708 case e_rssel:
709 final_type = R_HPPA_GOTOFF_RS14;
710 break;
711 case e_rdsel:
712 final_type = R_HPPA_GOTOFF_RD14;
713 break;
714 case e_rrsel:
715 final_type = R_HPPA_GOTOFF_RR14;
716 break;
717 case e_fsel:
718 final_type = R_HPPA_GOTOFF_14;
719 break;
720 case e_lsel:
721 case e_lssel:
722 case e_ldsel:
723 case e_lrsel:
724 default:
725 UNDEFINED;
726 final_type = base_type;
727 break;
728 }
729 break;
730 case 17:
731 UNDEFINED;
732 final_type = base_type;
733 break;
734 case 21:
735 switch (field)
736 {
737 case e_lsel:
738 final_type = R_HPPA_GOTOFF_L21;
739 break;
740 case e_lssel:
741 final_type = R_HPPA_GOTOFF_LS21;
742 break;
743 case e_ldsel:
744 final_type = R_HPPA_GOTOFF_LD21;
745 break;
746 case e_lrsel:
747 final_type = R_HPPA_GOTOFF_LR21;
748 break;
749 case e_rsel:
750 case e_rssel:
751 case e_rdsel:
752 case e_rrsel:
753 case e_fsel:
754 default:
755 UNDEFINED;
756 final_type = base_type;
757 break;
758 }
759 break;
760 case 32:
761 UNDEFINED;
762 final_type = base_type;
763 break;
764 default:
765 UNDEFINED;
766 final_type = base_type;
767 break;
768 }
769 break;
770 case R_HPPA_PCREL_CALL:
771 switch (format)
772 {
773 case 11:
774 switch (field)
775 {
776 case e_rsel:
777 final_type = R_HPPA_PCREL_CALL_R11;
778 break;
779 case e_rssel:
780 final_type = R_HPPA_PCREL_CALL_RS11;
781 break;
782 case e_rdsel:
783 final_type = R_HPPA_PCREL_CALL_RD11;
784 break;
785 case e_fsel:
786 final_type = R_HPPA_PCREL_CALL_11;
787 break;
788 case e_lsel:
789 case e_lrsel:
790 case e_lssel:
791 case e_rrsel:
792 default:
793 UNDEFINED;
794 final_type = base_type;
795 break;
796 }
797 break;
798 case 12:
799 UNDEFINED;
800 final_type = base_type;
801 break;
802 case 14:
803 switch (field)
804 {
805 case e_rsel:
806 final_type = R_HPPA_PCREL_CALL_R14;
807 break;
808 case e_rssel:
809 final_type = R_HPPA_PCREL_CALL_RS14;
810 break;
811 case e_rdsel:
812 final_type = R_HPPA_PCREL_CALL_RD14;
813 break;
814 case e_rrsel:
815 final_type = R_HPPA_PCREL_CALL_RR14;
816 break;
817 case e_fsel:
818 final_type = R_HPPA_PCREL_CALL_14;
819 break;
820 case e_lsel:
821 case e_lssel:
822 case e_ldsel:
823 case e_lrsel:
824 default:
825 UNDEFINED;
826 final_type = base_type;
827 break;
828 }
829 break;
830 case 17:
831 switch (field)
832 {
833 case e_rsel:
834 final_type = R_HPPA_PCREL_CALL_R17;
835 break;
836 case e_rssel:
837 final_type = R_HPPA_PCREL_CALL_RS17;
838 break;
839 case e_rdsel:
840 final_type = R_HPPA_PCREL_CALL_RD17;
841 break;
842 case e_rrsel:
843 final_type = R_HPPA_PCREL_CALL_RR17;
844 break;
845 case e_fsel:
846 final_type = R_HPPA_PCREL_CALL_17;
847 break;
848 case e_lsel:
849 case e_lssel:
850 case e_ldsel:
851 case e_lrsel:
852 default:
853 UNDEFINED;
854 final_type = base_type;
855 break;
856 }
857 break;
858 case 21:
859 switch (field)
860 {
861 case e_lsel:
862 final_type = R_HPPA_PCREL_CALL_L21;
863 break;
864 case e_lssel:
865 final_type = R_HPPA_PCREL_CALL_LS21;
866 break;
867 case e_ldsel:
868 final_type = R_HPPA_PCREL_CALL_LD21;
869 break;
870 case e_lrsel:
871 final_type = R_HPPA_PCREL_CALL_LR21;
872 break;
873 case e_rsel:
874 case e_rssel:
875 case e_rdsel:
876 case e_rrsel:
877 case e_fsel:
878 default:
879 UNDEFINED;
880 final_type = base_type;
881 break;
882 }
883 break;
884 case 32:
885 UNDEFINED;
886 final_type = base_type;
887 break;
888 default:
889 UNDEFINED;
890 final_type = base_type;
891 break;
892 }
893 break;
894 case R_HPPA_PLABEL:
895 switch (format)
896 {
897 case 11:
898 switch (field)
899 {
900 case e_fsel:
901 final_type = R_HPPA_PLABEL_11;
902 break;
903 case e_rsel:
904 final_type = R_HPPA_PLABEL_R11;
905 break;
906 default:
907 UNDEFINED;
908 final_type = base_type;
909 break;
910 }
911 break;
912 case 14:
913 switch (field)
914 {
915 case e_fsel:
916 final_type = R_HPPA_PLABEL_14;
917 break;
918 case e_rsel:
919 final_type = R_HPPA_PLABEL_R14;
920 break;
921 default:
922 UNDEFINED;
923 final_type = base_type;
924 break;
925 }
926 break;
927 case 21:
928 switch (field)
929 {
930 case e_lsel:
931 final_type = R_HPPA_PLABEL_L21;
932 break;
933 default:
934 UNDEFINED;
935 final_type = base_type;
936 break;
937 }
938 break;
939 case 32:
940 switch (field)
941 {
942 case e_fsel:
943 final_type = R_HPPA_PLABEL_32;
944 break;
945 default:
946 UNDEFINED;
947 final_type = base_type;
948 break;
949 }
950 break;
951 default:
952 UNDEFINED;
953 final_type = base_type;
954 break;
955 }
956 case R_HPPA_ABS_CALL:
957 switch (format)
958 {
959 case 11:
960 switch (field)
961 {
962 case e_rsel:
963 final_type = R_HPPA_ABS_CALL_R11;
964 break;
965 case e_rssel:
966 final_type = R_HPPA_ABS_CALL_RS11;
967 break;
968 case e_rdsel:
969 final_type = R_HPPA_ABS_CALL_RD11;
970 break;
971 case e_fsel:
972 final_type = R_HPPA_ABS_CALL_11;
973 break;
974 case e_lsel:
975 case e_lrsel:
976 case e_lssel:
977 case e_rrsel:
978 default:
979 UNDEFINED;
980 final_type = base_type;
981 break;
982 }
983 break;
984 case 12:
985 UNDEFINED;
986 final_type = base_type;
987 break;
988 case 14:
989 switch (field)
990 {
991 case e_rsel:
992 final_type = R_HPPA_ABS_CALL_R14;
993 break;
994 case e_rssel:
995 final_type = R_HPPA_ABS_CALL_RS14;
996 break;
997 case e_rdsel:
998 final_type = R_HPPA_ABS_CALL_RD14;
999 break;
1000 case e_rrsel:
1001 final_type = R_HPPA_ABS_CALL_RR14;
1002 break;
1003 case e_fsel:
1004 final_type = R_HPPA_ABS_CALL_14;
1005 break;
1006 case e_lsel:
1007 case e_lssel:
1008 case e_ldsel:
1009 case e_lrsel:
1010 default:
1011 UNDEFINED;
1012 final_type = base_type;
1013 break;
1014 }
1015 break;
1016 case 17:
1017 switch (field)
1018 {
1019 case e_rsel:
1020 final_type = R_HPPA_ABS_CALL_R17;
1021 break;
1022 case e_rssel:
1023 final_type = R_HPPA_ABS_CALL_RS17;
1024 break;
1025 case e_rdsel:
1026 final_type = R_HPPA_ABS_CALL_RD17;
1027 break;
1028 case e_rrsel:
1029 final_type = R_HPPA_ABS_CALL_RR17;
1030 break;
1031 case e_fsel:
1032 final_type = R_HPPA_ABS_CALL_17;
1033 break;
1034 case e_lsel:
1035 case e_lssel:
1036 case e_ldsel:
1037 case e_lrsel:
1038 default:
1039 UNDEFINED;
1040 final_type = base_type;
1041 break;
1042 }
1043 break;
1044 case 21:
1045 switch (field)
1046 {
1047 case e_lsel:
1048 final_type = R_HPPA_ABS_CALL_L21;
1049 break;
1050 case e_lssel:
1051 final_type = R_HPPA_ABS_CALL_LS21;
1052 break;
1053 case e_ldsel:
1054 final_type = R_HPPA_ABS_CALL_LD21;
1055 break;
1056 case e_lrsel:
1057 final_type = R_HPPA_ABS_CALL_LR21;
1058 break;
1059 case e_rsel:
1060 case e_rssel:
1061 case e_rdsel:
1062 case e_rrsel:
1063 case e_fsel:
1064 default:
1065 UNDEFINED;
1066 final_type = base_type;
1067 break;
1068 }
1069 break;
1070 case 32:
1071 UNDEFINED;
1072 final_type = base_type;
1073 break;
1074 default:
1075 UNDEFINED;
1076 final_type = base_type;
1077 break;
1078 }
1079 break;
1080 case R_HPPA_UNWIND:
1081 final_type = R_HPPA_UNWIND_ENTRY;
1082 break;
1083 case R_HPPA_COMPLEX:
1084 case R_HPPA_COMPLEX_PCREL_CALL:
1085 case R_HPPA_COMPLEX_ABS_CALL:
1086 final_types = (elf32_hppa_reloc_type **) bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type *) * 6);
1087 BFD_ASSERT (final_types != 0);
1088
1089 finaltype = (elf32_hppa_reloc_type *) bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type) * 5);
1090 BFD_ASSERT (finaltype != 0);
1091
1092 for (i = 0; i < 5; i++)
1093 final_types[i] = &finaltype[i];
1094
1095 final_types[5] = NULL;
1096
1097 finaltype[0] = R_HPPA_PUSH_SYM;
1098
1099 if (base_type == R_HPPA_COMPLEX)
1100 finaltype[1] = R_HPPA_PUSH_SYM;
1101 else if (base_type == R_HPPA_COMPLEX_PCREL_CALL)
1102 finaltype[1] = R_HPPA_PUSH_PCREL_CALL;
1103 else /* base_type == R_HPPA_COMPLEX_ABS_CALL */
1104 finaltype[1] = R_HPPA_PUSH_ABS_CALL;
1105
1106 finaltype[2] = R_HPPA_SUB;
1107
1108 switch (field)
1109 {
1110 case e_fsel:
1111 finaltype[3] = R_HPPA_EXPR_F;
1112 break;
1113 case e_lsel:
1114 finaltype[3] = R_HPPA_EXPR_L;
1115 break;
1116 case e_rsel:
1117 finaltype[3] = R_HPPA_EXPR_R;
1118 break;
1119 case e_lssel:
1120 finaltype[3] = R_HPPA_EXPR_LS;
1121 break;
1122 case e_rssel:
1123 finaltype[3] = R_HPPA_EXPR_RS;
1124 break;
1125 case e_ldsel:
1126 finaltype[3] = R_HPPA_EXPR_LD;
1127 break;
1128 case e_rdsel:
1129 finaltype[3] = R_HPPA_EXPR_RD;
1130 break;
1131 case e_lrsel:
1132 finaltype[3] = R_HPPA_EXPR_LR;
1133 break;
1134 case e_rrsel:
1135 finaltype[3] = R_HPPA_EXPR_RR;
1136 break;
1137 }
1138
1139 switch (format)
1140 {
1141 case 11:
1142 finaltype[4] = R_HPPA_EXPR_11;
1143 break;
1144 case 12:
1145 finaltype[4] = R_HPPA_EXPR_12;
1146 break;
1147 case 14:
1148 finaltype[4] = R_HPPA_EXPR_14;
1149 break;
1150 case 17:
1151 finaltype[4] = R_HPPA_EXPR_17;
1152 break;
1153 case 21:
1154 finaltype[4] = R_HPPA_EXPR_21;
1155 break;
1156 case 32:
1157 finaltype[4] = R_HPPA_EXPR_32;
1158 break;
1159 }
1160
1161 break;
1162
1163 default:
1164 final_type = base_type;
1165 break;
1166 }
1167
1168 return final_types;
1169 }
1170
1171 #undef final_type
1172
1173 /* 12.4.4. Derive format from instruction
1174
1175 Given a machine instruction, this function determines its format.
1176 The format can be determined solely from looking at the first six
1177 bits (the major opcode) of the instruction. Several major opcodes
1178 map to the same format. Opcodes which do not map to a known format
1179 should probably be reported as an error. */
1180
1181 unsigned char
1182 hppa_elf_insn2fmt (type, insn)
1183 elf32_hppa_reloc_type type;
1184 unsigned long insn;
1185 {
1186 unsigned char fmt = 0; /* XXX: is this a proper default? */
1187 unsigned char op = get_opcode (insn);
1188
1189 if (type == R_HPPA_NONE)
1190 fmt = 0;
1191 else
1192 {
1193 switch (op)
1194 {
1195 case ADDI:
1196 case ADDIT:
1197 case SUBI:
1198 fmt = 11;
1199 break;
1200 case MOVB:
1201 case MOVIB:
1202 case COMBT:
1203 case COMBF:
1204 case COMIBT:
1205 case COMIBF:
1206 case ADDBT:
1207 case ADDBF:
1208 case ADDIBT:
1209 case ADDIBF:
1210 case BVB:
1211 case BB:
1212 fmt = 12;
1213 break;
1214 case LDO:
1215 case LDB:
1216 case LDH:
1217 case LDW:
1218 case LDWM:
1219 case STB:
1220 case STH:
1221 case STW:
1222 case STWM:
1223 fmt = 14;
1224 break;
1225 case BL:
1226 case BE:
1227 case BLE:
1228 fmt = 17;
1229 break;
1230 case LDIL:
1231 case ADDIL:
1232 fmt = 21;
1233 break;
1234 default:
1235 fmt = 32;
1236 break;
1237 }
1238
1239 }
1240 return fmt;
1241 }
1242
1243 /* this function is in charge of performing all the HP PA relocations */
1244 static long global_value;
1245 static long GOT_value; /* XXX: need to calculate this! For HPUX, GOT == DP */
1246 static asymbol *global_symbol;
1247 static int global_sym_defined;
1248
1249 static bfd_reloc_status_type
1250 DEFUN (hppa_elf_reloc, (abfd, reloc_entry, symbol_in, data, input_section, output_bfd),
1251 bfd * abfd AND
1252 arelent * reloc_entry AND
1253 asymbol * symbol_in AND
1254 PTR data AND
1255 asection * input_section AND
1256 bfd * output_bfd)
1257 {
1258 unsigned long insn;
1259 long sym_value = 0;
1260
1261 unsigned long addr = reloc_entry->address; /*+ input_section->vma*/
1262 bfd_byte *hit_data = addr + (bfd_byte *) (data);
1263 unsigned short r_type = reloc_entry->howto->type & 0xFF;
1264 unsigned short r_field = e_fsel;
1265 boolean r_pcrel = reloc_entry->howto->pc_relative;
1266
1267 /* howto->bitsize contains the format (11, 14, 21, etc) information */
1268 unsigned r_format = reloc_entry->howto->bitsize;
1269 long r_addend = reloc_entry->addend;
1270
1271
1272 if (output_bfd)
1273 {
1274 /* Partial linking - do nothing */
1275 reloc_entry->address += input_section->output_offset;
1276 return bfd_reloc_ok;
1277 }
1278
1279 if (symbol_in && symbol_in->section == &bfd_und_section)
1280 return bfd_reloc_undefined;
1281
1282 /* Check for stubs that might be required. */
1283 /* symbol_in = hppa_elf_stub_check (abfd, input_section->output_section->owner, reloc_entry); */
1284
1285 sym_value = get_symbol_value (symbol_in);
1286
1287 /* compute value of $global$ if it is there. */
1288
1289 if (!global_sym_defined)
1290 {
1291 if (global_symbol)
1292 {
1293 global_value = (global_symbol->value
1294 + global_symbol->section->output_section->vma
1295 + global_symbol->section->output_offset);
1296 GOT_value = global_value; /* XXX: For HP-UX, GOT==DP */
1297 global_sym_defined++;
1298 }
1299 }
1300
1301 /* get the instruction word */
1302 insn = bfd_get_32 (abfd, hit_data);
1303
1304 /* relocate the value based on the relocation type */
1305
1306 /* basic_type_1: relocation is relative to $global$ */
1307 /* basic_type_2: relocation is relative to the current GOT */
1308 /* basic_type_3: relocation is an absolute call */
1309 /* basic_type_4: relocation is an PC-relative call */
1310 /* basic_type_5: relocation is plabel reference */
1311 /* basic_type_6: relocation is an unwind table relocation */
1312 /* extended_type: unimplemented */
1313
1314 switch (r_type)
1315 {
1316 case R_HPPA_NONE:
1317 break;
1318 case R_HPPA_32: /* Symbol + Addend 32 */
1319 r_field = e_fsel;
1320 goto do_basic_type_1;
1321 case R_HPPA_11: /* Symbol + Addend 11 */
1322 r_field = e_fsel;
1323 goto do_basic_type_1;
1324 case R_HPPA_14: /* Symbol + Addend 14 */
1325 r_field = e_fsel;
1326 goto do_basic_type_1;
1327 case R_HPPA_17: /* Symbol + Addend 17 */
1328 r_field = e_fsel;
1329 goto do_basic_type_1;
1330 case R_HPPA_L21: /* L (Symbol, Addend) 21 */
1331 r_field = e_lsel;
1332 goto do_basic_type_1;
1333 case R_HPPA_R11: /* R (Symbol, Addend) 11 */
1334 r_field = e_rsel;
1335 goto do_basic_type_1;
1336 case R_HPPA_R14: /* R (Symbol, Addend) 14 */
1337 r_field = e_rsel;
1338 goto do_basic_type_1;
1339 case R_HPPA_R17: /* R (Symbol, Addend) 17 */
1340 r_field = e_rsel;
1341 goto do_basic_type_1;
1342 case R_HPPA_LS21: /* LS(Symbol, Addend) 21 */
1343 r_field = e_lssel;
1344 goto do_basic_type_1;
1345 case R_HPPA_RS11: /* RS(Symbol, Addend) 11 */
1346 r_field = e_rssel;
1347 goto do_basic_type_1;
1348 case R_HPPA_RS14: /* RS(Symbol, Addend) 14 */
1349 r_field = e_rssel;
1350 goto do_basic_type_1;
1351 case R_HPPA_RS17: /* RS(Symbol, Addend) 17 */
1352 r_field = e_ldsel;
1353 goto do_basic_type_1;
1354 case R_HPPA_LD21: /* LD(Symbol, Addend) 21 */
1355 r_field = e_ldsel;
1356 goto do_basic_type_1;
1357 case R_HPPA_RD11: /* RD(Symbol, Addend) 11 */
1358 r_field = e_rdsel;
1359 goto do_basic_type_1;
1360 case R_HPPA_RD14: /* RD(Symbol, Addend) 14 */
1361 r_field = e_rdsel;
1362 goto do_basic_type_1;
1363 case R_HPPA_RD17: /* RD(Symbol, Addend) 17 */
1364 r_field = e_rdsel;
1365 goto do_basic_type_1;
1366 case R_HPPA_LR21: /* LR(Symbol, Addend) 21 */
1367 r_field = e_lrsel;
1368 goto do_basic_type_1;
1369 case R_HPPA_RR14: /* RR(Symbol, Addend) 14 */
1370 r_field = e_rrsel;
1371 goto do_basic_type_1;
1372 case R_HPPA_RR17: /* RR(Symbol, Addend) 17 */
1373 r_field = e_rrsel;
1374
1375 do_basic_type_1:
1376 insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
1377 symbol_in, sym_value, r_addend,
1378 r_type, r_format, r_field, r_pcrel);
1379 break;
1380
1381 case R_HPPA_GOTOFF_11: /* Symbol - GOT + Addend 11 */
1382 r_field = e_fsel;
1383 goto do_basic_type_2;
1384 case R_HPPA_GOTOFF_14: /* Symbol - GOT + Addend 14 */
1385 r_field = e_fsel;
1386 goto do_basic_type_2;
1387 case R_HPPA_GOTOFF_L21: /* L (Sym - GOT, Addend) 21 */
1388 r_field = e_lsel;
1389 goto do_basic_type_2;
1390 case R_HPPA_GOTOFF_R11: /* R (Sym - GOT, Addend) 11 */
1391 r_field = e_rsel;
1392 goto do_basic_type_2;
1393 case R_HPPA_GOTOFF_R14: /* R (Sym - GOT, Addend) 14 */
1394 r_field = e_rsel;
1395 goto do_basic_type_2;
1396 case R_HPPA_GOTOFF_LS21: /* LS(Sym - GOT, Addend) 21 */
1397 r_field = e_lssel;
1398 goto do_basic_type_2;
1399 case R_HPPA_GOTOFF_RS11: /* RS(Sym - GOT, Addend) 11 */
1400 r_field = e_rssel;
1401 goto do_basic_type_2;
1402 case R_HPPA_GOTOFF_RS14: /* RS(Sym - GOT, Addend) 14 */
1403 r_field = e_rssel;
1404 goto do_basic_type_2;
1405 case R_HPPA_GOTOFF_LD21: /* LD(Sym - GOT, Addend) 21 */
1406 r_field = e_ldsel;
1407 goto do_basic_type_2;
1408 case R_HPPA_GOTOFF_RD11: /* RD(Sym - GOT, Addend) 11 */
1409 r_field = e_rdsel;
1410 goto do_basic_type_2;
1411 case R_HPPA_GOTOFF_RD14: /* RD(Sym - GOT, Addend) 14 */
1412 r_field = e_rdsel;
1413 goto do_basic_type_2;
1414 case R_HPPA_GOTOFF_LR21: /* LR(Sym - GOT, Addend) 21 */
1415 r_field = e_lrsel;
1416 goto do_basic_type_2;
1417 case R_HPPA_GOTOFF_RR14: /* RR(Sym - GOT, Addend) 14 */
1418 r_field = e_rrsel;
1419 do_basic_type_2:
1420 sym_value -= GOT_value;
1421 insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
1422 symbol_in, sym_value, r_addend,
1423 r_type, r_format, r_field, r_pcrel);
1424 break;
1425
1426 case R_HPPA_ABS_CALL_11: /* Symbol + Addend 11 */
1427 r_field = e_fsel;
1428 goto do_basic_type_3;
1429 case R_HPPA_ABS_CALL_14: /* Symbol + Addend 14 */
1430 r_field = e_fsel;
1431 goto do_basic_type_3;
1432 case R_HPPA_ABS_CALL_17: /* Symbol + Addend 17 */
1433 r_field = e_fsel;
1434 goto do_basic_type_3;
1435 case R_HPPA_ABS_CALL_L21: /* L (Symbol, Addend) 21 */
1436 r_field = e_lsel;
1437 goto do_basic_type_3;
1438 case R_HPPA_ABS_CALL_R11: /* R (Symbol, Addend) 11 */
1439 r_field = e_rsel;
1440 goto do_basic_type_3;
1441 case R_HPPA_ABS_CALL_R14: /* R (Symbol, Addend) 14 */
1442 r_field = e_rsel;
1443 goto do_basic_type_3;
1444 case R_HPPA_ABS_CALL_R17: /* R (Symbol, Addend) 17 */
1445 r_field = e_rsel;
1446 goto do_basic_type_3;
1447 case R_HPPA_ABS_CALL_LS21: /* LS(Symbol, Addend) 21 */
1448 r_field = e_lssel;
1449 goto do_basic_type_3;
1450 case R_HPPA_ABS_CALL_RS11: /* RS(Symbol, Addend) 11 */
1451 r_field = e_lssel;
1452 goto do_basic_type_3;
1453 case R_HPPA_ABS_CALL_RS14: /* RS(Symbol, Addend) 14 */
1454 r_field = e_rssel;
1455 goto do_basic_type_3;
1456 case R_HPPA_ABS_CALL_RS17: /* RS(Symbol, Addend) 17 */
1457 r_field = e_rssel;
1458 goto do_basic_type_3;
1459 case R_HPPA_ABS_CALL_LD21: /* LD(Symbol, Addend) 21 */
1460 r_field = e_ldsel;
1461 goto do_basic_type_3;
1462 case R_HPPA_ABS_CALL_RD11: /* RD(Symbol, Addend) 11 */
1463 r_field = e_rdsel;
1464 goto do_basic_type_3;
1465 case R_HPPA_ABS_CALL_RD14: /* RD(Symbol, Addend) 14 */
1466 r_field = e_rdsel;
1467 goto do_basic_type_3;
1468 case R_HPPA_ABS_CALL_RD17: /* RD(Symbol, Addend) 17 */
1469 r_field = e_rdsel;
1470 goto do_basic_type_3;
1471 case R_HPPA_ABS_CALL_LR21: /* LR(Symbol, Addend) 21 */
1472 r_field = e_lrsel;
1473 goto do_basic_type_3;
1474 case R_HPPA_ABS_CALL_RR14: /* RR(Symbol, Addend) 14 */
1475 r_field = e_rrsel;
1476 goto do_basic_type_3;
1477 case R_HPPA_ABS_CALL_RR17: /* RR(Symbol, Addend) 17 */
1478 r_field = e_rrsel;
1479 do_basic_type_3:
1480 insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
1481 symbol_in, sym_value, r_addend,
1482 r_type, r_format, r_field, r_pcrel);
1483 break;
1484
1485 case R_HPPA_PCREL_CALL_11: /* Symbol - PC + Addend 11 */
1486 r_field = e_fsel;
1487 goto do_basic_type_4;
1488 case R_HPPA_PCREL_CALL_14: /* Symbol - PC + Addend 14 */
1489 r_field = e_fsel;
1490 goto do_basic_type_4;
1491 case R_HPPA_PCREL_CALL_17: /* Symbol - PC + Addend 17 */
1492 r_field = e_fsel;
1493 goto do_basic_type_4;
1494 case R_HPPA_PCREL_CALL_L21:/* L (Symbol - PC, Addend) 21 */
1495 r_field = e_lsel;
1496 goto do_basic_type_4;
1497 case R_HPPA_PCREL_CALL_R11:/* R (Symbol - PC, Addend) 11 */
1498 r_field = e_rsel;
1499 goto do_basic_type_4;
1500 case R_HPPA_PCREL_CALL_R14:/* R (Symbol - PC, Addend) 14 */
1501 r_field = e_rsel;
1502 goto do_basic_type_4;
1503 case R_HPPA_PCREL_CALL_R17:/* R (Symbol - PC, Addend) 17 */
1504 r_field = e_rsel;
1505 goto do_basic_type_4;
1506 case R_HPPA_PCREL_CALL_LS21: /* LS(Symbol - PC, Addend) 21 */
1507 r_field = e_lssel;
1508 goto do_basic_type_4;
1509 case R_HPPA_PCREL_CALL_RS11: /* RS(Symbol - PC, Addend) 11 */
1510 r_field = e_rssel;
1511 goto do_basic_type_4;
1512 case R_HPPA_PCREL_CALL_RS14: /* RS(Symbol - PC, Addend) 14 */
1513 r_field = e_rssel;
1514 goto do_basic_type_4;
1515 case R_HPPA_PCREL_CALL_RS17: /* RS(Symbol - PC, Addend) 17 */
1516 r_field = e_rssel;
1517 goto do_basic_type_4;
1518 case R_HPPA_PCREL_CALL_LD21: /* LD(Symbol - PC, Addend) 21 */
1519 r_field = e_ldsel;
1520 goto do_basic_type_4;
1521 case R_HPPA_PCREL_CALL_RD11: /* RD(Symbol - PC, Addend) 11 */
1522 r_field = e_rdsel;
1523 goto do_basic_type_4;
1524 case R_HPPA_PCREL_CALL_RD14: /* RD(Symbol - PC, Addend) 14 */
1525 r_field = e_rdsel;
1526 goto do_basic_type_4;
1527 case R_HPPA_PCREL_CALL_RD17: /* RD(Symbol - PC, Addend) 17 */
1528 r_field = e_rdsel;
1529 goto do_basic_type_4;
1530 case R_HPPA_PCREL_CALL_LR21: /* LR(Symbol - PC, Addend) 21 */
1531 r_field = e_lrsel;
1532 goto do_basic_type_4;
1533 case R_HPPA_PCREL_CALL_RR14: /* RR(Symbol - PC, Addend) 14 */
1534 r_field = e_rrsel;
1535 goto do_basic_type_4;
1536 case R_HPPA_PCREL_CALL_RR17: /* RR(Symbol - PC, Addend) 17 *//* #69 */
1537 r_field = e_rrsel;
1538 do_basic_type_4:
1539 insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
1540 symbol_in, sym_value, r_addend,
1541 r_type, r_format, r_field, r_pcrel);
1542 break;
1543
1544 case R_HPPA_PLABEL_32:
1545 case R_HPPA_PLABEL_11:
1546 case R_HPPA_PLABEL_14:
1547 r_field = e_fsel;
1548 goto do_basic_type_5;
1549 case R_HPPA_PLABEL_L21:
1550 r_field = e_lsel;
1551 goto do_basic_type_5;
1552 case R_HPPA_PLABEL_R11:
1553 case R_HPPA_PLABEL_R14:
1554 r_field = e_rsel;
1555 do_basic_type_5:
1556 insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
1557 symbol_in, sym_value, r_addend,
1558 r_type, r_format, r_field, r_pcrel);
1559 break;
1560
1561 case R_HPPA_UNWIND_ENTRY:
1562 case R_HPPA_UNWIND_ENTRIES:
1563 hppa_elf_relocate_unwind_table (abfd, input_section, data, addr,
1564 symbol_in, sym_value, r_addend,
1565 r_type, r_format, r_field, r_pcrel);
1566 return (bfd_reloc_ok);
1567
1568 case R_HPPA_PUSH_CONST: /* push Addend - - */
1569 case R_HPPA_PUSH_PC: /* push PC + Addend - - */
1570 case R_HPPA_PUSH_SYM: /* push Symbol + Addend - - */
1571 case R_HPPA_PUSH_GOTOFF: /* push Symbol - GOT + Addend - - */
1572 case R_HPPA_PUSH_ABS_CALL: /* push Symbol + Addend - - */
1573 case R_HPPA_PUSH_PCREL_CALL: /* push Symbol - PC + Addend - - */
1574 case R_HPPA_PUSH_PLABEL: /* [TBD] - - */
1575 case R_HPPA_MAX: /* pop A and B, push max(B,A) - - */
1576 case R_HPPA_MIN: /* pop A and B, push min(B,A) - - */
1577 case R_HPPA_ADD: /* pop A and B, push B + A - - */
1578 case R_HPPA_SUB: /* pop A and B, push B - A - - */
1579 case R_HPPA_MULT: /* pop A and B, push B * A - - */
1580 case R_HPPA_DIV: /* pop A and B, push B / A - - */
1581 case R_HPPA_MOD: /* pop A and B, push B % A - - */
1582 case R_HPPA_AND: /* pop A and B, push B & A - - */
1583 case R_HPPA_OR: /* pop A and B, push B | A - - */
1584 case R_HPPA_XOR: /* pop A and B, push B ^ A - - */
1585 case R_HPPA_NOT: /* pop A, push ~A - - */
1586 case R_HPPA_LSHIFT: /* pop A, push A << Addend - - */
1587 case R_HPPA_ARITH_RSHIFT: /* pop A, push A >> Addend - - */
1588 case R_HPPA_LOGIC_RSHIFT: /* pop A, push A >> Addend - - */
1589 case R_HPPA_EXPR_F: /* pop A, push A + Addend L - */
1590 case R_HPPA_EXPR_L: /* pop A, push L(A,Addend) L - */
1591 case R_HPPA_EXPR_R: /* pop A, push R(A,Addend) R - */
1592 case R_HPPA_EXPR_LS: /* pop A, push LS(A,Addend) LS - */
1593 case R_HPPA_EXPR_RS: /* pop A, push RS(A,Addend) RS - */
1594 case R_HPPA_EXPR_LD: /* pop A, push LD(A,Addend) LD - */
1595 case R_HPPA_EXPR_RD: /* pop A, push RD(A,Addend) RD - */
1596 case R_HPPA_EXPR_LR: /* pop A, push LR(A,Addend) LR - */
1597 case R_HPPA_EXPR_RR: /* pop A, push RR(A,Addend) RR - */
1598
1599 case R_HPPA_EXPR_32: /* pop - 32 */
1600 case R_HPPA_EXPR_21: /* pop - 21 */
1601 case R_HPPA_EXPR_11: /* pop - 11 */
1602 case R_HPPA_EXPR_14: /* pop - 14 */
1603 case R_HPPA_EXPR_17: /* pop - 17 */
1604 case R_HPPA_EXPR_12: /* pop - 12 */
1605 fprintf (stderr, "Relocation problem: ");
1606 fprintf (stderr, "Unimplemented reloc type %d, in module %s\n",
1607 r_type, abfd->filename);
1608 return (bfd_reloc_notsupported);
1609 case R_HPPA_STUB_CALL_17:
1610 /* yes, a branch to a long branch stub. Change instruction to a BLE */
1611 /* or BLE,N */
1612 if ( *(unsigned *)hit_data & 2 )
1613 insn = BLE_N_XXX_0_0;
1614 else
1615 insn = BLE_XXX_0_0;
1616 bfd_put_32 (abfd, insn, hit_data);
1617 r_type = R_HPPA_ABS_CALL_17;
1618 r_pcrel = 0;
1619 insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
1620 symbol_in, sym_value, r_addend,
1621 r_type, r_format, r_field, r_pcrel);
1622 break;
1623
1624 default:
1625 fprintf (stderr, "Relocation problem : ");
1626 fprintf (stderr, "Unrecognized reloc type %d, in module %s\n",
1627 r_type, abfd->filename);
1628 return (bfd_reloc_dangerous);
1629 }
1630
1631 /* update the instruction word */
1632 bfd_put_32 (abfd, insn, hit_data);
1633
1634 return (bfd_reloc_ok);
1635
1636 }
1637
1638 static reloc_howto_type *
1639 elf_hppa_reloc_type_lookup (arch, code)
1640 bfd_arch_info_type *arch;
1641 bfd_reloc_code_real_type code;
1642 {
1643 if ((int) code < (int) R_HPPA_UNIMPLEMENTED)
1644 {
1645 BFD_ASSERT ((int) elf_hppa_howto_table[(int) code].type == (int) code);
1646 return &elf_hppa_howto_table[(int) code];
1647 }
1648
1649 return (reloc_howto_type *) 0;
1650 }
1651
1652 #define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
1653
1654
1655 void
1656 DEFUN (elf_hppa_tc_symbol, (abfd, symbolP, sym_idx),
1657 bfd * abfd AND
1658 elf32_symbol_type * symbolP AND
1659 int sym_idx)
1660 {
1661 symext_chainS *symextP;
1662 unsigned int arg_reloc;
1663
1664 if (!(symbolP->symbol.flags & BSF_FUNCTION))
1665 return;
1666
1667 if (!((symbolP->symbol.flags & BSF_EXPORT) ||
1668 (symbolP->symbol.flags & BSF_GLOBAL)))
1669 return;
1670
1671 arg_reloc = symbolP->tc_data.hppa_arg_reloc;
1672
1673 symextP = (symext_chainS *) bfd_alloc (abfd, sizeof (symext_chainS) * 2);
1674
1675 symextP[0].entry = ELF32_HPPA_SX_WORD (HPPA_SXT_SYMNDX, sym_idx);
1676 symextP[0].next = &symextP[1];
1677
1678 symextP[1].entry = ELF32_HPPA_SX_WORD (HPPA_SXT_ARG_RELOC, arg_reloc);
1679 symextP[1].next = NULL;
1680
1681 if (symext_rootP == NULL)
1682 {
1683 symext_rootP = &symextP[0];
1684 symext_lastP = &symextP[1];
1685 }
1686 else
1687 {
1688 symext_lastP->next = &symextP[0];
1689 symext_lastP = &symextP[1];
1690 }
1691 }
1692
1693 /* Accessor function for the list of symbol extension records. */
1694 symext_chainS *elf32_hppa_get_symextn_chain()
1695 {
1696 return symext_rootP;
1697 }
1698
1699 static symext_entryS *symextn_contents;
1700 static unsigned int symextn_contents_real_size;
1701
1702 void
1703 DEFUN (elf_hppa_tc_make_sections, (abfd, ignored),
1704 bfd * abfd AND
1705 PTR ignored)
1706 {
1707 symext_chainS *symextP;
1708 int size;
1709 int n;
1710 int i;
1711 void hppa_elf_stub_finish (); /* forward declaration */
1712 asection *symextn_sec;
1713
1714 hppa_elf_stub_finish (abfd);
1715
1716 if (symext_rootP == NULL)
1717 return;
1718
1719 for (n = 0, symextP = symext_rootP; symextP; symextP = symextP->next, ++n)
1720 ;
1721
1722 size = sizeof (symext_entryS) * n;
1723 symextn_sec = bfd_get_section_by_name (abfd, SYMEXTN_SECTION_NAME);
1724 if (symextn_sec == (asection *) 0)
1725 {
1726 symextn_sec = bfd_make_section (abfd, SYMEXTN_SECTION_NAME);
1727 bfd_set_section_flags (abfd,
1728 symextn_sec,
1729 SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE | SEC_READONLY);
1730 symextn_sec->output_section = symextn_sec;
1731 symextn_sec->output_offset = 0;
1732 bfd_set_section_alignment (abfd, symextn_sec, 2);
1733 }
1734 symextn_contents = (symext_entryS *) bfd_alloc (abfd, size);
1735
1736 for (i = 0, symextP = symext_rootP; symextP; symextP = symextP->next, ++i)
1737 symextn_contents[i] = symextP->entry;
1738 symextn_contents_real_size = size;
1739 bfd_set_section_size (abfd, symextn_sec, symextn_contents_real_size);
1740
1741 return;
1742 }
1743
1744 /* Support for HP PA-RISC stub generation.
1745
1746 Written by
1747
1748 Center for Software Science
1749 Department of Computer Science
1750 University of Utah
1751
1752 */
1753
1754 /*
1755 HP-PA calling conventions state:
1756
1757 1. an argument relocation stub is required whenever the callee and
1758 caller argument relocation bits do not match exactly. The exception
1759 to this rule is if either the caller or callee argument relocation
1760 bit are 00 (do not relocate).
1761
1762 2. The linker can optionally add a symbol record for the stub so that
1763 the stub can be reused. The symbol record will be the same as the
1764 original export symbol record, except that the relocation bits will
1765 reflect the input of the stub, the type would be STUB and the symbol
1766 value will be the location of the relocation stub.
1767
1768 Other notes:
1769
1770 Stubs can be inserted *before* the section of the caller. The stubs
1771 can be treated as calls to code that manipulates the arguments.
1772
1773 */
1774
1775 typedef enum
1776 {
1777 HPPA_STUB_ILLEGAL,
1778 HPPA_STUB_ARG_RELOC,
1779 HPPA_STUB_LONG_BRANCH
1780 } hppa_stub_type;
1781
1782 symext_entryS
1783 elf32_hppa_get_sym_extn (abfd, sym, type)
1784 bfd *abfd;
1785 asymbol *sym;
1786 int type;
1787 {
1788 /* This function finds the symbol extension record of the */
1789 /* specified type for the specified symbol. It returns the */
1790 /* value of the symbol extension record. */
1791 symext_entryS retval;
1792
1793 switch (type)
1794 {
1795 case HPPA_SXT_NULL:
1796 retval = (symext_entryS) 0;
1797 break;
1798 case HPPA_SXT_SYMNDX:
1799 retval = (symext_entryS) 0; /* XXX: need to fix this */
1800 break;
1801 case HPPA_SXT_ARG_RELOC:
1802 {
1803 elf32_symbol_type *esymP = (elf32_symbol_type *) sym;
1804
1805 retval = (symext_entryS) esymP->tc_data.hppa_arg_reloc;
1806 break;
1807 }
1808 /* This should never happen. */
1809 default:
1810 abort();
1811 }
1812 return retval;
1813 }
1814
1815
1816 typedef struct Elf32_hppa_Stub_description_struct
1817 {
1818 bfd *this_bfd; /* bfd to which this stub */
1819 /* applies */
1820 asection *stub_sec; /* stub section for this bfd */
1821 unsigned relocs_allocated_cnt; /* count of relocations for this stub section */
1822 unsigned real_size;
1823 unsigned allocated_size;
1824 int *stub_secp; /* pointer to the next available location in the buffer */
1825 char *stub_contents; /* contents of the stubs for this bfd */
1826 }
1827
1828 Elf32_hppa_Stub_description;
1829
1830 typedef struct Elf32_hppa_Stub_list_struct
1831 {
1832 Elf32_hppa_Stub_description *stub;
1833 struct Elf32_hppa_Stub_list_struct *next;
1834 } Elf32_hppa_Stub_list;
1835
1836 static Elf32_hppa_Stub_list *elf_hppa_stub_rootP;
1837
1838 /* Locate the stub section information for the given bfd. */
1839 static Elf32_hppa_Stub_description *
1840 find_stubs (abfd, stub_sec)
1841 bfd *abfd;
1842 asection *stub_sec;
1843 {
1844 Elf32_hppa_Stub_list *stubP;
1845
1846 for (stubP = elf_hppa_stub_rootP; stubP; stubP = stubP->next)
1847 {
1848 if (stubP->stub->this_bfd == abfd
1849 && stubP->stub->stub_sec == stub_sec)
1850 return stubP->stub;
1851 }
1852
1853 return (Elf32_hppa_Stub_description *) NULL;
1854 }
1855
1856 static Elf32_hppa_Stub_description *
1857 new_stub (abfd, stub_sec)
1858 bfd *abfd;
1859 asection *stub_sec;
1860 {
1861 Elf32_hppa_Stub_description *stub = find_stubs (abfd, stub_sec);
1862
1863 if (stub)
1864 return stub;
1865
1866 stub = (Elf32_hppa_Stub_description *) bfd_zalloc (abfd, sizeof (Elf32_hppa_Stub_description));
1867 stub->this_bfd = abfd;
1868 stub->stub_sec = stub_sec;
1869 stub->real_size = 0;
1870 stub->allocated_size = 0;
1871 stub->stub_contents = NULL;
1872 stub->stub_secp = NULL;
1873
1874 return stub;
1875 }
1876
1877 static void
1878 add_stub (stub)
1879 Elf32_hppa_Stub_description *stub;
1880 {
1881 Elf32_hppa_Stub_list *new_entry;
1882
1883 new_entry = (Elf32_hppa_Stub_list *) bfd_zalloc (stub->this_bfd, sizeof (Elf32_hppa_Stub_list));
1884
1885 if (new_entry)
1886 {
1887 new_entry->stub = stub;
1888
1889 if (elf_hppa_stub_rootP)
1890 {
1891 new_entry->next = elf_hppa_stub_rootP;
1892 elf_hppa_stub_rootP = new_entry;
1893 }
1894 else
1895 {
1896 new_entry->next = (Elf32_hppa_Stub_list *) NULL;
1897 elf_hppa_stub_rootP = new_entry;
1898 }
1899 }
1900 else
1901 {
1902 bfd_error = no_memory;
1903 bfd_perror ("add_stub");
1904 }
1905 }
1906
1907 #define ARGUMENTS 0
1908 #define RETURN_VALUE 1
1909
1910 #define NO_ARG_RELOC 0
1911 #define R_TO_FR 1
1912 #define R01_TO_FR 2
1913 #define R23_TO_FR 3
1914 #define FR_TO_R 4
1915 #define FR_TO_R01 5
1916 #define FR_TO_R23 6
1917 #define ARG_RELOC_ERR 7
1918
1919 #define ARG0 0
1920 #define ARG1 1
1921 #define ARG2 2
1922 #define ARG3 3
1923 #define RETVAL 4
1924
1925 #define AR_NO 0
1926 #define AR_GR 1
1927 #define AR_FR 2
1928 #define AR_FU 3
1929 /* FP register in arg0/arg1. This value can only appear in the arg0 location. */
1930 #define AR_DBL01 4
1931 /* FP register in arg2/arg3. This value can only appear in the arg2 location. */
1932 #define AR_DBL23 5
1933
1934 #define AR_WARN(type,loc) \
1935 fprintf(stderr,"WARNING: Illegal argument relocation: %s for %s\n", \
1936 reloc_type_strings[type],reloc_loc_strings[loc])
1937
1938 static CONST char *CONST reloc_type_strings[] =
1939 {
1940 "NONE", "GR->FR", "GR0,GR1->FR1", "GR2,GR3->FR3", "FR->GR", "FR->GR0,GR1", "FR->GR2,GR3", "ERROR"
1941 };
1942
1943 static CONST char *CONST reloc_loc_strings[] =
1944 {
1945 "ARG0", "ARG1", "ARG2", "ARG3", "RETVAL"
1946 };
1947
1948 static CONST char mismatches[6][6] =
1949 { /* CALLEE NONE CALLEE GR CALLEE FR CALLEE FU CALLEE DBL01 CALLEE DBL23 */
1950 /* CALLER NONE */
1951 {NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, NO_ARG_RELOC},
1952 /* CALLER GR */
1953 {NO_ARG_RELOC, NO_ARG_RELOC, R_TO_FR, ARG_RELOC_ERR, R01_TO_FR, ARG_RELOC_ERR},
1954 /* CALLER FR */
1955 {NO_ARG_RELOC, FR_TO_R, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR},
1956 /* CALLER FU */
1957 {ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR},
1958 /* CALLER DBL01 */
1959 {NO_ARG_RELOC, FR_TO_R01, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, ARG_RELOC_ERR},
1960 /* CALLER DBL23 */
1961 {NO_ARG_RELOC, FR_TO_R23, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR, NO_ARG_RELOC},
1962 };
1963
1964 static CONST char retval_mismatches[6][6] =
1965 { /* CALLEE NONE CALLEE GR CALLEE FR CALLEE FU CALLEE DBL01 CALLEE DBL23 */
1966 /* CALLER NONE */
1967 {NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, NO_ARG_RELOC},
1968 /* CALLER GR */
1969 {NO_ARG_RELOC, NO_ARG_RELOC, R_TO_FR, ARG_RELOC_ERR, R01_TO_FR, ARG_RELOC_ERR},
1970 /* CALLER FR */
1971 {NO_ARG_RELOC, FR_TO_R, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR},
1972 /* CALLER FU */
1973 {ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR},
1974 /* CALLER DBL01 */
1975 {NO_ARG_RELOC, FR_TO_R01, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, ARG_RELOC_ERR},
1976 /* CALLER DBL23 */
1977 {NO_ARG_RELOC, FR_TO_R23, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR, NO_ARG_RELOC},
1978 };
1979
1980 static int
1981 type_of_mismatch (caller_bits, callee_bits, type)
1982 int caller_bits;
1983 int callee_bits;
1984 int type;
1985 {
1986 switch (type)
1987 {
1988 case ARGUMENTS:
1989 return mismatches[caller_bits][callee_bits];
1990 case RETURN_VALUE:
1991 return retval_mismatches[caller_bits][callee_bits];
1992 }
1993
1994 return 0;
1995 }
1996
1997 #define EXTRACT_ARBITS(ar,which) ((ar) >> (8-(which*2))) & 3
1998
1999 #define NEW_INSTRUCTION(desc,insn) \
2000 *((desc)->stub_secp)++ = (insn); \
2001 (desc)->real_size += sizeof(int); \
2002 bfd_set_section_size((desc)->this_bfd,(desc)->stub_sec,(desc)->real_size);
2003
2004 #define CURRENT_STUB_OFFSET(desc) \
2005 ((int)(desc)->stub_secp - (int)(desc)->stub_contents - 4)
2006
2007 static boolean stubs_finished = false;
2008
2009 void
2010 hppa_elf_stub_finish (output_bfd)
2011 bfd *output_bfd;
2012 {
2013 extern bfd_error_vector_type bfd_error_vector;
2014 Elf32_hppa_Stub_list *stub_list = elf_hppa_stub_rootP;
2015 /* All the stubs have been built. Finish up building */
2016 /* stub section. Apply relocations to the section. */
2017
2018 if ( stubs_finished )
2019 return;
2020
2021 for (; stub_list; stub_list = stub_list->next)
2022 {
2023 if (stub_list->stub->real_size)
2024 {
2025 bfd *stub_bfd = stub_list->stub->this_bfd;
2026 asection *stub_sec = bfd_get_section_by_name (stub_bfd, ".hppa_linker_stubs");
2027 bfd_size_type reloc_size;
2028 arelent **reloc_vector;
2029
2030 BFD_ASSERT (stub_sec == stub_list->stub->stub_sec);
2031 reloc_size = bfd_get_reloc_upper_bound (stub_bfd, stub_sec);
2032 reloc_vector = (arelent **) alloca (reloc_size);
2033
2034 BFD_ASSERT (stub_sec);
2035
2036 /* We are not relaxing the section, so just copy the size info */
2037 stub_sec->_cooked_size = stub_sec->_raw_size;
2038 stub_sec->reloc_done = true;
2039
2040
2041 if (bfd_canonicalize_reloc (stub_bfd,
2042 stub_sec,
2043 reloc_vector,
2044 output_bfd->outsymbols))
2045 {
2046 arelent **parent;
2047 for (parent = reloc_vector; *parent != (arelent *) NULL;
2048 parent++)
2049 {
2050 bfd_reloc_status_type r =
2051 bfd_perform_relocation (stub_bfd,
2052 *parent,
2053 stub_list->stub->stub_contents,
2054 stub_sec, 0);
2055
2056
2057 if (r != bfd_reloc_ok)
2058 {
2059 switch (r)
2060 {
2061 case bfd_reloc_undefined:
2062 bfd_error_vector.undefined_symbol (*parent, NULL);
2063 break;
2064 case bfd_reloc_dangerous:
2065 bfd_error_vector.reloc_dangerous (*parent, NULL);
2066 break;
2067 case bfd_reloc_outofrange:
2068 case bfd_reloc_overflow:
2069 bfd_error_vector.reloc_value_truncated (*parent, NULL);
2070 break;
2071 default:
2072 abort ();
2073 break;
2074 }
2075 }
2076 }
2077 }
2078
2079 bfd_set_section_contents (output_bfd,
2080 stub_sec,
2081 stub_list->stub->stub_contents,
2082 0,
2083 stub_list->stub->real_size);
2084
2085 free (reloc_vector);
2086 }
2087 }
2088 stubs_finished = true;
2089 }
2090
2091 void
2092 hppa_elf_stub_branch_reloc (stub_desc, /* the bfd */
2093 output_bfd, /* the output bfd */
2094 target_sym, /* the target symbol */
2095 offset) /* the offset within the stub buffer (pre-calculated) */
2096 Elf32_hppa_Stub_description *stub_desc;
2097 bfd *output_bfd;
2098 asymbol *target_sym;
2099 int offset;
2100 {
2101 /* Allocate a new relocation entry. */
2102 arelent relent;
2103 int size;
2104
2105 if (stub_desc->relocs_allocated_cnt == stub_desc->stub_sec->reloc_count)
2106 {
2107 if (stub_desc->stub_sec->relocation == NULL)
2108 {
2109 stub_desc->relocs_allocated_cnt = STUB_RELOC_INCR;
2110 size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
2111 stub_desc->stub_sec->relocation = (arelent *) zalloc (size);
2112 }
2113 else
2114 {
2115 stub_desc->relocs_allocated_cnt += STUB_RELOC_INCR;
2116 size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
2117 stub_desc->stub_sec->relocation = (arelent *) realloc (stub_desc->stub_sec->relocation,
2118 size);
2119 }
2120 }
2121
2122 /* Fill in the details. */
2123 relent.address = offset;
2124 relent.addend = 0;
2125 relent.sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
2126 BFD_ASSERT (relent.sym_ptr_ptr);
2127
2128 relent.sym_ptr_ptr[0] = target_sym;
2129 relent.howto = bfd_reloc_type_lookup (stub_desc->this_bfd, R_HPPA_PCREL_CALL_17);
2130
2131 /* Save it in the array of relocations for the stub section. */
2132
2133 memcpy (&stub_desc->stub_sec->relocation[stub_desc->stub_sec->reloc_count++],
2134 &relent,
2135 sizeof (arelent));
2136 }
2137
2138 void
2139 hppa_elf_stub_reloc (stub_desc, /* the bfd */
2140 output_bfd, /* the output bfd */
2141 target_sym, /* the target symbol */
2142 offset, /* the offset within the stub buffer (pre-calculated) */
2143 type)
2144 Elf32_hppa_Stub_description *stub_desc;
2145 bfd *output_bfd;
2146 asymbol *target_sym;
2147 int offset;
2148 elf32_hppa_reloc_type type;
2149 {
2150 /* Allocate a new relocation entry. */
2151 arelent relent;
2152 int size;
2153 Elf_Internal_Shdr *rela_hdr;
2154
2155 if (stub_desc->relocs_allocated_cnt == stub_desc->stub_sec->reloc_count)
2156 {
2157 if (stub_desc->stub_sec->relocation == NULL)
2158 {
2159 stub_desc->relocs_allocated_cnt = STUB_RELOC_INCR;
2160 size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
2161 stub_desc->stub_sec->relocation = (arelent *) zalloc (size);
2162 }
2163 else
2164 {
2165 stub_desc->relocs_allocated_cnt += STUB_RELOC_INCR;
2166 size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
2167 stub_desc->stub_sec->relocation = (arelent *) realloc (stub_desc->stub_sec->relocation,
2168 size);
2169 }
2170 }
2171
2172 rela_hdr = &elf_section_data(stub_desc->stub_sec)->rel_hdr;
2173 rela_hdr->sh_size += sizeof(Elf32_External_Rela);
2174
2175 /* Fill in the details. */
2176 relent.address = offset;
2177 relent.addend = 0;
2178 relent.sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
2179 BFD_ASSERT (relent.sym_ptr_ptr);
2180
2181 relent.sym_ptr_ptr[0] = target_sym;
2182 relent.howto = bfd_reloc_type_lookup (stub_desc->this_bfd, type);
2183
2184 /* Save it in the array of relocations for the stub section. */
2185
2186 memcpy (&stub_desc->stub_sec->relocation[stub_desc->stub_sec->reloc_count++],
2187 &relent,
2188 sizeof (arelent));
2189 }
2190
2191 asymbol *
2192 hppa_elf_build_arg_reloc_stub (abfd, output_bfd, reloc_entry, stub_types)
2193 bfd *abfd;
2194 bfd *output_bfd;
2195 arelent *reloc_entry;
2196 int stub_types[5];
2197 {
2198 asection *stub_sec = bfd_get_section_by_name (abfd, ".hppa_linker_stubs");
2199 Elf32_hppa_Stub_description *stub_desc = find_stubs (abfd, stub_sec);
2200 asymbol *stub_sym = NULL;
2201 asymbol *target_sym = reloc_entry->sym_ptr_ptr[0];
2202 asection *output_text_section = bfd_get_section_by_name (output_bfd, ".text");
2203 int i;
2204 char stub_sym_name[128];
2205
2206 if (!stub_sec)
2207 {
2208 BFD_ASSERT (stub_desc == NULL);
2209 stub_sec = bfd_make_section (abfd, ".hppa_linker_stubs");
2210 bfd_set_section_flags (abfd,
2211 stub_sec,
2212 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_READONLY);
2213 stub_sec->output_section = output_text_section->output_section;
2214 stub_sec->output_offset = 0;
2215 bfd_set_section_alignment (abfd, stub_sec, 2);
2216 stub_desc = new_stub (abfd, stub_sec);
2217 add_stub (stub_desc);
2218 }
2219
2220 /* make sure we have a stub descriptor structure */
2221
2222 if (!stub_desc)
2223 {
2224 stub_desc = new_stub (abfd, stub_sec);
2225 add_stub (stub_desc);
2226 }
2227
2228 /* allocate some space to write the stub */
2229
2230 if (!stub_desc->stub_contents)
2231 {
2232 stub_desc->allocated_size = STUB_BUFFER_INCR;
2233 stub_desc->stub_contents = (char *) xmalloc (STUB_BUFFER_INCR);
2234 }
2235 else if ((stub_desc->allocated_size - stub_desc->real_size) < STUB_MAX_SIZE)
2236 {
2237 stub_desc->allocated_size = stub_desc->allocated_size + STUB_BUFFER_INCR;
2238 stub_desc->stub_contents = (char *) xrealloc (stub_desc->stub_contents,
2239 stub_desc->allocated_size);
2240 }
2241
2242 stub_desc->stub_secp = (int *) (stub_desc->stub_contents + stub_desc->real_size);
2243
2244 /* create a symbol to point to this stub */
2245 stub_sym = bfd_make_empty_symbol (abfd);
2246 sprintf (stub_sym_name,
2247 "_stub_%s_%02d_%02d_%02d_%02d_%02d\000",
2248 reloc_entry->sym_ptr_ptr[0]->name,
2249 stub_types[0], stub_types[1], stub_types[2], stub_types[3], stub_types[4]);
2250 stub_sym->name = bfd_zalloc (abfd, strlen (stub_sym_name) + 1);
2251 strcpy ((char *) stub_sym->name, stub_sym_name);
2252 stub_sym->value = (int) stub_desc->stub_secp - (int) stub_desc->stub_contents;
2253 stub_sym->section = stub_sec;
2254 stub_sym->flags = BSF_LOCAL | BSF_FUNCTION;
2255
2256 /* redirect the original relocation from the old symbol (a function) */
2257 /* to the stub (the stub calls the function). */
2258 /* XXX do we need to change the relocation type? */
2259 reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
2260 reloc_entry->sym_ptr_ptr[0] = stub_sym;
2261
2262 /* generate the beginning common section for all stubs */
2263
2264 NEW_INSTRUCTION (stub_desc, ADDI_8_SP);
2265
2266 /* generate the code to move the arguments around */
2267 for (i = ARG0; i < ARG3; i++)
2268 {
2269 if (stub_types[i] != NO_ARG_RELOC)
2270 {
2271 /* A stub is needed */
2272 switch (stub_types[i])
2273 {
2274 case R_TO_FR:
2275 switch (i)
2276 {
2277 case ARG0:
2278 NEW_INSTRUCTION (stub_desc, STWS_ARG0_M8SP);
2279 NEW_INSTRUCTION (stub_desc, FLDWS_M8SP_FARG0);
2280 break;
2281 case ARG1:
2282 NEW_INSTRUCTION (stub_desc, STWS_ARG1_M8SP);
2283 NEW_INSTRUCTION (stub_desc, FLDWS_M8SP_FARG1);
2284 break;
2285 case ARG2:
2286 NEW_INSTRUCTION (stub_desc, STWS_ARG2_M8SP);
2287 NEW_INSTRUCTION (stub_desc, FLDWS_M8SP_FARG2);
2288 break;
2289 case ARG3:
2290 NEW_INSTRUCTION (stub_desc, STWS_ARG3_M8SP);
2291 NEW_INSTRUCTION (stub_desc, FLDWS_M8SP_FARG3);
2292 break;
2293 }
2294 continue;
2295
2296 case R01_TO_FR:
2297 switch (i)
2298 {
2299 case ARG0:
2300 NEW_INSTRUCTION(stub_desc, STWS_ARG0_M4SP);
2301 NEW_INSTRUCTION(stub_desc, STWS_ARG1_M8SP);
2302 NEW_INSTRUCTION(stub_desc, FLDDS_M8SP_FARG1);
2303 break;
2304 default:
2305 AR_WARN(stub_types[i],i);
2306 break;
2307 }
2308 continue;
2309
2310 case R23_TO_FR:
2311 switch (i)
2312 {
2313 case ARG2:
2314 NEW_INSTRUCTION(stub_desc, STWS_ARG2_M4SP);
2315 NEW_INSTRUCTION(stub_desc, STWS_ARG3_M8SP);
2316 NEW_INSTRUCTION(stub_desc, FLDDS_M8SP_FARG3);
2317 break;
2318 default:
2319 AR_WARN(stub_types[i],i);
2320 break;
2321 }
2322 continue;
2323
2324 case FR_TO_R:
2325 switch (i)
2326 {
2327 case ARG0:
2328 NEW_INSTRUCTION (stub_desc, FSTWS_FARG0_M8SP);
2329 NEW_INSTRUCTION (stub_desc, LDWS_M4SP_ARG0);
2330 break;
2331 case ARG1:
2332 NEW_INSTRUCTION (stub_desc, FSTWS_FARG1_M8SP);
2333 NEW_INSTRUCTION (stub_desc, LDWS_M4SP_ARG1);
2334 break;
2335 case ARG2:
2336 NEW_INSTRUCTION (stub_desc, FSTWS_FARG2_M8SP);
2337 NEW_INSTRUCTION (stub_desc, LDWS_M4SP_ARG2);
2338 break;
2339 case ARG3:
2340 NEW_INSTRUCTION (stub_desc, FSTWS_FARG3_M8SP);
2341 NEW_INSTRUCTION (stub_desc, LDWS_M4SP_ARG3);
2342 break;
2343 }
2344 continue;
2345
2346 case FR_TO_R01:
2347 switch (i)
2348 {
2349 case ARG0:
2350 NEW_INSTRUCTION(stub_desc, FSTDS_FARG1_M8SP);
2351 NEW_INSTRUCTION(stub_desc, LDWS_M4SP_ARG0);
2352 NEW_INSTRUCTION(stub_desc, LDWS_M8SP_ARG1);
2353 break;
2354 default:
2355 AR_WARN(stub_types[i],i);
2356 break;
2357 }
2358 continue;
2359
2360 case FR_TO_R23:
2361 switch (i)
2362 {
2363 case ARG2:
2364 NEW_INSTRUCTION(stub_desc, FSTDS_FARG3_M8SP);
2365 NEW_INSTRUCTION(stub_desc, LDWS_M4SP_ARG2);
2366 NEW_INSTRUCTION(stub_desc, LDWS_M8SP_ARG3);
2367 break;
2368 default:
2369 AR_WARN(stub_types[i],i);
2370 break;
2371 }
2372 continue;
2373
2374 }
2375 }
2376 }
2377
2378 NEW_INSTRUCTION (stub_desc, ADDI_M8_SP);
2379
2380 /* generate the branch to the target routine */
2381 NEW_INSTRUCTION (stub_desc, STW_RP_M8SP); /* First, save the return address */
2382
2383 /* Branch to the target function. */
2384 /* (Make it a long call, so we do not */
2385 /* have to worry about generating a */
2386 /* long call stub.) */
2387 NEW_INSTRUCTION(stub_desc, LDIL_XXX_31);
2388 hppa_elf_stub_reloc (stub_desc,
2389 abfd, /* the output bfd */
2390 target_sym, /* the target symbol */
2391 CURRENT_STUB_OFFSET(stub_desc), /* offset in stub buffer */
2392 R_HPPA_L21);
2393 NEW_INSTRUCTION(stub_desc,BLE_XXX_0_31);
2394 hppa_elf_stub_reloc (stub_desc,
2395 abfd, /* the output bfd */
2396 target_sym, /* the target symbol */
2397 CURRENT_STUB_OFFSET(stub_desc), /* offset in stub buffer */
2398 R_HPPA_ABS_CALL_R17);
2399 NEW_INSTRUCTION(stub_desc,COPY_31_2);
2400
2401 /* generate the code to move the return value around */
2402 i = RETVAL;
2403 if (stub_types[i] != NO_ARG_RELOC)
2404 {
2405 /* A stub is needed */
2406 switch (stub_types[i])
2407 {
2408 case R_TO_FR:
2409 NEW_INSTRUCTION (stub_desc, STWS_RET0_M8SP);
2410 NEW_INSTRUCTION (stub_desc, FLDWS_M8SP_FRET0);
2411 break;
2412
2413 case FR_TO_R:
2414 NEW_INSTRUCTION (stub_desc, FSTWS_FRET0_M8SP);
2415 NEW_INSTRUCTION (stub_desc, LDWS_M4SP_RET0);
2416 break;
2417 }
2418 }
2419
2420 /* generate the ending common section for all stubs */
2421
2422 NEW_INSTRUCTION (stub_desc, LDW_M8SP_RP); /* restore return address */
2423
2424 /* XXX: can we assume this is a save return? */
2425 NEW_INSTRUCTION (stub_desc, BV_N_0RP);
2426
2427 return stub_sym;
2428 }
2429
2430 int
2431 hppa_elf_arg_reloc_needed_p (abfd, reloc_entry, stub_types)
2432 bfd *abfd;
2433 arelent *reloc_entry;
2434 int stub_types[5];
2435 {
2436 /* If the symbol is still undefined, there is */
2437 /* no way to know if a stub is required. */
2438
2439 if (reloc_entry->sym_ptr_ptr[0] && reloc_entry->sym_ptr_ptr[0]->section != &bfd_und_section)
2440 {
2441 symext_entryS caller_ar = (symext_entryS) ELF32_HPPA_R_ARG_RELOC (reloc_entry->addend);
2442 symext_entryS callee_ar = elf32_hppa_get_sym_extn (abfd,
2443 reloc_entry->sym_ptr_ptr[0],
2444 HPPA_SXT_ARG_RELOC);
2445
2446 /* Now, determine if a stub is */
2447 /* required. A stub is required if they the callee and caller */
2448 /* argument relocation bits are both nonzero and not equal. */
2449
2450 if (caller_ar && callee_ar)
2451 {
2452 /* Both are non-zero, we need to do further checking. */
2453 /* First, check if there is a return value relocation to be done */
2454 int caller_loc[5];
2455 int callee_loc[5];
2456
2457 callee_loc[RETVAL] = EXTRACT_ARBITS (callee_ar, RETVAL);
2458 caller_loc[RETVAL] = EXTRACT_ARBITS (caller_ar, RETVAL);
2459 callee_loc[ARG0] = EXTRACT_ARBITS (callee_ar, ARG0);
2460 caller_loc[ARG0] = EXTRACT_ARBITS (caller_ar, ARG0);
2461 callee_loc[ARG1] = EXTRACT_ARBITS (callee_ar, ARG1);
2462 caller_loc[ARG1] = EXTRACT_ARBITS (caller_ar, ARG1);
2463 callee_loc[ARG2] = EXTRACT_ARBITS (callee_ar, ARG2);
2464 caller_loc[ARG2] = EXTRACT_ARBITS (caller_ar, ARG2);
2465 callee_loc[ARG3] = EXTRACT_ARBITS (callee_ar, ARG3);
2466 caller_loc[ARG3] = EXTRACT_ARBITS (caller_ar, ARG3);
2467
2468 /* Check some special combinations. For */
2469 /* example, if FU appears in ARG1 or ARG3, we */
2470 /* can move it to ARG0 or ARG2, respectively. */
2471
2472 if (caller_loc[ARG0] == AR_FU || caller_loc[ARG1] == AR_FU)
2473 {
2474 caller_loc[ARG0] = AR_DBL01;
2475 caller_loc[ARG1] = AR_NO;
2476 }
2477 if (caller_loc[ARG2] == AR_FU || caller_loc[ARG3] == AR_FU)
2478 {
2479 caller_loc[ARG2] = AR_DBL23;
2480 caller_loc[ARG3] = AR_NO;
2481 }
2482 if (callee_loc[ARG0] == AR_FU || callee_loc[ARG1] == AR_FU)
2483 {
2484 callee_loc[ARG0] = AR_DBL01;
2485 callee_loc[ARG1] = AR_NO;
2486 }
2487 if (callee_loc[ARG2] == AR_FU || callee_loc[ARG3] == AR_FU)
2488 {
2489 callee_loc[ARG2] = AR_DBL23;
2490 callee_loc[ARG3] = AR_NO;
2491 }
2492
2493 stub_types[ARG0] = type_of_mismatch (caller_loc[ARG0], callee_loc[ARG0], ARGUMENTS);
2494 stub_types[ARG1] = type_of_mismatch (caller_loc[ARG1], callee_loc[ARG1], ARGUMENTS);
2495 stub_types[ARG2] = type_of_mismatch (caller_loc[ARG2], callee_loc[ARG2], ARGUMENTS);
2496 stub_types[ARG3] = type_of_mismatch (caller_loc[ARG3], callee_loc[ARG3], ARGUMENTS);
2497 stub_types[RETVAL] = type_of_mismatch (caller_loc[RETVAL], callee_loc[RETVAL], RETURN_VALUE);
2498
2499 /* Steps involved in building stubs: */
2500 /* 1. Determine what argument registers need to relocated. This */
2501 /* step is already done here. */
2502 /* 2. Build the appropriate stub in the .hppa_linker_stubs section. */
2503 /* This section should never appear in an object file. It is */
2504 /* only used internally. The output_section of the */
2505 /* .hppa_linker_stubs section is the .text section of the */
2506 /* executable. */
2507 /* 3. Build a symbol that is used (internally only) as the entry */
2508 /* point of the stub. */
2509 /* 4. Change the instruction of the original branch into a branch to */
2510 /* the stub routine. */
2511 /* 5. Build a relocation entry for the instruction of the original */
2512 /* branch to be R_HPPA_PCREL_CALL to the stub routine. */
2513
2514
2515 if (stub_types[0]
2516 || stub_types[1]
2517 || stub_types[2]
2518 || stub_types[3]
2519 || stub_types[4])
2520 {
2521 #ifdef DETECT_STUBS
2522 fprintf (stderr, "Stub needed for %s @ %s+0x%x: callee/caller ar=0x%x/0x%x ",
2523 reloc_entry->sym_ptr_ptr[0]->name,
2524 abfd->filename, reloc_entry->address,
2525 callee_ar, caller_ar);
2526 for (i = ARG0; i < RETVAL; i++)
2527 {
2528 if (stub_types[i] != NO_ARG_RELOC)
2529 {
2530 fprintf (stderr, "%s%d: %s ",
2531 i == RETVAL ? "ret" : "arg",
2532 i == RETVAL ? 0 : i,
2533 reloc_type_strings[stub_types[i]]);
2534 }
2535 }
2536 fprintf (stderr, "\n");
2537 #endif
2538 return 1;
2539 }
2540
2541 }
2542 }
2543 return 0;
2544 }
2545
2546 asymbol *
2547 hppa_elf_build_long_branch_stub (abfd, output_bfd, reloc_entry, symbol, data)
2548 bfd *abfd;
2549 bfd *output_bfd;
2550 arelent *reloc_entry;
2551 asymbol *symbol;
2552 unsigned *data;
2553 {
2554 asection *stub_sec = bfd_get_section_by_name (abfd, ".hppa_linker_stubs");
2555 Elf32_hppa_Stub_description *stub_desc = find_stubs (abfd, stub_sec);
2556 asymbol *stub_sym = NULL;
2557 asymbol *target_sym = reloc_entry->sym_ptr_ptr[0];
2558 asymbol *return_sym = NULL;
2559 asection *output_text_section = bfd_get_section_by_name (output_bfd, ".text");
2560 char stub_sym_name[128];
2561 int milli = false;
2562
2563 if (!stub_sec)
2564 {
2565 BFD_ASSERT (stub_desc == NULL);
2566 stub_sec = bfd_make_section (abfd, ".hppa_linker_stubs");
2567 bfd_set_section_flags (abfd,
2568 stub_sec,
2569 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_READONLY);
2570 stub_sec->output_section = output_text_section->output_section;
2571 stub_sec->output_offset = 0;
2572 /* set up the ELF section header for this new section. */
2573 /* This is basically the same processing as elf_make_sections() */
2574 /* (elf_make_sections() is static so it is not accessible from */
2575 /* here.) */
2576
2577 {
2578 Elf_Internal_Shdr *this_hdr;
2579 this_hdr = &elf_section_data (stub_sec)->this_hdr;
2580
2581 this_hdr->sh_addr = stub_sec->vma;
2582 this_hdr->sh_size = stub_sec->_raw_size;
2583 /* contents already set by elf_set_section_contents */
2584
2585 if (stub_sec->flags & SEC_RELOC)
2586 {
2587 /* emit a reloc section, and thus strtab and symtab... */
2588 Elf_Internal_Shdr *rela_hdr;
2589 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
2590
2591 rela_hdr = &elf_section_data (stub_sec)->rel_hdr;
2592
2593 /* orelocation has the data, reloc_count has the count... */
2594 if (use_rela_p)
2595 {
2596 rela_hdr->sh_type = SHT_RELA;
2597 rela_hdr->sh_entsize = sizeof (Elf32_External_Rela);
2598 }
2599 else
2600 /* REL relocations */
2601 {
2602 rela_hdr->sh_type = SHT_REL;
2603 rela_hdr->sh_entsize = sizeof (Elf32_External_Rel);
2604 }
2605 rela_hdr->sh_flags = 0;
2606 rela_hdr->sh_addr = 0;
2607 rela_hdr->sh_offset = 0;
2608 rela_hdr->sh_addralign = 0;
2609 rela_hdr->size = 0;
2610 }
2611 if (stub_sec->flags & SEC_ALLOC)
2612 {
2613 this_hdr->sh_flags |= SHF_ALLOC;
2614 if (stub_sec->flags & SEC_LOAD)
2615 {
2616 /* @@ Do something with sh_type? */
2617 }
2618 }
2619 if (!(stub_sec->flags & SEC_READONLY))
2620 this_hdr->sh_flags |= SHF_WRITE;
2621
2622 if (stub_sec->flags & SEC_CODE)
2623 this_hdr->sh_flags |= SHF_EXECINSTR;
2624 }
2625
2626 bfd_set_section_alignment (abfd, stub_sec, 2);
2627 stub_desc = new_stub (abfd, stub_sec);
2628 add_stub (stub_desc);
2629 }
2630
2631 if (!stub_desc)
2632 {
2633 stub_desc = new_stub (abfd, stub_sec);
2634 add_stub (stub_desc);
2635 }
2636
2637 /* allocate some space to write the stub */
2638
2639 if (!stub_desc->stub_contents)
2640 {
2641 stub_desc->allocated_size = STUB_BUFFER_INCR;
2642 stub_desc->stub_contents = (char *) malloc (STUB_BUFFER_INCR);
2643 }
2644 else if ((stub_desc->allocated_size - stub_desc->real_size) < STUB_MAX_SIZE)
2645 {
2646 stub_desc->allocated_size = stub_desc->allocated_size + STUB_BUFFER_INCR;
2647 stub_desc->stub_contents = (char *) realloc (stub_desc->stub_contents,
2648 stub_desc->allocated_size);
2649 }
2650
2651 stub_desc->stub_secp = (int *) (stub_desc->stub_contents + stub_desc->real_size);
2652
2653 /* create a symbol to point to this stub */
2654 stub_sym = bfd_make_empty_symbol (abfd);
2655 sprintf (stub_sym_name,
2656 "_lb_stub_%s\000", reloc_entry->sym_ptr_ptr[0]->name);
2657 stub_sym->name = bfd_zalloc (abfd, strlen (stub_sym_name) + 1);
2658 strcpy ((char *) stub_sym->name, stub_sym_name);
2659 stub_sym->value = (int) stub_desc->stub_secp - (int) stub_desc->stub_contents;
2660 stub_sym->section = stub_sec;
2661 stub_sym->flags = BSF_LOCAL | BSF_FUNCTION;
2662
2663 /* create a symbol to point to the return location */
2664 return_sym = bfd_make_empty_symbol (abfd);
2665 sprintf (stub_sym_name,
2666 "_lb_rtn_%s\000", reloc_entry->sym_ptr_ptr[0]->name);
2667 return_sym->name = bfd_zalloc (abfd, strlen (stub_sym_name) + 1);
2668 strcpy ((char *) return_sym->name, stub_sym_name);
2669 return_sym->value = reloc_entry->address + 8;
2670 return_sym->section = stub_sec;
2671 return_sym->flags = BSF_LOCAL | BSF_FUNCTION;
2672
2673 /* redirect the original relocation from the old symbol (a function) */
2674 /* to the stub (the stub calls the function). */
2675 /* XXX do we need to change the relocation type? */
2676 reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
2677 reloc_entry->sym_ptr_ptr[0] = stub_sym;
2678 reloc_entry->howto = bfd_reloc_type_lookup (abfd, R_HPPA_STUB_CALL_17);
2679
2680 /* Build the stub */
2681
2682 /* A millicode call? */
2683 /* If so, the return address comes in on r31 rather than r2 (rp) so a */
2684 /* slightly different code sequence is needed. */
2685 if ( ((*data & 0x03e00000) >> 21) == 31 )
2686 milli = true;
2687
2688 /* 1. initialization for the call. */
2689
2690 NEW_INSTRUCTION(stub_desc, LDSID_31_RP);
2691 NEW_INSTRUCTION(stub_desc, MTSP_RP_SR0);
2692 if ( !milli )
2693 {
2694 NEW_INSTRUCTION(stub_desc, COPY_31_2);
2695
2696 NEW_INSTRUCTION(stub_desc, LDIL_XXX_31);
2697 hppa_elf_stub_reloc (stub_desc,
2698 abfd, /* the output bfd */
2699 target_sym, /* the target symbol */
2700 CURRENT_STUB_OFFSET(stub_desc), /* offset in stub buffer */
2701 R_HPPA_L21);
2702
2703 /* 2. Make the call. */
2704
2705 NEW_INSTRUCTION(stub_desc,BE_N_XXX_0_31);
2706 hppa_elf_stub_reloc (stub_desc,
2707 abfd, /* the output bfd */
2708 target_sym, /* the target symbol */
2709 CURRENT_STUB_OFFSET(stub_desc), /* offset in stub buffer */
2710 R_HPPA_ABS_CALL_R17);
2711 /* 3. Branch back to the original location. */
2712 /* (accomplished with the COPY_31_2 instruction) */
2713 }
2714 else
2715 {
2716 NEW_INSTRUCTION(stub_desc, STW_31_M24SP);
2717 NEW_INSTRUCTION(stub_desc, LDIL_XXX_RP);
2718 hppa_elf_stub_reloc (stub_desc,
2719 abfd, /* the output bfd */
2720 target_sym, /* the target symbol */
2721 CURRENT_STUB_OFFSET(stub_desc), /* offset in stub buffer */
2722 R_HPPA_L21);
2723
2724 /* 2. Make the call. */
2725
2726 NEW_INSTRUCTION(stub_desc,BLE_XXX_0_RP);
2727 hppa_elf_stub_reloc (stub_desc,
2728 abfd, /* the output bfd */
2729 target_sym, /* the target symbol */
2730 CURRENT_STUB_OFFSET(stub_desc), /* offset in stub buffer */
2731 R_HPPA_ABS_CALL_R17);
2732 NEW_INSTRUCTION(stub_desc,COPY_31_2);
2733
2734 /* 3. Branch back to the original location. */
2735 NEW_INSTRUCTION(stub_desc, LDW_M24SP_RP);
2736 NEW_INSTRUCTION(stub_desc, BV_N_0RP);
2737 }
2738
2739 return stub_sym;
2740 }
2741
2742 int
2743 hppa_elf_long_branch_needed_p (abfd, asec, reloc_entry, symbol, insn)
2744 bfd *abfd;
2745 asection *asec;
2746 arelent *reloc_entry;
2747 asymbol *symbol;
2748 unsigned insn;
2749 {
2750 long sym_value = get_symbol_value(symbol);
2751 int fmt = reloc_entry->howto->bitsize;
2752 unsigned char op = get_opcode(insn);
2753 unsigned raddr;
2754
2755 #define too_far(val,num_bits) ((int)(val) > (1<<(num_bits))-1) || ((int)(val) < (-1<<(num_bits)))
2756
2757 BFD_ASSERT(fmt == hppa_elf_insn2fmt(reloc_entry->howto->type,insn));
2758
2759 switch (op)
2760 {
2761 case BL:
2762 raddr =
2763 reloc_entry->address + asec->output_offset + asec->output_section->vma;
2764 if ( too_far(sym_value - raddr,fmt+1) )
2765 {
2766 #ifdef DETECT_STUBS
2767 fprintf(stderr,"long_branch needed on BL insn: abfd=%s,sym=%s,distance=0x%x\n",abfd->filename,symbol->name,sym_value - reloc_entry->address);
2768 #endif
2769 return 1;
2770 }
2771 break;
2772 }
2773 return 0;
2774 }
2775
2776 asymbol *
2777 hppa_elf_stub_check (abfd, output_bfd, input_section, reloc_entry, symbol, hit_data)
2778 bfd *abfd;
2779 bfd *output_bfd;
2780 asection *input_section;
2781 arelent *reloc_entry;
2782 asymbol *symbol;
2783 bfd_byte *hit_data;
2784 {
2785 int stub_types[5];
2786
2787 switch (reloc_entry->howto->type)
2788 {
2789 case R_HPPA_ABS_CALL_11: /* Symbol + Addend 11 */
2790 case R_HPPA_ABS_CALL_14: /* Symbol + Addend 14 */
2791 case R_HPPA_ABS_CALL_17: /* Symbol + Addend 17 */
2792 case R_HPPA_ABS_CALL_L21: /* L (Symbol, Addend) 21 */
2793 case R_HPPA_ABS_CALL_R11: /* R (Symbol, Addend) 11 */
2794 case R_HPPA_ABS_CALL_R14: /* R (Symbol, Addend) 14 */
2795 case R_HPPA_ABS_CALL_R17: /* R (Symbol, Addend) 17 */
2796 case R_HPPA_ABS_CALL_LS21: /* LS(Symbol, Addend) 21 */
2797 case R_HPPA_ABS_CALL_RS11: /* RS(Symbol, Addend) 11 */
2798 case R_HPPA_ABS_CALL_RS14: /* RS(Symbol, Addend) 14 */
2799 case R_HPPA_ABS_CALL_RS17: /* RS(Symbol, Addend) 17 */
2800 case R_HPPA_ABS_CALL_LD21: /* LD(Symbol, Addend) 21 */
2801 case R_HPPA_ABS_CALL_RD11: /* RD(Symbol, Addend) 11 */
2802 case R_HPPA_ABS_CALL_RD14: /* RD(Symbol, Addend) 14 */
2803 case R_HPPA_ABS_CALL_RD17: /* RD(Symbol, Addend) 17 */
2804 case R_HPPA_ABS_CALL_LR21: /* LR(Symbol, Addend) 21 */
2805 case R_HPPA_ABS_CALL_RR14: /* RR(Symbol, Addend) 14 */
2806 case R_HPPA_ABS_CALL_RR17: /* RR(Symbol, Addend) 17 */
2807
2808 case R_HPPA_PCREL_CALL_11: /* Symbol - PC + Addend 11 */
2809 case R_HPPA_PCREL_CALL_14: /* Symbol - PC + Addend 14 */
2810 case R_HPPA_PCREL_CALL_17: /* Symbol - PC + Addend 17 */
2811 case R_HPPA_PCREL_CALL_12: /* Symbol - PC + Addend 12 */
2812 case R_HPPA_PCREL_CALL_L21:/* L (Symbol - PC, Addend) 21 */
2813 case R_HPPA_PCREL_CALL_R11:/* R (Symbol - PC, Addend) 11 */
2814 case R_HPPA_PCREL_CALL_R14:/* R (Symbol - PC, Addend) 14 */
2815 case R_HPPA_PCREL_CALL_R17:/* R (Symbol - PC, Addend) 17 */
2816 case R_HPPA_PCREL_CALL_LS21: /* LS(Symbol - PC, Addend) 21 */
2817 case R_HPPA_PCREL_CALL_RS11: /* RS(Symbol - PC, Addend) 11 */
2818 case R_HPPA_PCREL_CALL_RS14: /* RS(Symbol - PC, Addend) 14 */
2819 case R_HPPA_PCREL_CALL_RS17: /* RS(Symbol - PC, Addend) 17 */
2820 case R_HPPA_PCREL_CALL_LD21: /* LD(Symbol - PC, Addend) 21 */
2821 case R_HPPA_PCREL_CALL_RD11: /* RD(Symbol - PC, Addend) 11 */
2822 case R_HPPA_PCREL_CALL_RD14: /* RD(Symbol - PC, Addend) 14 */
2823 case R_HPPA_PCREL_CALL_RD17: /* RD(Symbol - PC, Addend) 17 */
2824 case R_HPPA_PCREL_CALL_LR21: /* LR(Symbol - PC, Addend) 21 */
2825 case R_HPPA_PCREL_CALL_RR14: /* RR(Symbol - PC, Addend) 14 */
2826 case R_HPPA_PCREL_CALL_RR17: /* RR(Symbol - PC, Addend) 17 */
2827 if (hppa_elf_arg_reloc_needed_p (abfd, reloc_entry, stub_types))
2828 {
2829 /* generate a stub */
2830 return hppa_elf_build_arg_reloc_stub (abfd, output_bfd, reloc_entry,
2831 stub_types);
2832 }
2833 if (hppa_elf_long_branch_needed_p (abfd, input_section, reloc_entry, symbol,*(unsigned *)hit_data))
2834 {
2835 /* generate a stub */
2836 return hppa_elf_build_long_branch_stub (abfd, output_bfd,
2837 reloc_entry, symbol,
2838 (unsigned *)hit_data);
2839 }
2840 break;
2841
2842 default:
2843 break;
2844
2845 }
2846 return reloc_entry->sym_ptr_ptr[0];
2847 }
2848
2849 #define STUB_SYM_BUFFER_INC 5
2850
2851 asymbol *
2852 hppa_look_for_stubs_in_section (stub_bfd, abfd, output_bfd, asec, syms, new_sym_cnt)
2853 bfd *stub_bfd;
2854 bfd *abfd;
2855 bfd *output_bfd;
2856 asection *asec;
2857 asymbol **syms;
2858 int *new_sym_cnt;
2859 {
2860 int i;
2861 int stub_types[5];
2862 asymbol *new_syms = (asymbol *) NULL;
2863 int new_cnt = 0;
2864 int new_max = 0;
2865
2866 /* Relocations are in different places depending on whether this is */
2867 /* an output section or an input section. Also, the relocations are */
2868 /* in different forms. Sigh. */
2869 /* Luckily, we have bfd_canonicalize_reloc() to straighten this out for us. */
2870
2871 /* if ( asec->orelocation || asec->relocation ) { */
2872 if (asec->reloc_count > 0)
2873 {
2874 arelent **reloc_vector = (arelent **) alloca (asec->reloc_count * (sizeof (arelent *) + 1));
2875
2876 bfd_canonicalize_reloc (abfd, asec, reloc_vector, syms);
2877 for (i = 0; i < asec->reloc_count; i++)
2878 {
2879 #if 0
2880 arelent *rle;
2881
2882 if ( asec->orelocation )
2883 rle = asec->orelocation[i];
2884 else
2885 rle = asec->relocation+i;
2886 #endif
2887
2888 arelent *rle = reloc_vector[i];
2889
2890 switch (rle->howto->type)
2891 {
2892 case R_HPPA_ABS_CALL_11: /* Symbol + Addend 11 */
2893 case R_HPPA_ABS_CALL_14: /* Symbol + Addend 14 */
2894 case R_HPPA_ABS_CALL_17: /* Symbol + Addend 17 */
2895 case R_HPPA_ABS_CALL_L21: /* L (Symbol, Addend) 21 */
2896 case R_HPPA_ABS_CALL_R11: /* R (Symbol, Addend) 11 */
2897 case R_HPPA_ABS_CALL_R14: /* R (Symbol, Addend) 14 */
2898 case R_HPPA_ABS_CALL_R17: /* R (Symbol, Addend) 17 */
2899 case R_HPPA_ABS_CALL_LS21: /* LS(Symbol, Addend) 21 */
2900 case R_HPPA_ABS_CALL_RS11: /* RS(Symbol, Addend) 11 */
2901 case R_HPPA_ABS_CALL_RS14: /* RS(Symbol, Addend) 14 */
2902 case R_HPPA_ABS_CALL_RS17: /* RS(Symbol, Addend) 17 */
2903 case R_HPPA_ABS_CALL_LD21: /* LD(Symbol, Addend) 21 */
2904 case R_HPPA_ABS_CALL_RD11: /* RD(Symbol, Addend) 11 */
2905 case R_HPPA_ABS_CALL_RD14: /* RD(Symbol, Addend) 14 */
2906 case R_HPPA_ABS_CALL_RD17: /* RD(Symbol, Addend) 17 */
2907 case R_HPPA_ABS_CALL_LR21: /* LR(Symbol, Addend) 21 */
2908 case R_HPPA_ABS_CALL_RR14: /* RR(Symbol, Addend) 14 */
2909 case R_HPPA_ABS_CALL_RR17: /* RR(Symbol, Addend) 17 */
2910
2911 case R_HPPA_PCREL_CALL_11: /* Symbol - PC + Addend 11 */
2912 case R_HPPA_PCREL_CALL_14: /* Symbol - PC + Addend 14 */
2913 case R_HPPA_PCREL_CALL_17: /* Symbol - PC + Addend 17 */
2914 case R_HPPA_PCREL_CALL_12: /* Symbol - PC + Addend 12 */
2915 case R_HPPA_PCREL_CALL_L21: /* L (Symbol - PC, Addend) 21 */
2916 case R_HPPA_PCREL_CALL_R11: /* R (Symbol - PC, Addend) 11 */
2917 case R_HPPA_PCREL_CALL_R14: /* R (Symbol - PC, Addend) 14 */
2918 case R_HPPA_PCREL_CALL_R17: /* R (Symbol - PC, Addend) 17 */
2919 case R_HPPA_PCREL_CALL_LS21: /* LS(Symbol - PC, Addend) 21 */
2920 case R_HPPA_PCREL_CALL_RS11: /* RS(Symbol - PC, Addend) 11 */
2921 case R_HPPA_PCREL_CALL_RS14: /* RS(Symbol - PC, Addend) 14 */
2922 case R_HPPA_PCREL_CALL_RS17: /* RS(Symbol - PC, Addend) 17 */
2923 case R_HPPA_PCREL_CALL_LD21: /* LD(Symbol - PC, Addend) 21 */
2924 case R_HPPA_PCREL_CALL_RD11: /* RD(Symbol - PC, Addend) 11 */
2925 case R_HPPA_PCREL_CALL_RD14: /* RD(Symbol - PC, Addend) 14 */
2926 case R_HPPA_PCREL_CALL_RD17: /* RD(Symbol - PC, Addend) 17 */
2927 case R_HPPA_PCREL_CALL_LR21: /* LR(Symbol - PC, Addend) 21 */
2928 case R_HPPA_PCREL_CALL_RR14: /* RR(Symbol - PC, Addend) 14 */
2929 case R_HPPA_PCREL_CALL_RR17: /* RR(Symbol - PC, Addend) 17 */
2930 if (hppa_elf_arg_reloc_needed_p (abfd, rle, stub_types))
2931 {
2932 /* generate a stub */
2933 /* keep track of the new symbol */
2934
2935 asymbol *r;
2936
2937 if (new_cnt == new_max)
2938 {
2939 new_max += STUB_SYM_BUFFER_INC;
2940 new_syms = (asymbol *) realloc (new_syms, new_max * sizeof (asymbol));
2941 }
2942 r = hppa_elf_build_arg_reloc_stub (stub_bfd, output_bfd, rle,
2943 stub_types);
2944 new_syms[new_cnt++] = *r;
2945 }
2946 /* We need to retrieve the section contents to check for */
2947 /* long branch stubs. */
2948 {
2949 unsigned insn;
2950
2951 bfd_get_section_contents(abfd, asec, &insn, rle->address, sizeof(insn));
2952 if (hppa_elf_long_branch_needed_p (abfd, asec, rle, rle->sym_ptr_ptr[0], insn))
2953 {
2954 /* generate a stub */
2955 /* keep track of the new symbol */
2956
2957 asymbol *r;
2958
2959 if (new_cnt == new_max)
2960 {
2961 new_max += STUB_SYM_BUFFER_INC;
2962 new_syms = (asymbol *) realloc (new_syms, new_max * sizeof (asymbol));
2963 }
2964 r = hppa_elf_build_long_branch_stub (stub_bfd,
2965 output_bfd,
2966 rle,
2967 rle->sym_ptr_ptr[0],
2968 &insn);
2969 new_syms[new_cnt++] = *r;
2970 }
2971 }
2972 break;
2973
2974 default:
2975 break;
2976
2977 }
2978 }
2979 }
2980 *new_sym_cnt = new_cnt;
2981 return new_syms;
2982 }
2983
2984
2985 char *linker_stubs = NULL;
2986 int linker_stubs_size = 0;
2987 int linker_stubs_max_size = 0;
2988 #define STUB_ALLOC_INCR 100
2989
2990 boolean
2991 DEFUN (hppa_elf_set_section_contents, (abfd, section, location, offset, count),
2992 bfd * abfd AND
2993 sec_ptr section AND
2994 PTR location AND
2995 file_ptr offset AND
2996 bfd_size_type count)
2997 {
2998 if ( strcmp(section->name, ".hppa_linker_stubs") == 0 )
2999 {
3000 if ( linker_stubs_max_size < offset + count )
3001 {
3002 linker_stubs_max_size = offset + count + STUB_ALLOC_INCR;
3003 linker_stubs = (char *)realloc(linker_stubs, linker_stubs_max_size);
3004 }
3005
3006 if ( offset + count > linker_stubs_size )
3007 linker_stubs_size = offset + count;
3008
3009 memcpy(linker_stubs + offset,location,count);
3010 return (true);
3011 }
3012 else
3013 return bfd_elf32_set_section_contents (abfd, section, location,
3014 offset, count);
3015 }
3016
3017 boolean
3018 DEFUN (hppa_elf_get_section_contents, (abfd, section, location, offset, count),
3019 bfd * abfd AND
3020 sec_ptr section AND
3021 PTR location AND
3022 file_ptr offset AND
3023 bfd_size_type count)
3024 {
3025 /* if this is the linker stub section, then we have the */
3026 /* section contents in memory rather than on disk. */
3027 if (strcmp (section->name, ".hppa_linker_stubs") == 0)
3028 {
3029 Elf32_hppa_Stub_description *stub_desc = find_stubs (abfd, section);
3030
3031 if (count == 0)
3032 return true;
3033 if ((bfd_size_type) (offset + count) > section->_raw_size)
3034 return (false); /* on error */
3035 if ((bfd_size_type) (offset + count) > stub_desc->real_size)
3036 return (false); /* on error */
3037
3038 memcpy (location, stub_desc->stub_contents + offset, count);
3039 return (true);
3040 }
3041 /* if this is the symbol extension section, then we have the */
3042 /* section contents in memory rather than on disk. */
3043 else if (strcmp (section->name, ".hppa_symextn") == 0)
3044 {
3045 if (count == 0)
3046 return true;
3047 if ((bfd_size_type) (offset + count) > section->_raw_size)
3048 return (false); /* on error */
3049 if ((bfd_size_type) (offset + count) > symextn_contents_real_size)
3050 return (false); /* on error */
3051
3052 memcpy (location, symextn_contents + offset, count);
3053 return (true);
3054 }
3055 else
3056 return bfd_generic_get_section_contents (abfd, section, location, offset, count);
3057 }
3058
3059 static void
3060 DEFUN (elf_info_to_howto, (abfd, cache_ptr, dst),
3061 bfd * abfd AND
3062 arelent * cache_ptr AND
3063 Elf32_Internal_Rela * dst)
3064 {
3065 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_HPPA_UNIMPLEMENTED);
3066 cache_ptr->howto = &elf_hppa_howto_table[ELF32_R_TYPE(dst->r_info)];
3067 }
3068
3069 static void
3070 DEFUN (elf32_hppa_backend_symbol_processing, (abfd, sym),
3071 bfd * abfd AND
3072 asymbol * sym)
3073 {
3074 /* Is this a definition of $global$? If so, keep it because it will be
3075 needed if any relocations are performed. */
3076
3077 if (!strcmp (sym->name, "$global$")
3078 && sym->section != &bfd_und_section)
3079 {
3080 global_symbol = sym;
3081 }
3082 }
3083
3084 #define elf_backend_symbol_processing elf32_hppa_backend_symbol_processing
3085
3086 struct elf32_hppa_symextn_map_struct
3087 {
3088 int old_index;
3089 bfd *bfd;
3090 asymbol *sym;
3091 int new_index;
3092 };
3093
3094 static struct elf32_hppa_symextn_map_struct *elf32_hppa_symextn_map;
3095 static int elf32_hppa_symextn_map_size;
3096
3097 static boolean
3098 DEFUN (elf32_hppa_backend_symbol_table_processing, (abfd, esyms,symcnt),
3099 bfd * abfd AND
3100 elf32_symbol_type *esyms AND
3101 int symcnt)
3102 {
3103 Elf32_Internal_Shdr *symextn_hdr = bfd_elf_find_section (abfd, SYMEXTN_SECTION_NAME);
3104 int i;
3105 int current_sym_idx = 0;
3106
3107 /* If the symbol extension section does not exist, all the symbol */
3108 /* all the symbol extension information is assumed to be zero. */
3109
3110 if ( symextn_hdr == NULL )
3111 {
3112 for ( i = 0; i < symcnt; i++ )
3113 {
3114 esyms[i].tc_data.hppa_arg_reloc = 0;
3115 }
3116 return (true);
3117 }
3118
3119 /* allocate a buffer of the appropriate size for the symextn section */
3120
3121 symextn_hdr->contents = bfd_zalloc(abfd,symextn_hdr->sh_size);
3122 symextn_hdr->size = symextn_hdr->sh_size;
3123
3124 /* read in the symextn section */
3125
3126 if (bfd_seek (abfd, symextn_hdr->sh_offset, SEEK_SET) == -1)
3127 {
3128 bfd_error = system_call_error;
3129 return (false);
3130 }
3131 if (bfd_read ((PTR) symextn_hdr->contents, 1, symextn_hdr->size, abfd)
3132 != symextn_hdr->size)
3133 {
3134 free ((PTR)symextn_hdr->contents);
3135 bfd_error = system_call_error;
3136 return (false);
3137 }
3138
3139 /* parse the entries, updating the symtab entries as we go */
3140
3141 for ( i = 0; i < symextn_hdr->size / sizeof(symext_entryS); i++ )
3142 {
3143 symext_entryS *seP = ((symext_entryS *)symextn_hdr->contents) + i;
3144 int se_value = ELF32_HPPA_SX_VAL(*seP);
3145 int se_type = ELF32_HPPA_SX_TYPE(*seP);
3146
3147 switch ( se_type )
3148 {
3149 case HPPA_SXT_NULL:
3150 break;
3151
3152 case HPPA_SXT_SYMNDX:
3153 if ( se_value >= symcnt )
3154 {
3155 bfd_error = bad_value;
3156 bfd_perror("elf32_hppa_backend_symbol_table_processing -- symbol index");
3157 return (false);
3158 }
3159 current_sym_idx = se_value - 1;
3160 break;
3161
3162 case HPPA_SXT_ARG_RELOC:
3163 esyms[current_sym_idx].tc_data.hppa_arg_reloc = se_value;
3164 break;
3165
3166 default:
3167 bfd_error = bad_value;
3168 bfd_perror("elf32_hppa_backend_symbol_table_processing");
3169 return (false);
3170 }
3171 }
3172 return (true);
3173 }
3174
3175 #define elf_backend_symbol_table_processing elf32_hppa_backend_symbol_table_processing
3176
3177 static boolean
3178 DEFUN (elf32_hppa_backend_section_processing, (abfd, secthdr),
3179 bfd * abfd AND
3180 Elf32_Internal_Shdr *secthdr)
3181 {
3182 int i,j,k;
3183
3184 if ( secthdr->sh_type == SHT_HPPA_SYMEXTN )
3185 {
3186 for ( i = 0; i < secthdr->size / sizeof(symext_entryS); i++ )
3187 {
3188 symext_entryS *seP = ((symext_entryS *)secthdr->contents) + i;
3189 int se_value = ELF32_HPPA_SX_VAL(*seP);
3190 int se_type = ELF32_HPPA_SX_TYPE(*seP);
3191
3192 switch ( se_type )
3193 {
3194 case HPPA_SXT_NULL:
3195 break;
3196
3197 case HPPA_SXT_SYMNDX:
3198 for ( j = 0; j < abfd->symcount; j++ )
3199 {
3200 /* locate the map entry for this symbol, if there is one. */
3201 /* modify the symbol extension section symbol index entry */
3202 /* to reflect the new symbol table index */
3203
3204 for ( k = 0; k < elf32_hppa_symextn_map_size; k++ )
3205 {
3206 if ( elf32_hppa_symextn_map[k].old_index == se_value
3207 && elf32_hppa_symextn_map[k].bfd == abfd->outsymbols[j]->the_bfd
3208 && elf32_hppa_symextn_map[k].sym == abfd->outsymbols[j] )
3209 {
3210 bfd_put_32(abfd,
3211 ELF32_HPPA_SX_WORD (HPPA_SXT_SYMNDX, j),
3212 (char *)seP);
3213 }
3214 }
3215 }
3216 break;
3217
3218 case HPPA_SXT_ARG_RELOC:
3219 break;
3220
3221 default:
3222 bfd_error = bad_value;
3223 bfd_perror("elf32_hppa_backend_section_processing");
3224 return (false);
3225 }
3226 }
3227 }
3228 return true;
3229 }
3230
3231 #define elf_backend_section_processing elf32_hppa_backend_section_processing
3232
3233 static boolean
3234 DEFUN (elf32_hppa_backend_section_from_shdr, (abfd, hdr, name),
3235 bfd * abfd AND
3236 Elf32_Internal_Shdr *hdr AND
3237 char * name)
3238 {
3239 asection *newsect;
3240
3241 if ( hdr->sh_type == SHT_HPPA_SYMEXTN )
3242 {
3243 BFD_ASSERT ( strcmp(name,".hppa_symextn") == 0 );
3244
3245 /* Bits that get saved. This one is real. */
3246 if (!hdr->rawdata)
3247 {
3248 newsect = bfd_make_section (abfd, name);
3249 if (newsect != NULL)
3250 {
3251 newsect->vma = hdr->sh_addr;
3252 newsect->_raw_size = hdr->sh_size;
3253 newsect->filepos = hdr->sh_offset; /* so we can read back the bits */
3254 newsect->flags |= SEC_HAS_CONTENTS;
3255 newsect->alignment_power = hdr->sh_addralign;
3256
3257 if (hdr->sh_flags & SHF_ALLOC)
3258 {
3259 newsect->flags |= SEC_ALLOC;
3260 newsect->flags |= SEC_LOAD;
3261 }
3262
3263 if (!(hdr->sh_flags & SHF_WRITE))
3264 newsect->flags |= SEC_READONLY;
3265
3266 if (hdr->sh_flags & SHF_EXECINSTR)
3267 newsect->flags |= SEC_CODE; /* FIXME: may only contain SOME code */
3268 else
3269 newsect->flags |= SEC_DATA;
3270
3271 hdr->rawdata = (void *) newsect;
3272 }
3273 }
3274 return true;
3275 }
3276 return false;
3277 }
3278
3279 #define elf_backend_section_from_shdr elf32_hppa_backend_section_from_shdr
3280
3281 static boolean
3282 DEFUN (elf32_hppa_backend_fake_sections, (abfd, secthdr, asect),
3283 bfd * abfd AND
3284 Elf_Internal_Shdr *secthdr AND
3285 asection *asect)
3286 {
3287
3288 if ( strcmp(asect->name, ".hppa_symextn") == 0 )
3289 {
3290 secthdr->sh_type = SHT_HPPA_SYMEXTN;
3291 secthdr->sh_flags = 0;
3292 secthdr->sh_info = elf_section_data(asect)->rel_hdr.sh_link;
3293 secthdr->sh_link = elf_onesymtab(abfd);
3294 return true;
3295 }
3296
3297 if (!strcmp (asect->name, ".hppa_unwind"))
3298 {
3299 secthdr->sh_type = SHT_PROGBITS;
3300 /* Unwind descriptors are not part of the program memory image. */
3301 secthdr->sh_flags = 0;
3302 secthdr->sh_info = 0;
3303 secthdr->sh_link = 0;
3304 secthdr->sh_entsize = 16;
3305 return true;
3306 }
3307
3308 return false;
3309 }
3310
3311 #define elf_backend_fake_sections elf32_hppa_backend_fake_sections
3312
3313 static boolean
3314 DEFUN (elf32_hppa_backend_section_from_bfd_section, (abfd, hdr, asect),
3315 bfd *abfd AND
3316 Elf32_Internal_Shdr *hdr AND
3317 asection *asect)
3318 {
3319
3320 if ( hdr->sh_type == SHT_HPPA_SYMEXTN )
3321 {
3322 if (hdr->rawdata)
3323 {
3324 if (((struct sec *) (hdr->rawdata)) == asect)
3325 {
3326 BFD_ASSERT( strcmp(asect->name, ".hppa_symextn") == 0 );
3327 return true;
3328 }
3329 }
3330 }
3331
3332 return false;
3333 }
3334
3335 #define elf_backend_section_from_bfd_section elf32_hppa_backend_section_from_bfd_section
3336
3337 #define bfd_generic_get_section_contents hppa_elf_get_section_contents
3338 #define bfd_elf32_set_section_contents hppa_elf_set_section_contents
3339
3340 #define TARGET_BIG_SYM bfd_elf32_hppa_vec
3341 #define TARGET_BIG_NAME "elf32-hppa"
3342 #define ELF_ARCH bfd_arch_hppa
3343
3344 #include "elf32-target.h"
A mirror of the official binutils-gdb repository