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