projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* som.c (hppa_som_gen_reloc_type): Choose a reasonable field
[deliverable/binutils-gdb.git] / bfd / elf32-hppa.c
CommitLineData
4c85cbfa 1/* BFD back-end for HP PA-RISC ELF files.
31dabb6c 2 Copyright (C) 1990, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
4c85cbfa
KR		 3
4 Written by
e8f2240a 5
4c85cbfa
KR		 6 Center for Software Science
7 Department of Computer Science
8 University of Utah
9
10This file is part of BFD, the Binary File Descriptor library.
11
12This program is free software; you can redistribute it and/or modify
13it under the terms of the GNU General Public License as published by
14the Free Software Foundation; either version 2 of the License, or
15(at your option) any later version.
16
17This program is distributed in the hope that it will be useful,
18but WITHOUT ANY WARRANTY; without even the implied warranty of
19MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20GNU General Public License for more details.
21
22You should have received a copy of the GNU General Public License
23along with this program; if not, write to the Free Software
24Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
25
26#include "bfd.h"
27#include "sysdep.h"
24f13b03 28#include "bfdlink.h"
4c85cbfa
KR		 29#include "libbfd.h"
30#include "obstack.h"
31#include "libelf.h"
32
b68a74d1
JL		 33/* The internal type of a symbol table extension entry. */
34typedef unsigned long symext_entryS;
35
36/* The external type of a symbol table extension entry. */
37#define ELF32_PARISC_SX_SIZE (4)
38#define ELF32_PARISC_SX_GET(bfd, addr) bfd_h_get_32 ((bfd), (addr))
39#define ELF32_PARISC_SX_PUT(bfd, val, addr) \
40 bfd_h_put_32 ((bfd), (val), (addr))
4c85cbfa 41
24f13b03
ILT		 42/* HPPA symbol table extension entry types */
43enum elf32_hppa_symextn_types
44{
45 PARISC_SXT_NULL,
46 PARISC_SXT_SYMNDX,
47 PARISC_SXT_ARG_RELOC,
48};
4c85cbfa 49
24f13b03 50/* These macros compose and decompose the value of a symextn entry:
4c85cbfa 51
24f13b03
ILT		 52 entry_type = ELF32_PARISC_SX_TYPE(word);
53 entry_value = ELF32_PARISC_SX_VAL(word);
54 word = ELF32_PARISC_SX_WORD(type,val); */
55
56#define ELF32_PARISC_SX_TYPE(p) ((p) >> 24)
57#define ELF32_PARISC_SX_VAL(p) ((p) & 0xFFFFFF)
58#define ELF32_PARISC_SX_WORD(type,val) (((type) << 24) + (val & 0xFFFFFF))
59
60/* The following was added facilitate implementation of the .hppa_symextn
61 section. This section is built after the symbol table is built in the
62 elf_write_object_contents routine (called from bfd_close). It is built
63 so late because it requires information that is not known until
64 the symbol and string table sections have been allocated, and
65 the symbol table has been built. */
66
67#define SYMEXTN_SECTION_NAME ".PARISC.symext"
68
24f13b03
ILT		 69struct symext_chain
70 {
71 symext_entryS entry;
72 struct symext_chain *next;
73 };
74
75typedef struct symext_chain symext_chainS;
76
77/* We use three different hash tables to hold information for
78 linking PA ELF objects.
79
80 The first is the elf32_hppa_link_hash_table which is derived
81 from the standard ELF linker hash table. We use this as a place to
82 attach other hash tables and static information.
83
84 The second is the stub hash table which is derived from the
85 base BFD hash table. The stub hash table holds the information
86 necessary to build the linker stubs during a link.
87
88 The last hash table keeps track of argument location information needed
89 to build hash tables. Each function with nonzero argument location
90 bits will have an entry in this table. */
91
92/* Hash table for linker stubs. */
93
94struct elf32_hppa_stub_hash_entry
95{
96 /* Base hash table entry structure, we can get the name of the stub
97 (and thus know exactly what actions it performs) from the base
98 hash table entry. */
99 struct bfd_hash_entry root;
100
101 /* Offset of the beginning of this stub. */
102 bfd_vma offset;
103
104 /* Given the symbol's value and its section we can determine its final
105 value when building the stubs (so the stub knows where to jump. */
106 symvalue target_value;
107 asection *target_section;
108};
109
110struct elf32_hppa_stub_hash_table
111{
112 /* The hash table itself. */
113 struct bfd_hash_table root;
114
115 /* The stub BFD. */
116 bfd *stub_bfd;
117
118 /* Where to place the next stub. */
119 bfd_byte *location;
120
121 /* Current offset in the stub section. */
122 unsigned int offset;
123
124};
125
126/* Hash table for argument location information. */
127
128struct elf32_hppa_args_hash_entry
e08b9ad7 129{
24f13b03
ILT		 130 /* Base hash table entry structure. */
131 struct bfd_hash_entry root;
132
133 /* The argument location bits for this entry. */
134 int arg_bits;
135};
e08b9ad7 136
24f13b03
ILT		 137struct elf32_hppa_args_hash_table
138{
139 /* The hash table itself. */
140 struct bfd_hash_table root;
141};
e08b9ad7 142
24f13b03 143struct elf32_hppa_link_hash_entry
e08b9ad7 144{
24f13b03
ILT		 145 struct elf_link_hash_entry root;
146};
147
148struct elf32_hppa_link_hash_table
e08b9ad7 149{
24f13b03
ILT		 150 /* The main hash table. */
151 struct elf_link_hash_table root;
152
153 /* The stub hash table. */
154 struct elf32_hppa_stub_hash_table *stub_hash_table;
155
156 /* The argument relocation bits hash table. */
157 struct elf32_hppa_args_hash_table *args_hash_table;
158
159 /* A count of the number of output symbols. */
160 unsigned int output_symbol_count;
161
162 /* Stuff so we can handle DP relative relocations. */
163 long global_value;
164 int global_sym_defined;
165};
166
e08b9ad7
JL		 167/* FIXME. */
168#define ARGUMENTS 0
169#define RETURN_VALUE 1
170
24f13b03 171/* The various argument relocations that may be performed. */
e08b9ad7
JL		 172typedef enum
173{
174 /* No relocation. */
24f13b03
ILT		 175 NO,
176 /* Relocate 32 bits from GR to FP register. */
177 GF,
178 /* Relocate 64 bits from a GR pair to FP pair. */
179 GD,
180 /* Relocate 32 bits from FP to GR. */
181 FG,
182 /* Relocate 64 bits from FP pair to GR pair. */
183 DG,
e08b9ad7
JL		 184} arg_reloc_type;
185
e08b9ad7
JL		 186/* What is being relocated (eg which argument or the return value). */
187typedef enum
188{
24f13b03 189 ARG0, ARG1, ARG2, ARG3, RET,
e08b9ad7
JL		 190} arg_reloc_location;
191
e08b9ad7 192
24f13b03 193/* ELF32/HPPA relocation support
e08b9ad7 194
24f13b03
ILT		 195 This file contains ELF32/HPPA relocation support as specified
196 in the Stratus FTX/Golf Object File Format (SED-1762) dated
197 February 1994. */
198
199#include "elf32-hppa.h"
200#include "hppa_stubs.h"
4c85cbfa 201
4991ebb9
ILT		 202static bfd_reloc_status_type hppa_elf_reloc
203 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
4c85cbfa 204
24f13b03 205static unsigned long hppa_elf_relocate_insn
f5bfdacd
JL		 206 PARAMS ((bfd *, asection *, unsigned long, unsigned long, long,
207 long, unsigned long, unsigned long, unsigned long));
208
f5bfdacd
JL		 209static bfd_reloc_status_type hppa_elf_reloc
210 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd*, char **));
211
31dabb6c 212static reloc_howto_type * elf_hppa_reloc_type_lookup
7ed5e970 213 PARAMS ((bfd *, bfd_reloc_code_real_type));
f5bfdacd 214
24f13b03
ILT		 215static boolean elf32_hppa_set_section_contents
216 PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
e08b9ad7 217
24f13b03
ILT		 218static void elf_info_to_howto
219 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
e08b9ad7 220
24f13b03
ILT		 221static boolean elf32_hppa_backend_symbol_table_processing
222 PARAMS ((bfd *, elf_symbol_type *, int));
e08b9ad7 223
24f13b03
ILT		 224static void elf32_hppa_backend_begin_write_processing
225 PARAMS ((bfd *, struct bfd_link_info *));
e08b9ad7 226
24f13b03
ILT		 227static void elf32_hppa_backend_final_write_processing
228 PARAMS ((bfd *, boolean));
e08b9ad7 229
24f13b03
ILT		 230static void add_entry_to_symext_chain
231 PARAMS ((bfd *, unsigned int, unsigned int, symext_chainS **,
232 symext_chainS **));
e08b9ad7 233
24f13b03
ILT		 234static void
235elf_hppa_tc_make_sections PARAMS ((bfd *, symext_chainS *));
e08b9ad7 236
24f13b03 237static boolean hppa_elf_is_local_label PARAMS ((bfd *, asymbol *));
e08b9ad7 238
24f13b03
ILT		 239static boolean elf32_hppa_add_symbol_hook
240 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
241 const char **, flagword *, asection **, bfd_vma *));
e08b9ad7 242
24f13b03 243static bfd_reloc_status_type elf32_hppa_bfd_final_link_relocate
31dabb6c 244 PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *,
24f13b03
ILT		 245 bfd_byte *, bfd_vma, bfd_vma, bfd_vma, struct bfd_link_info *,
246 asection *, const char *, int));
e08b9ad7 247
24f13b03
ILT		 248static struct bfd_link_hash_table *elf32_hppa_link_hash_table_create
249 PARAMS ((bfd *));
e08b9ad7 250
24f13b03
ILT		 251static struct bfd_hash_entry *
252elf32_hppa_stub_hash_newfunc
253 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
e08b9ad7 254
24f13b03
ILT		 255static struct bfd_hash_entry *
256elf32_hppa_args_hash_newfunc
257 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
e08b9ad7 258
24f13b03
ILT		 259static boolean
260elf32_hppa_relocate_section
261 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
eb4267a3 262 bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
e08b9ad7 263
24f13b03
ILT		 264static boolean
265elf32_hppa_stub_hash_table_init
266 PARAMS ((struct elf32_hppa_stub_hash_table *, bfd *,
267 struct bfd_hash_entry *(*) PARAMS ((struct bfd_hash_entry *,
268 struct bfd_hash_table *,
269 const char *))));
e08b9ad7 270
24f13b03
ILT		 271static boolean
272elf32_hppa_build_one_stub PARAMS ((struct bfd_hash_entry *, PTR));
e08b9ad7 273
24f13b03
ILT		 274static boolean
275elf32_hppa_read_symext_info
276 PARAMS ((bfd *, Elf_Internal_Shdr *, struct elf32_hppa_args_hash_table *,
5874427f 277 Elf_Internal_Sym *));
e08b9ad7 278
24f13b03
ILT		 279static unsigned int elf32_hppa_size_of_stub
280 PARAMS ((unsigned int, unsigned int, bfd_vma, bfd_vma, const char *));
459ae909 281
24f13b03
ILT		 282static boolean elf32_hppa_arg_reloc_needed
283 PARAMS ((unsigned int, unsigned int, arg_reloc_type []));
459ae909 284
24f13b03
ILT		 285static void elf32_hppa_name_of_stub
286 PARAMS ((unsigned int, unsigned int, bfd_vma, bfd_vma, char *));
459ae909 287
24f13b03 288static boolean elf32_hppa_size_symext PARAMS ((struct bfd_hash_entry *, PTR));
459ae909 289
24f13b03
ILT		 290static boolean elf32_hppa_link_output_symbol_hook
291 PARAMS ((bfd *, struct bfd_link_info *, const char *,
292 Elf_Internal_Sym *, asection *));
25057836 293
e08b9ad7
JL		 294/* ELF/PA relocation howto entries. */
295
d9ad93bc 296static reloc_howto_type elf_hppa_howto_table[ELF_HOWTO_TABLE_SIZE] =
4c85cbfa 297{
459ae909
JL		 298 {R_PARISC_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_NONE"},
299 {R_PARISC_DIR32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR32"},
300 {R_PARISC_DIR21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR21L"},
301 {R_PARISC_DIR17R, 0, 0, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR17R"},
302 {R_PARISC_DIR17F, 0, 0, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR17F"},
303 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
304 {R_PARISC_DIR14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR14R"},
305 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
306
307 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
308 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
309 {R_PARISC_PCREL21L, 0, 0, 21, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL21L"},
310 {R_PARISC_PCREL17R, 0, 0, 17, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL17R"},
311 {R_PARISC_PCREL17F, 0, 0, 17, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL17F"},
312 {R_PARISC_PCREL17C, 0, 0, 17, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL17C"},
313 {R_PARISC_PCREL14R, 0, 0, 14, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL14R"},
314 {R_PARISC_PCREL14F, 0, 0, 14, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL14F"},
315
316 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
317 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
318 {R_PARISC_DPREL21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DPREL21L"},
319 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
320 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
321 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
322 {R_PARISC_DPREL14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DPREL14R"},
323 {R_PARISC_DPREL14F, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DPREL14F"},
324
325 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
326 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
327 {R_PARISC_DLTREL21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTREL21L"},
328 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
329 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
330 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
331 {R_PARISC_DLTREL14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTREL14R"},
332 {R_PARISC_DLTREL14F, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTREL14F"},
333
334 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
335 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
336 {R_PARISC_DLTIND21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTIND21L"},
337 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
338 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
339 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
340 {R_PARISC_DLTIND14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTIND14R"},
341 {R_PARISC_DLTIND14F, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTIND14F"},
342
343 {R_PARISC_SETBASE, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_SETBASE"},
344 {R_PARISC_BASEREL32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL32"},
345 {R_PARISC_BASEREL21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL21L"},
346 {R_PARISC_BASEREL17R, 0, 0, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL17R"},
347 {R_PARISC_BASEREL17F, 0, 0, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL17F"},
348 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
349 {R_PARISC_BASEREL14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL14R"},
350 {R_PARISC_BASEREL14F, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL14F"},
351
352 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
353 {R_PARISC_TEXTREL32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_TEXTREL32"},
354 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
355 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
356 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
357 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
358 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
359 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
360
361 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
362 {R_PARISC_DATAREL32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
363 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
364 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
365 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
366 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
367 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
368 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
369
370
371 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
372 {R_PARISC_PLABEL32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLABEL32"},
373 {R_PARISC_PLABEL21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLABEL21L"},
374 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
375 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
376 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
377 {R_PARISC_PLABEL14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLABEL14R"},
378 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
379
380 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
381 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
382 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
383 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
384 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
385 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
386 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
387 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
388
389 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
390 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
391 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
392 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
393 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
394 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
395 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
396 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
397 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
398 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
399 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
400 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
401 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
402 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
403 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
404 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
405
406 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
407 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
408 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
409 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
410 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
411 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
412 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
413 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
414 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
415 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
416 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
417 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
418 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
419 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
420 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
421 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
422
423 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
424 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
425 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
426 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
427 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
428 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
429 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
430 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
431 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
432 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
433 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
434 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
435 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
436 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
437 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
438 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
439
440
441 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
442 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
443 {R_PARISC_PLTIND21L, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLTIND21L"},
444 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
445 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
446 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
447 {R_PARISC_PLTIND14R, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLTIND14R"},
448 {R_PARISC_PLTIND14F, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLTIND14F"},
449
450
451 {R_PARISC_COPY, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_COPY"},
452 {R_PARISC_GLOB_DAT, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_GLOB_DAT"},
453 {R_PARISC_JMP_SLOT, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_JMP_SLOT"},
454 {R_PARISC_RELATIVE, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_RELATIVE"},
459ae909
JL		 455
456 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont, NULL, "R_PARISC_UNIMPLEMENTED"},
e8f2240a 457};
4c85cbfa 458
24f13b03
ILT		 459/* Where (what register type) is an argument comming from? */
460typedef enum
461{
462 AR_NO,
463 AR_GR,
464 AR_FR,
465 AR_FU,
466 AR_FPDBL1,
467 AR_FPDBL2,
468} arg_location;
469
470/* Horizontal represents the callee's argument location information,
471 vertical represents caller's argument location information. Value at a
472 particular X,Y location represents what (if any) argument relocation
473 needs to be performed to make caller and callee agree. */
474
475static CONST arg_reloc_type arg_mismatches[6][6] =
476{
477 {NO, NO, NO, NO, NO, NO},
478 {NO, NO, GF, NO, GD, NO},
479 {NO, FG, NO, NO, NO, NO},
480 {NO, NO, NO, NO, NO, NO},
481 {NO, DG, NO, NO, NO, NO},
482 {NO, DG, NO, NO, NO, NO},
483};
484
485/* Likewise, but reversed for the return value. */
486static CONST arg_reloc_type ret_mismatches[6][6] =
487{
488 {NO, NO, NO, NO, NO, NO},
489 {NO, NO, FG, NO, DG, NO},
490 {NO, GF, NO, NO, NO, NO},
491 {NO, NO, NO, NO, NO, NO},
492 {NO, GD, NO, NO, NO, NO},
493 {NO, GD, NO, NO, NO, NO},
494};
495
496/* Misc static crud for symbol extension records. */
d9ad93bc
KR		 497static symext_chainS *symext_rootP;
498static symext_chainS *symext_lastP;
b68a74d1 499static bfd_size_type symext_chain_size;
24f13b03
ILT		 500
501/* FIXME: We should be able to try this static variable! */
b68a74d1 502static bfd_byte *symextn_contents;
e08b9ad7 503
24f13b03
ILT		 504
505/* For linker stub hash tables. */
506#define elf32_hppa_stub_hash_lookup(table, string, create, copy) \
507 ((struct elf32_hppa_stub_hash_entry *) \
508 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
509
510#define elf32_hppa_stub_hash_traverse(table, func, info) \
511 (bfd_hash_traverse \
512 (&(table)->root, \
513 (boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func), \
514 (info)))
515
516/* For linker args hash tables. */
517#define elf32_hppa_args_hash_lookup(table, string, create, copy) \
518 ((struct elf32_hppa_args_hash_entry *) \
519 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
520
521#define elf32_hppa_args_hash_traverse(table, func, info) \
522 (bfd_hash_traverse \
523 (&(table)->root, \
524 (boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func), \
525 (info)))
526
527#define elf32_hppa_args_hash_table_init(table, newfunc) \
528 (bfd_hash_table_init \
529 (&(table)->root, \
530 (struct bfd_hash_entry *(*) PARAMS ((struct bfd_hash_entry *, \
531 struct bfd_hash_table *, \
532 const char *))) (newfunc)))
533
534/* For HPPA linker hash table. */
535
536#define elf32_hppa_link_hash_lookup(table, string, create, copy, follow)\
537 ((struct elf32_hppa_link_hash_entry *) \
538 elf_link_hash_lookup (&(table)->root, (string), (create), \
539 (copy), (follow)))
540
541#define elf32_hppa_link_hash_traverse(table, func, info) \
542 (elf_link_hash_traverse \
543 (&(table)->root, \
544 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
545 (info)))
546
547/* Get the PA ELF linker hash table from a link_info structure. */
548
549#define elf32_hppa_hash_table(p) \
550 ((struct elf32_hppa_link_hash_table *) ((p)->hash))
551
552
553/* Extract specific argument location bits for WHICH from
554 the full argument location in AR. */
555#define EXTRACT_ARBITS(ar, which) ((ar) >> (8 - ((which) * 2))) & 3
556
557/* Assorted hash table functions. */
558
559/* Initialize an entry in the stub hash table. */
560
561static struct bfd_hash_entry *
562elf32_hppa_stub_hash_newfunc (entry, table, string)
563 struct bfd_hash_entry *entry;
564 struct bfd_hash_table *table;
565 const char *string;
566{
567 struct elf32_hppa_stub_hash_entry *ret;
568
569 ret = (struct elf32_hppa_stub_hash_entry *) entry;
570
571 /* Allocate the structure if it has not already been allocated by a
572 subclass. */
573 if (ret == NULL)
574 ret = ((struct elf32_hppa_stub_hash_entry *)
575 bfd_hash_allocate (table,
576 sizeof (struct elf32_hppa_stub_hash_entry)));
577 if (ret == NULL)
578 {
579 bfd_set_error (bfd_error_no_memory);
580 return NULL;
581 }
582
583 /* Call the allocation method of the superclass. */
584 ret = ((struct elf32_hppa_stub_hash_entry *)
585 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
586
587 if (ret)
588 {
589 /* Initialize the local fields. */
590 ret->offset = 0;
591 ret->target_value = 0;
592 ret->target_section = NULL;
593 }
594
595 return (struct bfd_hash_entry *) ret;
596}
597
598/* Initialize a stub hash table. */
599
600static boolean
601elf32_hppa_stub_hash_table_init (table, stub_bfd, newfunc)
602 struct elf32_hppa_stub_hash_table *table;
603 bfd *stub_bfd;
604 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
605 struct bfd_hash_table *,
606 const char *));
607{
608 table->offset = 0;
609 table->location = 0;
610 table->stub_bfd = stub_bfd;
611 return (bfd_hash_table_init (&table->root, newfunc));
612}
613
614/* Initialize an entry in the argument location hash table. */
615
616static struct bfd_hash_entry *
617elf32_hppa_args_hash_newfunc (entry, table, string)
618 struct bfd_hash_entry *entry;
619 struct bfd_hash_table *table;
620 const char *string;
621{
622 struct elf32_hppa_args_hash_entry *ret;
623
624 ret = (struct elf32_hppa_args_hash_entry *) entry;
625
626 /* Allocate the structure if it has not already been allocated by a
627 subclass. */
628 if (ret == NULL)
629 ret = ((struct elf32_hppa_args_hash_entry *)
630 bfd_hash_allocate (table,
631 sizeof (struct elf32_hppa_args_hash_entry)));
632 if (ret == NULL)
633 {
634 bfd_set_error (bfd_error_no_memory);
635 return NULL;
636 }
637
638 /* Call the allocation method of the superclass. */
639 ret = ((struct elf32_hppa_args_hash_entry *)
640 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
641
642 /* Initialize the local fields. */
643 if (ret)
644 ret->arg_bits = 0;
645
646 return (struct bfd_hash_entry *) ret;
647}
648
649/* Create the derived linker hash table. The PA ELF port uses the derived
650 hash table to keep information specific to the PA ELF linker (without
651 using static variables). */
652
653static struct bfd_link_hash_table *
654elf32_hppa_link_hash_table_create (abfd)
655 bfd *abfd;
656{
657 struct elf32_hppa_link_hash_table *ret;
658
659 ret = ((struct elf32_hppa_link_hash_table *)
660 bfd_alloc (abfd, sizeof (struct elf32_hppa_link_hash_table)));
661 if (ret == NULL)
662 {
663 bfd_set_error (bfd_error_no_memory);
664 return NULL;
665 }
666 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
667 _bfd_elf_link_hash_newfunc))
668 {
669 bfd_release (abfd, ret);
670 return NULL;
671 }
672 ret->stub_hash_table = NULL;
673 ret->args_hash_table = NULL;
674 ret->output_symbol_count = 0;
675 ret->global_value = 0;
676 ret->global_sym_defined = 0;
677
678 return &ret->root.root;
679}
e8f2240a 680
f5bfdacd 681/* Relocate the given INSN given the various input parameters.
e8f2240a 682
f5bfdacd 683 FIXME: endianness and sizeof (long) issues abound here. */
4c85cbfa
KR		 684
685static unsigned long
f5bfdacd
JL		 686hppa_elf_relocate_insn (abfd, input_sect, insn, address, sym_value,
687 r_addend, r_format, r_field, pcrel)
f4bd7a8f
DM		 688 bfd *abfd;
689 asection *input_sect;
690 unsigned long insn;
691 unsigned long address;
f4bd7a8f
DM		 692 long sym_value;
693 long r_addend;
f5bfdacd
JL		 694 unsigned long r_format;
695 unsigned long r_field;
696 unsigned long pcrel;
4c85cbfa 697{
e8f2240a
KR		 698 unsigned char opcode = get_opcode (insn);
699 long constant_value;
e8f2240a
KR		 700
701 switch (opcode)
702 {
703 case LDO:
704 case LDB:
705 case LDH:
706 case LDW:
707 case LDWM:
708 case STB:
709 case STH:
710 case STW:
711 case STWM:
f5bfdacd
JL		 712 case COMICLR:
713 case SUBI:
714 case ADDIT:
715 case ADDI:
716 case LDIL:
717 case ADDIL:
7218bb04 718 constant_value = HPPA_R_CONSTANT (r_addend);
e8f2240a
KR		 719
720 if (pcrel)
721 sym_value -= address;
e8f2240a 722
e8f2240a 723 sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
f5bfdacd 724 return hppa_rebuild_insn (abfd, insn, sym_value, r_format);
e8f2240a
KR		 725
726 case BL:
727 case BE:
728 case BLE:
e8f2240a
KR		 729 /* XXX computing constant_value is not needed??? */
730 constant_value = assemble_17 ((insn & 0x001f0000) >> 16,
731 (insn & 0x00001ffc) >> 2,
732 insn & 1);
f5bfdacd 733
e8f2240a
KR		 734 constant_value = (constant_value << 15) >> 15;
735 if (pcrel)
736 {
737 sym_value -=
738 address + input_sect->output_offset
739 + input_sect->output_section->vma;
740 sym_value = hppa_field_adjust (sym_value, -8, r_field);
741 }
742 else
743 sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
4c85cbfa 744
f5bfdacd 745 return hppa_rebuild_insn (abfd, insn, sym_value >> 2, r_format);
4c85cbfa 746
e8f2240a
KR		 747 default:
748 if (opcode == 0)
749 {
7218bb04 750 constant_value = HPPA_R_CONSTANT (r_addend);
e8f2240a 751
f5bfdacd
JL		 752 if (pcrel)
753 sym_value -= address;
754
e8f2240a
KR		 755 return hppa_field_adjust (sym_value, constant_value, r_field);
756 }
757 else
f5bfdacd 758 abort ();
e8f2240a 759 }
4c85cbfa
KR		 760}
761
24f13b03 762/* Relocate an HPPA ELF section. */
f5bfdacd 763
24f13b03
ILT		 764static boolean
765elf32_hppa_relocate_section (output_bfd, info, input_bfd, input_section,
eb4267a3 766 contents, relocs, local_syms, local_sections)
24f13b03
ILT		 767 bfd *output_bfd;
768 struct bfd_link_info *info;
769 bfd *input_bfd;
770 asection *input_section;
771 bfd_byte *contents;
772 Elf_Internal_Rela *relocs;
773 Elf_Internal_Sym *local_syms;
774 asection **local_sections;
e8f2240a 775{
24f13b03
ILT		 776 Elf_Internal_Shdr *symtab_hdr;
777 Elf_Internal_Rela *rel;
778 Elf_Internal_Rela *relend;
779
780 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
781
782 rel = relocs;
783 relend = relocs + input_section->reloc_count;
784 for (; rel < relend; rel++)
785 {
786 int r_type;
31dabb6c 787 reloc_howto_type *howto;
24f13b03
ILT		 788 long r_symndx;
789 struct elf_link_hash_entry *h;
790 Elf_Internal_Sym *sym;
791 asection *sym_sec;
792 bfd_vma relocation;
793 bfd_reloc_status_type r;
794 const char *sym_name;
795
796 r_type = ELF32_R_TYPE (rel->r_info);
797 if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
798 {
799 bfd_set_error (bfd_error_bad_value);
800 return false;
801 }
802 howto = elf_hppa_howto_table + r_type;
803
804 r_symndx = ELF32_R_SYM (rel->r_info);
805
806 if (info->relocateable)
807 {
808 /* This is a relocateable link. We don't have to change
809 anything, unless the reloc is against a section symbol,
810 in which case we have to adjust according to where the
811 section symbol winds up in the output section. */
812 if (r_symndx < symtab_hdr->sh_info)
813 {
814 sym = local_syms + r_symndx;
815 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
816 {
817 sym_sec = local_sections[r_symndx];
818 rel->r_addend += sym_sec->output_offset;
819 }
820 }
821
822 continue;
823 }
824
825 /* This is a final link. */
826 h = NULL;
827 sym = NULL;
828 sym_sec = NULL;
829 if (r_symndx < symtab_hdr->sh_info)
830 {
831 sym = local_syms + r_symndx;
832 sym_sec = local_sections[r_symndx];
833 relocation = ((ELF_ST_TYPE (sym->st_info) == STT_SECTION
834 ? 0 : sym->st_value)
835 + sym_sec->output_offset
836 + sym_sec->output_section->vma);
837 }
838 else
839 {
840 long indx;
841
842 indx = r_symndx - symtab_hdr->sh_info;
843 h = elf_sym_hashes (input_bfd)[indx];
31dabb6c
JL		 844 if (h->root.type == bfd_link_hash_defined
845 || h->root.type == bfd_link_hash_defweak)
24f13b03
ILT		 846 {
847 sym_sec = h->root.u.def.section;
848 relocation = (h->root.u.def.value
849 + sym_sec->output_offset
850 + sym_sec->output_section->vma);
851 }
31dabb6c 852 else if (h->root.type == bfd_link_hash_undefweak)
24f13b03
ILT		 853 relocation = 0;
854 else
855 {
856 if (!((*info->callbacks->undefined_symbol)
857 (info, h->root.root.string, input_bfd,
858 input_section, rel->r_offset)))
859 return false;
6cb964d4 860 break;
24f13b03
ILT		 861 }
862 }
863
864 if (h != NULL)
865 sym_name = h->root.root.string;
866 else
867 {
ede4eed4
KR		 868 sym_name = bfd_elf_string_from_elf_section (input_bfd,
869 symtab_hdr->sh_link,
870 sym->st_name);
24f13b03
ILT		 871 if (sym_name == NULL)
872 return false;
873 if (*sym_name == '\0')
874 sym_name = bfd_section_name (input_bfd, sym_sec);
875 }
876
877 /* If args_hash_table is NULL, then we have encountered some
878 kind of link error (ex. undefined symbols). Do not try to
879 apply any relocations, continue the loop so we can notify
880 the user of several errors in a single attempted link. */
881 if (elf32_hppa_hash_table (info)->args_hash_table == NULL)
882 continue;
883
884 r = elf32_hppa_bfd_final_link_relocate (howto, input_bfd, output_bfd,
885 input_section, contents,
886 rel->r_offset, relocation,
887 rel->r_addend, info, sym_sec,
888 sym_name, h == NULL);
889
890 if (r != bfd_reloc_ok)
891 {
892 switch (r)
893 {
31dabb6c
JL		 894 /* This can happen for DP relative relocs if $global$ is
895 undefined. This is a panic situation so we don't try
896 to continue. */
897 case bfd_reloc_undefined:
898 case bfd_reloc_notsupported:
899 if (!((*info->callbacks->undefined_symbol)
900 (info, "$global$", input_bfd,
901 input_section, rel->r_offset)))
902 return false;
903 return false;
24f13b03
ILT		 904 case bfd_reloc_dangerous:
905 {
906 /* We use this return value to indicate that we performed
907 a "dangerous" relocation. This doesn't mean we did
908 the wrong thing, it just means there may be some cleanup
909 that needs to be done here.
910
911 In particular we had to swap the last call insn and its
912 delay slot. If the delay slot insn needed a relocation,
913 then we'll need to adjust the next relocation entry's
914 offset to account for the fact that the insn moved.
915
916 This hair wouldn't be necessary if we inserted stubs
917 between procedures and used a "bl" to get to the stub. */
918 if (rel != relend)
919 {
920 Elf_Internal_Rela *next_rel = rel + 1;
921
922 if (rel->r_offset + 4 == next_rel->r_offset)
923 next_rel->r_offset -= 4;
924 }
925 break;
926 }
927 default:
928 case bfd_reloc_outofrange:
929 case bfd_reloc_overflow:
930 {
931 if (!((*info->callbacks->reloc_overflow)
932 (info, sym_name, howto->name, (bfd_vma) 0,
933 input_bfd, input_section, rel->r_offset)))
934 return false;
935 }
936 break;
937 }
938 }
939 }
940
941 return true;
4c85cbfa
KR		 942}
943
f5bfdacd 944/* Return one (or more) BFD relocations which implement the base
e08b9ad7 945 relocation with modifications based on format and field. */
4c85cbfa 946
e8f2240a
KR		 947elf32_hppa_reloc_type **
948hppa_elf_gen_reloc_type (abfd, base_type, format, field)
949 bfd *abfd;
950 elf32_hppa_reloc_type base_type;
951 int format;
952 int field;
4c85cbfa 953{
e8f2240a
KR		 954 elf32_hppa_reloc_type *finaltype;
955 elf32_hppa_reloc_type **final_types;
e8f2240a 956
f5bfdacd
JL		 957 /* Allocate slots for the BFD relocation. */
958 final_types = (elf32_hppa_reloc_type **)
959 bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type *) * 2);
24f13b03
ILT		 960 if (final_types == NULL)
961 return NULL;
e8f2240a 962
f5bfdacd
JL		 963 /* Allocate space for the relocation itself. */
964 finaltype = (elf32_hppa_reloc_type *)
965 bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type));
24f13b03
ILT		 966 if (finaltype == NULL)
967 return NULL;
e8f2240a 968
f5bfdacd 969 /* Some reasonable defaults. */
e8f2240a
KR		 970 final_types[0] = finaltype;
971 final_types[1] = NULL;
972
973#define final_type finaltype[0]
974
975 final_type = base_type;
976
f5bfdacd
JL		 977 /* Just a tangle of nested switch statements to deal with the braindamage
978 that a different field selector means a completely different relocation
979 for PA ELF. */
e8f2240a
KR		 980 switch (base_type)
981 {
982 case R_HPPA:
24f13b03 983 case R_HPPA_ABS_CALL:
e8f2240a
KR		 984 switch (format)
985 {
e8f2240a
KR		 986 case 14:
987 switch (field)
988 {
989 case e_rsel:
e8f2240a 990 case e_rrsel:
459ae909 991 final_type = R_PARISC_DIR14R;
e8f2240a 992 break;
459ae909
JL		 993 case e_rtsel:
994 final_type = R_PARISC_DLTREL14R;
e8f2240a 995 break;
e8f2240a 996 case e_tsel:
459ae909 997 final_type = R_PARISC_DLTREL14F;
a36b6f1d 998 break;
459ae909
JL		 999 case e_rpsel:
1000 final_type = R_PARISC_PLABEL14R;
a36b6f1d 1001 break;
e8f2240a 1002 default:
24f13b03 1003 return NULL;
e8f2240a
KR		 1004 }
1005 break;
f5bfdacd 1006
e8f2240a
KR		 1007 case 17:
1008 switch (field)
1009 {
1010 case e_fsel:
459ae909 1011 final_type = R_PARISC_DIR17F;
e8f2240a
KR		 1012 break;
1013 case e_rsel:
e8f2240a 1014 case e_rrsel:
459ae909 1015 final_type = R_PARISC_DIR17R;
e8f2240a 1016 break;
e8f2240a 1017 default:
24f13b03 1018 return NULL;
e8f2240a
KR		 1019 }
1020 break;
f5bfdacd 1021
e8f2240a
KR		 1022 case 21:
1023 switch (field)
1024 {
1025 case e_lsel:
e8f2240a 1026 case e_lrsel:
459ae909 1027 final_type = R_PARISC_DIR21L;
e8f2240a 1028 break;
a36b6f1d 1029 case e_ltsel:
459ae909
JL		 1030 final_type = R_PARISC_DLTREL21L;
1031 break;
1032 case e_lpsel:
1033 final_type = R_PARISC_PLABEL21L;
a36b6f1d 1034 break;
e8f2240a 1035 default:
24f13b03 1036 return NULL;
e8f2240a
KR		 1037 }
1038 break;
f5bfdacd 1039
e8f2240a
KR		 1040 case 32:
1041 switch (field)
1042 {
1043 case e_fsel:
459ae909 1044 final_type = R_PARISC_DIR32;
e8f2240a
KR		 1045 break;
1046 case e_psel:
459ae909 1047 final_type = R_PARISC_PLABEL32;
a36b6f1d 1048 break;
e8f2240a 1049 default:
24f13b03 1050 return NULL;
e8f2240a
KR		 1051 }
1052 break;
f5bfdacd 1053
e8f2240a 1054 default:
24f13b03 1055 return NULL;
e8f2240a
KR		 1056 }
1057 break;
f5bfdacd
JL		 1058
1059
e8f2240a
KR		 1060 case R_HPPA_GOTOFF:
1061 switch (format)
1062 {
e8f2240a
KR		 1063 case 14:
1064 switch (field)
1065 {
1066 case e_rsel:
e8f2240a 1067 case e_rrsel:
459ae909 1068 final_type = R_PARISC_DPREL14R;
e8f2240a
KR		 1069 break;
1070 case e_fsel:
459ae909 1071 final_type = R_PARISC_DPREL14F;
e8f2240a 1072 break;
e8f2240a 1073 default:
24f13b03 1074 return NULL;
e8f2240a
KR		 1075 }
1076 break;
f5bfdacd 1077
e8f2240a
KR		 1078 case 21:
1079 switch (field)
1080 {
e8f2240a 1081 case e_lrsel:
e8f2240a 1082 case e_lsel:
459ae909 1083 final_type = R_PARISC_DPREL21L;
e8f2240a 1084 break;
e8f2240a 1085 default:
24f13b03 1086 return NULL;
e8f2240a
KR		 1087 }
1088 break;
f5bfdacd 1089
e8f2240a 1090 default:
24f13b03 1091 return NULL;
e8f2240a
KR		 1092 }
1093 break;
f5bfdacd
JL		 1094
1095
459ae909 1096 case R_HPPA_PCREL_CALL:
e8f2240a
KR		 1097 switch (format)
1098 {
e8f2240a
KR		 1099 case 14:
1100 switch (field)
1101 {
1102 case e_rsel:
e8f2240a 1103 case e_rrsel:
459ae909 1104 final_type = R_PARISC_PCREL14R;
e8f2240a
KR		 1105 break;
1106 case e_fsel:
459ae909 1107 final_type = R_PARISC_PCREL14F;
e8f2240a 1108 break;
e8f2240a 1109 default:
24f13b03 1110 return NULL;
e8f2240a
KR		 1111 }
1112 break;
f5bfdacd 1113
e8f2240a
KR		 1114 case 17:
1115 switch (field)
1116 {
1117 case e_rsel:
e8f2240a 1118 case e_rrsel:
459ae909 1119 final_type = R_PARISC_PCREL17R;
e8f2240a
KR		 1120 break;
1121 case e_fsel:
459ae909 1122 final_type = R_PARISC_PCREL17F;
e8f2240a 1123 break;
e8f2240a 1124 default:
24f13b03 1125 return NULL;
e8f2240a
KR		 1126 }
1127 break;
f5bfdacd 1128
e8f2240a
KR		 1129 case 21:
1130 switch (field)
1131 {
1132 case e_lsel:
e8f2240a 1133 case e_lrsel:
459ae909 1134 final_type = R_PARISC_PCREL21L;
e8f2240a 1135 break;
e8f2240a 1136 default:
24f13b03 1137 return NULL;
e8f2240a
KR		 1138 }
1139 break;
f5bfdacd 1140
e8f2240a 1141 default:
24f13b03 1142 return NULL;
e8f2240a
KR		 1143 }
1144 break;
f5bfdacd 1145
e8f2240a 1146 default:
24f13b03 1147 return NULL;
e8f2240a
KR		 1148 }
1149
1150 return final_types;
4c85cbfa
KR		 1151}
1152
e8f2240a
KR		 1153#undef final_type
1154
24f13b03 1155/* Set the contents of a particular section at a particular location. */
4c85cbfa 1156
24f13b03
ILT		 1157static boolean
1158elf32_hppa_set_section_contents (abfd, section, location, offset, count)
4861ac76 1159 bfd *abfd;
24f13b03
ILT		 1160 sec_ptr section;
1161 PTR location;
1162 file_ptr offset;
1163 bfd_size_type count;
e8f2240a 1164{
24f13b03
ILT		 1165 /* Ignore write requests for the symbol extension section until we've
1166 had the chance to rebuild it ourselves. */
1167 if (!strcmp (section->name, ".PARISC.symextn") && !symext_chain_size)
1168 return true;
1169 else
ede4eed4
KR		 1170 return _bfd_elf_set_section_contents (abfd, section, location,
1171 offset, count);
24f13b03
ILT		 1172}
1173
1174/* Translate from an elf into field into a howto relocation pointer. */
1175
1176static void
1177elf_info_to_howto (abfd, cache_ptr, dst)
1178 bfd *abfd;
1179 arelent *cache_ptr;
1180 Elf32_Internal_Rela *dst;
1181{
1182 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_PARISC_UNIMPLEMENTED);
1183 cache_ptr->howto = &elf_hppa_howto_table[ELF32_R_TYPE (dst->r_info)];
1184}
1185
1186
1187/* Actually perform a relocation. NOTE this is (mostly) superceeded
1188 by elf32_hppa_bfd_final_link_relocate which is called by the new
1189 fast linker. */
1190
1191static bfd_reloc_status_type
1192hppa_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
1193 error_message)
1194 bfd *abfd;
1195 arelent *reloc_entry;
1196 asymbol *symbol_in;
1197 PTR data;
1198 asection *input_section;
1199 bfd *output_bfd;
1200 char **error_message;
1201{
1202 /* It is no longer valid to call hppa_elf_reloc when creating
1203 a final executable. */
e8f2240a
KR		 1204 if (output_bfd)
1205 {
e8f2240a 1206 reloc_entry->address += input_section->output_offset;
459ae909
JL		 1207
1208 /* Work around lossage in generic elf code to write relocations.
1209 (maps different section symbols into the same symbol index). */
1210 if ((symbol_in->flags & BSF_SECTION_SYM)
1211 && symbol_in->section)
1212 reloc_entry->addend += symbol_in->section->output_offset;
e8f2240a
KR		 1213 return bfd_reloc_ok;
1214 }
24f13b03
ILT		 1215 else
1216 {
1217 *error_message = (char *) "Unsupported call to hppa_elf_reloc";
1218 return bfd_reloc_notsupported;
1219 }
1220}
e8f2240a 1221
24f13b03
ILT		 1222/* Actually perform a relocation as part of a final link. This can get
1223 rather hairy when linker stubs are needed. */
e8f2240a 1224
24f13b03
ILT		 1225static bfd_reloc_status_type
1226elf32_hppa_bfd_final_link_relocate (howto, input_bfd, output_bfd,
1227 input_section, contents, offset, value,
1228 addend, info, sym_sec, sym_name, is_local)
31dabb6c 1229 reloc_howto_type *howto;
24f13b03
ILT		 1230 bfd *input_bfd;
1231 bfd *output_bfd;
1232 asection *input_section;
1233 bfd_byte *contents;
1234 bfd_vma offset;
1235 bfd_vma value;
1236 bfd_vma addend;
1237 struct bfd_link_info *info;
1238 asection *sym_sec;
1239 const char *sym_name;
1240 int is_local;
1241{
1242 unsigned long insn;
1243 unsigned long r_type = howto->type;
1244 unsigned long r_format = howto->bitsize;
1245 unsigned long r_field = e_fsel;
5874427f 1246 bfd_byte *hit_data = contents + offset;
24f13b03 1247 boolean r_pcrel = howto->pc_relative;
e8f2240a 1248
24f13b03 1249 insn = bfd_get_32 (input_bfd, hit_data);
f5bfdacd 1250
24f13b03
ILT		 1251 /* Make sure we have a value for $global$. FIXME isn't this effectively
1252 just like the gp pointer on MIPS? Can we use those routines for this
1253 purpose? */
1254 if (!elf32_hppa_hash_table (info)->global_sym_defined)
e8f2240a 1255 {
24f13b03
ILT		 1256 struct elf_link_hash_entry *h;
1257 asection *sec;
1258
1259 h = elf_link_hash_lookup (elf_hash_table (info), "$global$", false,
1260 false, false);
e8f2240a 1261
24f13b03
ILT		 1262 /* If there isn't a $global$, then we're in deep trouble. */
1263 if (h == NULL)
1264 return bfd_reloc_notsupported;
1265
31dabb6c
JL		 1266 /* If $global$ isn't a defined symbol, then we're still in deep
1267 trouble. */
1268 if (h->root.type != bfd_link_hash_defined)
1269 return bfd_reloc_undefined;
1270
24f13b03
ILT		 1271 sec = h->root.u.def.section;
1272 elf32_hppa_hash_table (info)->global_value = (h->root.u.def.value
b68a74d1 1273 + sec->output_section->vma
24f13b03
ILT		 1274 + sec->output_offset);
1275 elf32_hppa_hash_table (info)->global_sym_defined = 1;
1276 }
e8f2240a 1277
e8f2240a
KR		 1278 switch (r_type)
1279 {
459ae909 1280 case R_PARISC_NONE:
e8f2240a 1281 break;
4861ac76 1282
459ae909
JL		 1283 case R_PARISC_DIR32:
1284 case R_PARISC_DIR17F:
459ae909 1285 case R_PARISC_PCREL17C:
e8f2240a
KR		 1286 r_field = e_fsel;
1287 goto do_basic_type_1;
459ae909
JL		 1288 case R_PARISC_DIR21L:
1289 case R_PARISC_PCREL21L:
e8f2240a
KR		 1290 r_field = e_lrsel;
1291 goto do_basic_type_1;
459ae909
JL		 1292 case R_PARISC_DIR17R:
1293 case R_PARISC_PCREL17R:
1294 case R_PARISC_DIR14R:
1295 case R_PARISC_PCREL14R:
e8f2240a 1296 r_field = e_rrsel;
459ae909 1297 goto do_basic_type_1;
e8f2240a 1298
24f13b03
ILT		 1299 /* For all the DP relative relocations, we need to examine the symbol's
1300 section. If it's a code section, then "data pointer relative" makes
1301 no sense. In that case we don't adjust the "value", and for 21 bit
1302 addil instructions, we change the source addend register from %dp to
6cb964d4 1303 %r0. */
459ae909 1304 case R_PARISC_DPREL21L:
e8f2240a 1305 r_field = e_lrsel;
24f13b03 1306 if (sym_sec->flags & SEC_CODE)
9a688057 1307 {
c2730ba3 1308 if ((insn & 0xfc000000) >> 26 == 0xa
9a688057
JL		 1309 && (insn & 0x03e00000) >> 21 == 0x1b)
1310 insn &= ~0x03e00000;
1311 }
24f13b03
ILT		 1312 else
1313 value -= elf32_hppa_hash_table (info)->global_value;
459ae909
JL		 1314 goto do_basic_type_1;
1315 case R_PARISC_DPREL14R:
e8f2240a 1316 r_field = e_rrsel;
24f13b03
ILT		 1317 if ((sym_sec->flags & SEC_CODE) == 0)
1318 value -= elf32_hppa_hash_table (info)->global_value;
459ae909
JL		 1319 goto do_basic_type_1;
1320 case R_PARISC_DPREL14F:
e8f2240a 1321 r_field = e_fsel;
24f13b03
ILT		 1322 if ((sym_sec->flags & SEC_CODE) == 0)
1323 value -= elf32_hppa_hash_table (info)->global_value;
459ae909 1324 goto do_basic_type_1;
4861ac76 1325
24f13b03
ILT		 1326 /* These cases are separate as they may involve a lot more work
1327 to deal with linker stubs. */
1328 case R_PARISC_PLABEL32:
1329 case R_PARISC_PLABEL21L:
1330 case R_PARISC_PLABEL14R:
1331 case R_PARISC_PCREL17F:
1332 {
1333 bfd_vma location;
1334 unsigned int len, caller_args, callee_args;
1335 arg_reloc_type arg_reloc_types[5];
1336 struct elf32_hppa_args_hash_table *args_hash_table;
1337 struct elf32_hppa_args_hash_entry *args_hash;
1338 char *new_name, *stub_name;
1339
1340 /* Get the field selector right. We'll need it in a minute. */
1341 if (r_type == R_PARISC_PCREL17F
1342 || r_type == R_PARISC_PLABEL32)
1343 r_field = e_fsel;
1344 else if (r_type == R_PARISC_PLABEL21L)
1345 r_field = e_lrsel;
1346 else if (r_type == R_PARISC_PLABEL14R)
1347 r_field = e_rrsel;
1348
1349 /* Find out where we are and where we're going. */
1350 location = (offset +
1351 input_section->output_offset +
1352 input_section->output_section->vma);
1353
1354 /* Now look for the argument relocation bits associated with the
1355 target. */
1356 len = strlen (sym_name) + 1;
1357 if (is_local)
1358 len += 9;
1359 new_name = malloc (len);
1360 if (!new_name)
1361 {
1362 bfd_set_error (bfd_error_no_memory);
1363 return bfd_reloc_notsupported;
1364 }
1365 strcpy (new_name, sym_name);
e8f2240a 1366
24f13b03
ILT		 1367 /* Local symbols have unique IDs. */
1368 if (is_local)
1369 sprintf (new_name + len - 10, "_%08x", (int)sym_sec);
e8f2240a 1370
24f13b03 1371 args_hash_table = elf32_hppa_hash_table (info)->args_hash_table;
4861ac76 1372
24f13b03
ILT		 1373 args_hash = elf32_hppa_args_hash_lookup (args_hash_table,
1374 new_name, false, false);
1375 if (args_hash == NULL)
1376 callee_args = 0;
1377 else
1378 callee_args = args_hash->arg_bits;
7218bb04 1379
24f13b03
ILT		 1380 /* If this is a CALL relocation, then get the caller's bits
1381 from the addend. Else use the magic 0x155 value for PLABELS.
1382
1383 Also we don't care about the destination (value) for PLABELS. */
1384 if (r_type == R_PARISC_PCREL17F)
1385 caller_args = HPPA_R_ARG_RELOC (addend);
1386 else
1387 {
1388 caller_args = 0x155;
1389 location = value;
1390 }
1391
1392 /* Any kind of linker stub needed? */
1393 if (((int)(value - location) > 0x3ffff)
1394 || ((int)(value - location) < (int)0xfffc0000)
1395 || elf32_hppa_arg_reloc_needed (caller_args, callee_args,
1396 arg_reloc_types))
1397 {
1398 struct elf32_hppa_stub_hash_table *stub_hash_table;
1399 struct elf32_hppa_stub_hash_entry *stub_hash;
1400 asection *stub_section;
7218bb04 1401
24f13b03 1402 /* Build a name for the stub. */
f5bfdacd 1403
24f13b03
ILT		 1404 len = strlen (new_name);
1405 len += 23;
1406 stub_name = malloc (len);
1407 if (!stub_name)
1408 {
1409 bfd_set_error (bfd_error_no_memory);
1410 return bfd_reloc_notsupported;
1411 }
1412 elf32_hppa_name_of_stub (caller_args, callee_args,
1413 location, value, stub_name);
1414 strcat (stub_name, new_name);
1415 free (new_name);
1416
1417 stub_hash_table = elf32_hppa_hash_table (info)->stub_hash_table;
1418
1419 stub_hash
1420 = elf32_hppa_stub_hash_lookup (stub_hash_table, stub_name,
1421 false, false);
1422
1423 /* We're done with that name. */
1424 free (stub_name);
1425
1426 /* The stub BFD only has one section. */
1427 stub_section = stub_hash_table->stub_bfd->sections;
1428
1429 if (stub_hash != NULL)
1430 {
1431
1432 if (r_type == R_PARISC_PCREL17F)
1433 {
1434 unsigned long delay_insn;
1435 unsigned int opcode, rtn_reg, ldo_target_reg, ldo_src_reg;
1436
1437 /* We'll need to peek at the next insn. */
1438 delay_insn = bfd_get_32 (input_bfd, hit_data + 4);
1439 opcode = get_opcode (delay_insn);
1440
1441 /* We also need to know the return register for this
1442 call. */
1443 rtn_reg = (insn & 0x03e00000) >> 21;
1444
1445 ldo_src_reg = (delay_insn & 0x03e00000) >> 21;
1446 ldo_target_reg = (delay_insn & 0x001f0000) >> 16;
1447
1448 /* Munge up the value and other parameters for
1449 hppa_elf_relocate_insn. */
1450
1451 value = (stub_hash->offset
1452 + stub_section->output_offset
1453 + stub_section->output_section->vma);
1454
1455 r_format = 17;
1456 r_field = e_fsel;
1457 r_pcrel = 0;
1458 addend = 0;
1459
1460 /* We need to peek at the delay insn and determine if
1461 we'll need to swap the branch and its delay insn. */
1462 if ((insn & 2)
1463 || (opcode == LDO
1464 && ldo_target_reg == rtn_reg)
1465 || (delay_insn == 0x08000240))
1466 {
1467 /* No need to swap the branch and its delay slot, but
1468 we do need to make sure to jump past the return
1469 pointer update in the stub. */
1470 value += 4;
1471
1472 /* If the delay insn does a return pointer adjustment,
1473 then we have to make sure it stays valid. */
1474 if (opcode == LDO
1475 && ldo_target_reg == rtn_reg)
1476 {
1477 delay_insn &= 0xfc00ffff;
1478 delay_insn |= ((31 << 21) | (31 << 16));
1479 bfd_put_32 (input_bfd, delay_insn, hit_data + 4);
1480 }
1481 /* Use a BLE to reach the stub. */
1482 insn = BLE_SR4_R0;
1483 }
1484 else
1485 {
1486 /* Wonderful, we have to swap the call insn and its
1487 delay slot. */
1488 bfd_put_32 (input_bfd, delay_insn, hit_data);
1489 /* Use a BLE,n to reach the stub. */
1490 insn = (BLE_SR4_R0 | 0x2);
1491 bfd_put_32 (input_bfd, insn, hit_data + 4);
1492 insn = hppa_elf_relocate_insn (input_bfd,
1493 input_section,
1494 insn, offset + 4,
1495 value, addend,
1496 r_format, r_field,
1497 r_pcrel);
1498 /* Update the instruction word. */
1499 bfd_put_32 (input_bfd, insn, hit_data + 4);
1500 return bfd_reloc_dangerous;
1501 }
1502 }
1503 else
1504 {
1505 /* PLABEL stuff is easy. */
1506
1507 value = (stub_hash->offset
1508 + stub_section->output_offset
1509 + stub_section->output_section->vma);
1510 /* We don't need the RP adjustment for PLABELs. */
1511 value += 4;
1512 if (r_type == R_PARISC_PLABEL32)
1513 r_format = 32;
1514 else if (r_type == R_PARISC_PLABEL21L)
1515 r_format = 21;
1516 else if (r_type == R_PARISC_PLABEL14R)
1517 r_format = 14;
1518
1519 r_pcrel = 0;
1520 addend = 0;
1521 }
7218bb04 1522 }
4861ac76 1523 else
24f13b03
ILT		 1524 return bfd_reloc_notsupported;
1525 }
1526 goto do_basic_type_1;
1527 }
1528
1529do_basic_type_1:
1530 insn = hppa_elf_relocate_insn (input_bfd, input_section, insn,
1531 offset, value, addend, r_format,
1532 r_field, r_pcrel);
d9ad93bc 1533 break;
24f13b03 1534
f5bfdacd 1535 /* Something we don't know how to handle. */
e8f2240a 1536 default:
f5bfdacd 1537 return bfd_reloc_notsupported;
e8f2240a
KR		 1538 }
1539
4861ac76 1540 /* Update the instruction word. */
24f13b03 1541 bfd_put_32 (input_bfd, insn, hit_data);
e8f2240a 1542 return (bfd_reloc_ok);
e8f2240a
KR		 1543}
1544
f5bfdacd
JL		 1545/* Return the address of the howto table entry to perform the CODE
1546 relocation for an ARCH machine. */
1547
31dabb6c 1548static reloc_howto_type *
7ed5e970
ILT		 1549elf_hppa_reloc_type_lookup (abfd, code)
1550 bfd *abfd;
e8f2240a
KR		 1551 bfd_reloc_code_real_type code;
1552{
459ae909 1553 if ((int) code < (int) R_PARISC_UNIMPLEMENTED)
e8f2240a
KR		 1554 {
1555 BFD_ASSERT ((int) elf_hppa_howto_table[(int) code].type == (int) code);
1556 return &elf_hppa_howto_table[(int) code];
1557 }
f5bfdacd 1558 return NULL;
e8f2240a
KR		 1559}
1560
25057836
JL		 1561/* Return true if SYM represents a local label symbol. */
1562
1563static boolean
1564hppa_elf_is_local_label (abfd, sym)
1565 bfd *abfd;
1566 asymbol *sym;
1567{
1568 return (sym->name[0] == 'L' && sym->name[1] == '$');
1569}
e8f2240a 1570
459ae909
JL		 1571/* Do any backend specific processing when beginning to write an object
1572 file. For PA ELF we need to determine the size of the symbol extension
1573 section *before* any other output processing happens. */
1574
1575static void
24f13b03 1576elf32_hppa_backend_begin_write_processing (abfd, info)
459ae909 1577 bfd *abfd;
24f13b03 1578 struct bfd_link_info *info;
459ae909 1579{
24f13b03 1580 unsigned int i;
459ae909
JL		 1581 asection *symextn_sec;
1582
24f13b03
ILT		 1583 /* Size up the symbol extension section. */
1584 if ((abfd->outsymbols == NULL
1585 && info == NULL)
1586 || symext_chain_size != 0)
459ae909
JL		 1587 return;
1588
24f13b03 1589 if (info == NULL)
459ae909 1590 {
24f13b03
ILT		 1591 /* We were not called from the BFD ELF linker code, so we need
1592 to examine the output BFD's outsymbols.
459ae909 1593
24f13b03
ILT		 1594 Note we can not build the symbol extensions now as the symbol
1595 map hasn't been set up. */
1596 for (i = 0; i < abfd->symcount; i++)
1597 {
1598 elf_symbol_type *symbol = (elf_symbol_type *)abfd->outsymbols[i];
459ae909 1599
24f13b03
ILT		 1600 /* Only functions ever need an entry in the symbol extension
1601 section. */
1602 if (!(symbol->symbol.flags & BSF_FUNCTION))
1603 continue;
1604
1605 /* And only if they specify the locations of their arguments. */
1606 if (symbol->tc_data.hppa_arg_reloc == 0)
1607 continue;
1608
1609 /* Yup. This function symbol needs an entry. */
b68a74d1 1610 symext_chain_size += 2 * ELF32_PARISC_SX_SIZE;
24f13b03
ILT		 1611 }
1612 }
1613 else if (info->relocateable == true)
1614 {
1615 struct elf32_hppa_args_hash_table *table;
1616 table = elf32_hppa_hash_table (info)->args_hash_table;
459ae909 1617
24f13b03
ILT		 1618 /* Determine the size of the symbol extension section. */
1619 elf32_hppa_args_hash_traverse (table,
1620 elf32_hppa_size_symext,
1621 &symext_chain_size);
459ae909
JL		 1622 }
1623
1624 /* Now create the section and set its size. We'll fill in the
1625 contents later. */
1626 symextn_sec = bfd_get_section_by_name (abfd, SYMEXTN_SECTION_NAME);
1627 if (symextn_sec == NULL)
24f13b03
ILT		 1628 symextn_sec = bfd_make_section (abfd, SYMEXTN_SECTION_NAME);
1629
1630 bfd_set_section_flags (abfd, symextn_sec,
1631 SEC_LOAD | SEC_HAS_CONTENTS | SEC_DATA);
1632 symextn_sec->output_section = symextn_sec;
1633 symextn_sec->output_offset = 0;
1634 bfd_set_section_alignment (abfd, symextn_sec, 2);
1635 bfd_set_section_size (abfd, symextn_sec, symext_chain_size);
1636}
1637
1638/* Called for each entry in the args location hash table. For each
1639 entry we bump the size pointer by 2 records (16 bytes). */
1640
1641static boolean
1642elf32_hppa_size_symext (gen_entry, in_args)
1643 struct bfd_hash_entry *gen_entry;
1644 PTR in_args;
1645{
b68a74d1 1646 bfd_size_type *sizep = (bfd_size_type *)in_args;
24f13b03 1647
b68a74d1 1648 *sizep += 2 * ELF32_PARISC_SX_SIZE;
24f13b03
ILT		 1649 return true;
1650}
1651
1652/* Backend routine called by the linker for each output symbol.
1653
1654 For PA ELF we use this opportunity to add an appropriate entry
1655 to the symbol extension chain for function symbols. */
1656
1657static boolean
1658elf32_hppa_link_output_symbol_hook (abfd, info, name, sym, section)
1659 bfd *abfd;
1660 struct bfd_link_info *info;
1661 const char *name;
1662 Elf_Internal_Sym *sym;
1663 asection *section;
1664{
1665 char *new_name;
1666 unsigned int len, index;
1667 struct elf32_hppa_args_hash_table *args_hash_table;
1668 struct elf32_hppa_args_hash_entry *args_hash;
1669
1670 /* If the args hash table is NULL, then we've encountered an error
1671 of some sorts (for example, an undefined symbol). In that case
1672 we've got nothing else to do.
1673
1674 NOTE: elf_link_output_symbol will abort if we return false here! */
1675 if (elf32_hppa_hash_table (info)->args_hash_table == NULL)
1676 return true;
1677
1678 index = elf32_hppa_hash_table (info)->output_symbol_count++;
1679
1680 /* We need to look up this symbol in the args hash table to see if
1681 it has argument relocation bits. */
1682 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
1683 return true;
1684
1685 /* We know it's a function symbol of some kind. */
1686 len = strlen (name) + 1;
1687 if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
1688 len += 9;
1689
1690 new_name = malloc (len);
1691 if (new_name == NULL)
459ae909 1692 {
24f13b03
ILT		 1693 bfd_set_error (bfd_error_no_memory);
1694 return false;
459ae909
JL		 1695 }
1696
24f13b03
ILT		 1697 strcpy (new_name, name);
1698 if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
1699 sprintf (new_name + len - 10, "_%08x", (int)section);
1700
1701 /* Now that we have the unique name, we can look it up in the
1702 args hash table. */
1703 args_hash_table = elf32_hppa_hash_table (info)->args_hash_table;
1704 args_hash = elf32_hppa_args_hash_lookup (args_hash_table, new_name,
1705 false, false);
1706 free (new_name);
1707 if (args_hash == NULL)
1708 return true;
1709
1710 /* We know this symbol has arg reloc bits. */
1711 add_entry_to_symext_chain (abfd, args_hash->arg_bits,
1712 index, &symext_rootP, &symext_lastP);
1713 return true;
459ae909
JL		 1714}
1715
1716/* Perform any processing needed late in the object file writing process.
1717 For PA ELF we build and set the contents of the symbol extension
1718 section. */
1719
1720static void
24f13b03 1721elf32_hppa_backend_final_write_processing (abfd, linker)
459ae909 1722 bfd *abfd;
24f13b03 1723 boolean linker;
459ae909
JL		 1724{
1725 asection *symextn_sec;
b68a74d1 1726 unsigned int i;
459ae909
JL		 1727
1728 /* Now build the symbol extension section. */
1729 if (symext_chain_size == 0)
24f13b03 1730 return;
459ae909 1731
24f13b03 1732 if (! linker)
459ae909 1733 {
24f13b03
ILT		 1734 /* We were not called from the backend linker, so we still need
1735 to build the symbol extension chain.
459ae909 1736
24f13b03
ILT		 1737 Look at each symbol, adding the appropriate information to the
1738 symbol extension section list as necessary. */
1739 for (i = 0; i < abfd->symcount; i++)
1740 {
1741 elf_symbol_type *symbol = (elf_symbol_type *) abfd->outsymbols[i];
459ae909 1742
24f13b03
ILT		 1743 /* Only functions ever need an entry in the symbol extension
1744 section. */
1745 if (!(symbol->symbol.flags & BSF_FUNCTION))
1746 continue;
1747
1748 /* And only if they specify the locations of their arguments. */
1749 if (symbol->tc_data.hppa_arg_reloc == 0)
1750 continue;
459ae909 1751
24f13b03
ILT		 1752 /* Add this symbol's information to the chain. */
1753 add_entry_to_symext_chain (abfd, symbol->tc_data.hppa_arg_reloc,
b68a74d1 1754 symbol->symbol.udata.i, &symext_rootP,
24f13b03
ILT		 1755 &symext_lastP);
1756 }
459ae909
JL		 1757 }
1758
24f13b03 1759 /* Now fill in the contents of the symbol extension section. */
459ae909
JL		 1760 elf_hppa_tc_make_sections (abfd, symext_rootP);
1761
1762 /* And attach that as the section's contents. */
1763 symextn_sec = bfd_get_section_by_name (abfd, SYMEXTN_SECTION_NAME);
1764 if (symextn_sec == (asection *) 0)
1765 abort();
1766
1767 symextn_sec->contents = (void *)symextn_contents;
24f13b03
ILT		 1768
1769 bfd_set_section_contents (abfd, symextn_sec, symextn_sec->contents,
459ae909
JL		 1770 symextn_sec->output_offset, symextn_sec->_raw_size);
1771}
1772
f5bfdacd
JL		 1773/* Update the symbol extention chain to include the symbol pointed to
1774 by SYMBOLP if SYMBOLP is a function symbol. Used internally and by GAS. */
e8f2240a 1775
459ae909 1776static void
24f13b03 1777add_entry_to_symext_chain (abfd, arg_reloc, sym_idx, symext_root, symext_last)
f4bd7a8f 1778 bfd *abfd;
24f13b03
ILT		 1779 unsigned int arg_reloc;
1780 unsigned int sym_idx;
f5bfdacd
JL		 1781 symext_chainS **symext_root;
1782 symext_chainS **symext_last;
e8f2240a
KR		 1783{
1784 symext_chainS *symextP;
3a70b01d 1785
f5bfdacd 1786 /* Allocate memory and initialize this entry. */
e8f2240a 1787 symextP = (symext_chainS *) bfd_alloc (abfd, sizeof (symext_chainS) * 2);
9783e04a
DM		 1788 if (!symextP)
1789 {
f5bfdacd 1790 bfd_set_error (bfd_error_no_memory);
9783e04a
DM		 1791 abort(); /* FIXME */
1792 }
e8f2240a 1793
459ae909 1794 symextP[0].entry = ELF32_PARISC_SX_WORD (PARISC_SXT_SYMNDX, sym_idx);
e8f2240a
KR		 1795 symextP[0].next = &symextP[1];
1796
459ae909 1797 symextP[1].entry = ELF32_PARISC_SX_WORD (PARISC_SXT_ARG_RELOC, arg_reloc);
e8f2240a
KR		 1798 symextP[1].next = NULL;
1799
f5bfdacd
JL		 1800 /* Now update the chain itself so it can be walked later to build
1801 the symbol extension section. */
1802 if (*symext_root == NULL)
e8f2240a 1803 {
f5bfdacd
JL		 1804 *symext_root = &symextP[0];
1805 *symext_last = &symextP[1];
e8f2240a
KR		 1806 }
1807 else
1808 {
f5bfdacd
JL		 1809 (*symext_last)->next = &symextP[0];
1810 *symext_last = &symextP[1];
e8f2240a
KR		 1811 }
1812}
1813
24f13b03 1814/* Build the symbol extension section. */
e8f2240a 1815
459ae909 1816static void
f5bfdacd 1817elf_hppa_tc_make_sections (abfd, symext_root)
f4bd7a8f 1818 bfd *abfd;
f5bfdacd 1819 symext_chainS *symext_root;
e8f2240a
KR		 1820{
1821 symext_chainS *symextP;
24f13b03 1822 unsigned int i;
e8f2240a
KR		 1823 asection *symextn_sec;
1824
e8f2240a 1825 symextn_sec = bfd_get_section_by_name (abfd, SYMEXTN_SECTION_NAME);
f5bfdacd
JL		 1826
1827 /* Grab some memory for the contents of the symbol extension section
1828 itself. */
b68a74d1
JL		 1829 symextn_contents = (bfd_byte *) bfd_zalloc (abfd,
1830 symextn_sec->_raw_size);
9783e04a
DM		 1831 if (!symextn_contents)
1832 {
f5bfdacd 1833 bfd_set_error (bfd_error_no_memory);
9783e04a
DM		 1834 abort(); /* FIXME */
1835 }
e8f2240a 1836
459ae909 1837 /* Fill in the contents of the symbol extension chain. */
f5bfdacd 1838 for (i = 0, symextP = symext_root; symextP; symextP = symextP->next, ++i)
b68a74d1
JL		 1839 ELF32_PARISC_SX_PUT (abfd, (bfd_vma) symextP->entry,
1840 symextn_contents + i * ELF32_PARISC_SX_SIZE);
e8f2240a
KR		 1841
1842 return;
1843}
1844
24f13b03
ILT		 1845/* Do some PA ELF specific work after reading in the symbol table.
1846 In particular attach the argument relocation from the
1847 symbol extension section to the appropriate symbols. */
e8f2240a 1848
24f13b03
ILT		 1849static boolean
1850elf32_hppa_backend_symbol_table_processing (abfd, esyms,symcnt)
e8f2240a 1851 bfd *abfd;
24f13b03
ILT		 1852 elf_symbol_type *esyms;
1853 int symcnt;
e8f2240a 1854{
24f13b03
ILT		 1855 Elf32_Internal_Shdr *symextn_hdr =
1856 bfd_elf_find_section (abfd, SYMEXTN_SECTION_NAME);
1857 unsigned int i, current_sym_idx = 0;
1858
1859 /* If no symbol extension existed, then all symbol extension information
1860 is assumed to be zero. */
1861 if (symextn_hdr == NULL)
e8f2240a 1862 {
24f13b03
ILT		 1863 for (i = 0; i < symcnt; i++)
1864 esyms[i].tc_data.hppa_arg_reloc = 0;
1865 return (true);
1866 }
e8f2240a 1867
24f13b03
ILT		 1868 /* FIXME: Why not use bfd_get_section_contents here? Also should give
1869 memory back when we're done. */
1870 /* Allocate a buffer of the appropriate size for the symextn section. */
1871 symextn_hdr->contents = bfd_zalloc(abfd,symextn_hdr->sh_size);
1872 if (!symextn_hdr->contents)
1873 {
1874 bfd_set_error (bfd_error_no_memory);
1875 return false;
e8f2240a 1876 }
e8f2240a 1877
24f13b03
ILT		 1878 /* Read in the symextn section. */
1879 if (bfd_seek (abfd, symextn_hdr->sh_offset, SEEK_SET) == -1)
1880 return false;
b68a74d1
JL		 1881 if (bfd_read ((PTR) symextn_hdr->contents, 1, symextn_hdr->sh_size, abfd)
1882 != symextn_hdr->sh_size)
24f13b03 1883 return false;
e8f2240a 1884
24f13b03
ILT		 1885 /* Parse entries in the symbol extension section, updating the symtab
1886 entries as we go */
b68a74d1 1887 for (i = 0; i < symextn_hdr->sh_size / ELF32_PARISC_SX_SIZE; i++)
24f13b03 1888 {
b68a74d1
JL		 1889 symext_entryS se =
1890 ELF32_PARISC_SX_GET (abfd,
1891 (symextn_hdr->contents
1892 + i * ELF32_PARISC_SX_SIZE));
1893 unsigned int se_value = ELF32_PARISC_SX_VAL (se);
1894 unsigned int se_type = ELF32_PARISC_SX_TYPE (se);
e8f2240a 1895
24f13b03
ILT		 1896 switch (se_type)
1897 {
1898 case PARISC_SXT_NULL:
1899 break;
e8f2240a 1900
24f13b03
ILT		 1901 case PARISC_SXT_SYMNDX:
1902 if (se_value >= symcnt)
1903 {
1904 bfd_set_error (bfd_error_bad_value);
1905 return (false);
1906 }
1907 current_sym_idx = se_value - 1;
1908 break;
1909
1910 case PARISC_SXT_ARG_RELOC:
1911 esyms[current_sym_idx].tc_data.hppa_arg_reloc = se_value;
1912 break;
1913
1914 default:
1915 bfd_set_error (bfd_error_bad_value);
1916 return (false);
1917 }
e8f2240a 1918 }
24f13b03 1919 return (true);
e8f2240a
KR		 1920}
1921
24f13b03
ILT		 1922/* Read and attach the symbol extension information for the symbols
1923 in INPUT_BFD to the argument location hash table. Handle locals
1924 if DO_LOCALS is true; likewise for globals when DO_GLOBALS is true. */
1925
1926static boolean
5874427f 1927elf32_hppa_read_symext_info (input_bfd, symtab_hdr, args_hash_table, local_syms)
24f13b03
ILT		 1928 bfd *input_bfd;
1929 Elf_Internal_Shdr *symtab_hdr;
1930 struct elf32_hppa_args_hash_table *args_hash_table;
1931 Elf_Internal_Sym *local_syms;
e8f2240a 1932{
24f13b03 1933 asection *symextn_sec;
b68a74d1 1934 bfd_byte *contents;
24f13b03 1935 unsigned int i, n_entries, current_index = 0;
e8f2240a 1936
24f13b03
ILT		 1937 /* Get the symbol extension section for this BFD. If no section exists
1938 then there's nothing to do. Likewise if the section exists, but
1939 has no contents. */
1940 symextn_sec = bfd_get_section_by_name (input_bfd, SYMEXTN_SECTION_NAME);
1941 if (symextn_sec == NULL)
1942 return true;
e8f2240a 1943
24f13b03
ILT		 1944 /* Done separately so we can turn off SEC_HAS_CONTENTS (see below). */
1945 if (symextn_sec->_raw_size == 0)
3a70b01d 1946 {
24f13b03
ILT		 1947 symextn_sec->flags &= ~SEC_HAS_CONTENTS;
1948 return true;
3a70b01d 1949 }
24f13b03 1950
b68a74d1 1951 contents = (bfd_byte *) malloc (symextn_sec->_raw_size);
24f13b03 1952 if (contents == NULL)
3a70b01d 1953 {
f5bfdacd 1954 bfd_set_error (bfd_error_no_memory);
24f13b03 1955 return false;
3a70b01d 1956 }
e8f2240a 1957
24f13b03
ILT		 1958 /* How gross. We turn off SEC_HAS_CONTENTS for the input symbol extension
1959 sections to keep the generic ELF/BFD code from trying to do anything
1960 with them. We have to undo that hack temporarily so that we can read
1961 in the contents with the generic code. */
1962 symextn_sec->flags |= SEC_HAS_CONTENTS;
1963 if (bfd_get_section_contents (input_bfd, symextn_sec, contents,
1964 0, symextn_sec->_raw_size) == false)
3a70b01d 1965 {
24f13b03
ILT		 1966 symextn_sec->flags &= ~SEC_HAS_CONTENTS;
1967 free (contents);
1968 return false;
3a70b01d
KR		 1969 }
1970
24f13b03
ILT		 1971 /* Gross. Turn off SEC_HAS_CONTENTS for the input symbol extension
1972 sections (see above). */
1973 symextn_sec->flags &= ~SEC_HAS_CONTENTS;
e8f2240a 1974
b68a74d1 1975 n_entries = symextn_sec->_raw_size / ELF32_PARISC_SX_SIZE;
24f13b03 1976 for (i = 0; i < n_entries; i++)
e8f2240a 1977 {
b68a74d1
JL		 1978 symext_entryS entry =
1979 ELF32_PARISC_SX_GET (input_bfd, contents + i * ELF32_PARISC_SX_SIZE);
24f13b03
ILT		 1980 unsigned int value = ELF32_PARISC_SX_VAL (entry);
1981 unsigned int type = ELF32_PARISC_SX_TYPE (entry);
1982 struct elf32_hppa_args_hash_entry *args_hash;
e8f2240a 1983
24f13b03 1984 switch (type)
e8f2240a 1985 {
24f13b03
ILT		 1986 case PARISC_SXT_NULL:
1987 break;
e8f2240a 1988
24f13b03
ILT		 1989 case PARISC_SXT_SYMNDX:
1990 if (value >= symtab_hdr->sh_size / sizeof (Elf32_External_Sym))
80425e6c 1991 {
24f13b03
ILT		 1992 bfd_set_error (bfd_error_bad_value);
1993 free (contents);
1994 return false;
80425e6c 1995 }
24f13b03
ILT		 1996 current_index = value;
1997 break;
e8f2240a 1998
24f13b03 1999 case PARISC_SXT_ARG_RELOC:
5874427f 2000 if (current_index < symtab_hdr->sh_info)
326e32d7 2001 {
24f13b03
ILT		 2002 Elf_Internal_Shdr *hdr;
2003 char *new_name;
2004 const char *sym_name;
2005 asection *sym_sec;
2006 unsigned int len;
2007
2008 hdr = elf_elfsections (input_bfd)[local_syms[current_index].st_shndx];
2009 sym_sec = hdr->bfd_section;
ede4eed4 2010 sym_name = bfd_elf_string_from_elf_section (input_bfd,
24f13b03
ILT		 2011 symtab_hdr->sh_link,
2012 local_syms[current_index].st_name);
2013 len = strlen (sym_name) + 10;
2014 new_name = malloc (len);
2015 if (new_name == NULL)
2016 {
2017 bfd_set_error (bfd_error_no_memory);
2018 free (contents);
2019 return false;
2020 }
2021 strcpy (new_name, sym_name);
2022 sprintf (new_name + len - 10, "_%08x", (int)sym_sec);
2023
2024 /* This is a global symbol with argument location info.
2025 We need to enter it into the hash table. */
2026 args_hash = elf32_hppa_args_hash_lookup (args_hash_table,
2027 new_name, true,
2028 true);
2029 free (new_name);
2030 if (args_hash == NULL)
2031 {
2032 free (contents);
2033 return false;
2034 }
2035 args_hash->arg_bits = value;
2036 break;
326e32d7 2037 }
5874427f 2038 else if (current_index >= symtab_hdr->sh_info)
e8f2240a 2039 {
24f13b03
ILT		 2040 struct elf_link_hash_entry *h;
2041
2042 current_index -= symtab_hdr->sh_info;
2043 h = elf_sym_hashes(input_bfd)[current_index];
2044 /* This is a global symbol with argument location
2045 information. We need to enter it into the hash table. */
2046 args_hash = elf32_hppa_args_hash_lookup (args_hash_table,
2047 h->root.root.string,
2048 true, true);
2049 if (args_hash == NULL)
e8f2240a 2050 {
24f13b03
ILT		 2051 bfd_set_error (bfd_error_bad_value);
2052 free (contents);
2053 return false;
e8f2240a 2054 }
24f13b03
ILT		 2055 args_hash->arg_bits = value;
2056 break;
e8f2240a 2057 }
24f13b03
ILT		 2058 else
2059 break;
e8f2240a 2060
24f13b03
ILT		 2061 default:
2062 bfd_set_error (bfd_error_bad_value);
2063 free (contents);
2064 return false;
e8f2240a
KR		 2065 }
2066 }
24f13b03
ILT		 2067 free (contents);
2068 return true;
e8f2240a
KR		 2069}
2070
24f13b03
ILT		 2071/* Undo the generic ELF code's subtraction of section->vma from the
2072 value of each external symbol. */
d9ad93bc 2073
24f13b03
ILT		 2074static boolean
2075elf32_hppa_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2076 bfd *abfd;
2077 struct bfd_link_info *info;
2078 const Elf_Internal_Sym *sym;
2079 const char **namep;
2080 flagword *flagsp;
2081 asection **secp;
2082 bfd_vma *valp;
d9ad93bc 2083{
24f13b03
ILT		 2084 *valp += (*secp)->vma;
2085 return true;
e8f2240a
KR		 2086}
2087
24f13b03
ILT		 2088/* Determine the name of the stub needed to perform a call assuming the
2089 argument relocation bits for caller and callee are in CALLER and CALLEE
2090 for a call from LOCATION to DESTINATION. Copy the name into STUB_NAME. */
e08b9ad7 2091
24f13b03
ILT		 2092static void
2093elf32_hppa_name_of_stub (caller, callee, location, destination, stub_name)
2094 unsigned int caller, callee;
2095 bfd_vma location, destination;
2096 char *stub_name;
e8f2240a 2097{
24f13b03 2098 arg_reloc_type arg_reloc_types[5];
e08b9ad7 2099
24f13b03 2100 if (elf32_hppa_arg_reloc_needed (caller, callee, arg_reloc_types))
e8f2240a 2101 {
24f13b03
ILT		 2102 arg_reloc_location i;
2103 /* Fill in the basic template. */
2104 strcpy (stub_name, "__XX_XX_XX_XX_XX_stub_");
e8f2240a 2105
24f13b03
ILT		 2106 /* Now fix the specifics. */
2107 for (i = ARG0; i <= RET; i++)
2108 switch (arg_reloc_types[i])
2109 {
2110 case NO:
2111 stub_name[3 * i + 2] = 'N';
2112 stub_name[3 * i + 3] = 'O';
2113 break;
2114 case GF:
2115 stub_name[3 * i + 2] = 'G';
2116 stub_name[3 * i + 3] = 'F';
2117 break;
2118 case FG:
2119 stub_name[3 * i + 2] = 'F';
2120 stub_name[3 * i + 3] = 'G';
2121 break;
2122 case GD:
2123 stub_name[3 * i + 2] = 'G';
2124 stub_name[3 * i + 3] = 'D';
2125 break;
2126 case DG:
2127 stub_name[3 * i + 2] = 'D';
2128 stub_name[3 * i + 3] = 'G';
2129 break;
2130 }
e08b9ad7 2131 }
e08b9ad7 2132 else
24f13b03
ILT		 2133 strcpy (stub_name, "_____long_branch_stub_");
2134}
e08b9ad7 2135
24f13b03
ILT		 2136/* Determine if an argument relocation stub is needed to perform a
2137 call assuming the argument relocation bits for caller and callee
2138 are in CALLER and CALLEE. Place the type of relocations (if any)
2139 into stub_types_p. */
e8f2240a 2140
24f13b03
ILT		 2141static boolean
2142elf32_hppa_arg_reloc_needed (caller, callee, stub_types)
2143 unsigned int caller, callee;
2144 arg_reloc_type stub_types[5];
2145{
2146 /* Special case for no relocations. */
2147 if (caller == 0 || callee == 0)
2148 return 0;
3a70b01d
KR		 2149 else
2150 {
24f13b03
ILT		 2151 arg_location caller_loc[5];
2152 arg_location callee_loc[5];
2153
2154 /* Extract the location information for the argument and return
2155 value on both the caller and callee sides. */
2156 caller_loc[ARG0] = EXTRACT_ARBITS (caller, ARG0);
2157 callee_loc[ARG0] = EXTRACT_ARBITS (callee, ARG0);
2158 caller_loc[ARG1] = EXTRACT_ARBITS (caller, ARG1);
2159 callee_loc[ARG1] = EXTRACT_ARBITS (callee, ARG1);
2160 caller_loc[ARG2] = EXTRACT_ARBITS (caller, ARG2);
2161 callee_loc[ARG2] = EXTRACT_ARBITS (callee, ARG2);
2162 caller_loc[ARG3] = EXTRACT_ARBITS (caller, ARG3);
2163 callee_loc[ARG3] = EXTRACT_ARBITS (callee, ARG3);
2164 caller_loc[RET] = EXTRACT_ARBITS (caller, RET);
2165 callee_loc[RET] = EXTRACT_ARBITS (callee, RET);
2166
2167 /* Check some special combinations. This is necessary to
2168 deal with double precision FP arguments. */
2169 if (caller_loc[ARG0] == AR_FU || caller_loc[ARG1] == AR_FU)
9783e04a 2170 {
24f13b03
ILT		 2171 caller_loc[ARG0] = AR_FPDBL1;
2172 caller_loc[ARG1] = AR_NO;
9783e04a 2173 }
24f13b03 2174 if (caller_loc[ARG2] == AR_FU || caller_loc[ARG3] == AR_FU)
9783e04a 2175 {
24f13b03
ILT		 2176 caller_loc[ARG2] = AR_FPDBL2;
2177 caller_loc[ARG3] = AR_NO;
9783e04a 2178 }
24f13b03 2179 if (callee_loc[ARG0] == AR_FU || callee_loc[ARG1] == AR_FU)
6e58a4e5 2180 {
24f13b03
ILT		 2181 callee_loc[ARG0] = AR_FPDBL1;
2182 callee_loc[ARG1] = AR_NO;
6e58a4e5 2183 }
24f13b03 2184 if (callee_loc[ARG2] == AR_FU || callee_loc[ARG3] == AR_FU)
3a70b01d 2185 {
24f13b03
ILT		 2186 callee_loc[ARG2] = AR_FPDBL2;
2187 callee_loc[ARG3] = AR_NO;
2188 }
e8f2240a 2189
24f13b03
ILT		 2190 /* Now look up any relocation needed for each argument and the
2191 return value. */
2192 stub_types[ARG0] = arg_mismatches[caller_loc[ARG0]][callee_loc[ARG0]];
2193 stub_types[ARG1] = arg_mismatches[caller_loc[ARG1]][callee_loc[ARG1]];
2194 stub_types[ARG2] = arg_mismatches[caller_loc[ARG2]][callee_loc[ARG2]];
2195 stub_types[ARG3] = arg_mismatches[caller_loc[ARG3]][callee_loc[ARG3]];
2196 stub_types[RET] = ret_mismatches[caller_loc[RET]][callee_loc[RET]];
2197
2198 return (stub_types[ARG0] != NO
2199 || stub_types[ARG1] != NO
2200 || stub_types[ARG2] != NO
2201 || stub_types[ARG3] != NO
2202 || stub_types[RET] != NO);
2203 }
2204}
4861ac76 2205
24f13b03
ILT		 2206/* Compute the size of the stub needed to call from LOCATION to DESTINATION
2207 (a function named SYM_NAME), with argument relocation bits CALLER and
2208 CALLEE. Return zero if no stub is needed to perform such a call. */
e08b9ad7 2209
24f13b03
ILT		 2210static unsigned int
2211elf32_hppa_size_of_stub (callee, caller, location, destination, sym_name)
2212 unsigned int callee, caller;
2213 bfd_vma location, destination;
2214 const char *sym_name;
2215{
2216 arg_reloc_type arg_reloc_types[5];
2217
2218 /* Determine if a long branch or argument relocation stub is needed.
2219 If an argument relocation stub is needed, the relocation will be
2220 stored into arg_reloc_types. */
2221 if (!(((int)(location - destination) > 0x3ffff)
2222 || ((int)(location - destination) < (int)0xfffc0000)
2223 || elf32_hppa_arg_reloc_needed (caller, callee, arg_reloc_types)))
2224 return 0;
e08b9ad7 2225
24f13b03
ILT		 2226 /* Some kind of stub is needed. Determine how big it needs to be.
2227 First check for argument relocation stubs as they also handle
2228 long calls. Then check for long calls to millicode and finally
2229 the normal long calls. */
2230 if (arg_reloc_types[ARG0] != NO
2231 || arg_reloc_types[ARG1] != NO
2232 || arg_reloc_types[ARG2] != NO
2233 || arg_reloc_types[ARG3] != NO
2234 || arg_reloc_types[RET] != NO)
2235 {
2236 /* Some kind of argument relocation stub is needed. */
2237 unsigned int len = 16;
2238 arg_reloc_location i;
2239
2240 /* Each GR or FG relocation takes 2 insns, each GD or DG
2241 relocation takes 3 insns. Plus 4 more insns for the
2242 RP adjustment, ldil & (be | ble) and copy. */
2243 for (i = ARG0; i <= RET; i++)
2244 switch (arg_reloc_types[i])
2245 {
2246 case GF:
2247 case FG:
2248 len += 8;
2249 break;
e08b9ad7 2250
24f13b03
ILT		 2251 case GD:
2252 case DG:
2253 len += 12;
2254 break;
e08b9ad7 2255
24f13b03
ILT		 2256 default:
2257 break;
2258 }
2259
2260 /* Extra instructions are needed if we're relocating a return value. */
2261 if (arg_reloc_types[RET] != NO)
2262 len += 12;
2263
2264 return len;
2265 }
2266 else if (!strncmp ("$$", sym_name, 2)
2267 && strcmp ("$$dyncall", sym_name))
2268 return 12;
2269 else
2270 return 16;
2271}
e08b9ad7 2272
24f13b03
ILT		 2273/* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
2274 IN_ARGS contains the stub BFD and link info pointers. */
2275
2276static boolean
2277elf32_hppa_build_one_stub (gen_entry, in_args)
2278 struct bfd_hash_entry *gen_entry;
2279 PTR in_args;
2280{
2281 void **args = (void **)in_args;
2282 bfd *stub_bfd = (bfd *)args[0];
2283 struct bfd_link_info *info = (struct bfd_link_info *)args[1];
2284 struct elf32_hppa_stub_hash_entry *entry;
2285 struct elf32_hppa_stub_hash_table *stub_hash_table;
2286 bfd_byte *loc;
2287 symvalue sym_value;
2288 const char *sym_name;
2289
2290 /* Initialize pointers to the stub hash table, the particular entry we
2291 are building a stub for, and where (in memory) we should place the stub
2292 instructions. */
2293 entry = (struct elf32_hppa_stub_hash_entry *)gen_entry;
2294 stub_hash_table = elf32_hppa_hash_table(info)->stub_hash_table;
2295 loc = stub_hash_table->location;
2296
2297 /* Make a note of the offset within the stubs for this entry. */
2298 entry->offset = stub_hash_table->offset;
2299
2300 /* The symbol's name starts at offset 22. */
2301 sym_name = entry->root.string + 22;
2302
2303 sym_value = (entry->target_value
2304 + entry->target_section->output_offset
2305 + entry->target_section->output_section->vma);
2306
2307 if (strncmp ("_____long_branch_stub_", entry->root.string, 22))
2308 {
2309 /* This must be an argument or return value relocation stub. */
2310 unsigned long insn;
2311 arg_reloc_location i;
2312 bfd_byte *begin_loc = loc;
2313
2314 /* First the return pointer adjustment. Depending on exact calling
2315 sequence this instruction may be skipped. */
2316 bfd_put_32 (stub_bfd, LDO_M4_R31_R31, loc);
2317 loc += 4;
2318
2319 /* If we are relocating a return value, then we're going to have
2320 to return into the stub. So we have to save off the user's
2321 return pointer into the stack at RP'. */
2322 if (strncmp (entry->root.string + 14, "NO", 2))
2323 {
2324 bfd_put_32 (stub_bfd, STW_R31_M8R30, loc);
2325 loc += 4;
e08b9ad7
JL		 2326 }
2327
24f13b03
ILT		 2328 /* Iterate over the argument relocations, emitting instructions
2329 to move them around as necessary. */
2330 for (i = ARG0; i <= ARG3; i++)
4861ac76 2331 {
24f13b03 2332 if (!strncmp (entry->root.string + 3 * i + 2, "GF", 2))
e08b9ad7 2333 {
24f13b03
ILT		 2334 bfd_put_32 (stub_bfd, STW_ARG_M16R30 | ((26 - i) << 16), loc);
2335 bfd_put_32 (stub_bfd, FLDW_M16R30_FARG | (4 + i), loc + 4);
2336 loc += 8;
e08b9ad7 2337 }
24f13b03 2338 else if (!strncmp (entry->root.string + 3 * i + 2, "FG", 2))
e08b9ad7 2339 {
24f13b03
ILT		 2340 bfd_put_32 (stub_bfd, FSTW_FARG_M16R30 | (4 + i), loc);
2341 bfd_put_32 (stub_bfd, LDW_M16R30_ARG | ((26 - i) << 16), loc + 4);
2342 loc += 8;
e08b9ad7 2343 }
24f13b03 2344 else if (!strncmp (entry->root.string + 3 * i + 2, "GD", 2))
e8f2240a 2345 {
24f13b03
ILT		 2346 bfd_put_32 (stub_bfd, STW_ARG_M12R30 | ((26 - i) << 16), loc);
2347 bfd_put_32 (stub_bfd, STW_ARG_M16R30 | ((25 - i) << 16), loc + 4);
2348 bfd_put_32 (stub_bfd, FLDD_M16R30_FARG | (5 + i), loc + 8);
2349 loc += 12;
e08b9ad7 2350 }
24f13b03 2351 else if (!strncmp (entry->root.string + 3 * i + 2, "DG", 2))
e08b9ad7 2352 {
24f13b03
ILT		 2353 bfd_put_32 (stub_bfd, FSTD_FARG_M16R30 | (5 + i), loc);
2354 bfd_put_32 (stub_bfd, LDW_M12R30_ARG | ((26 - i) << 16), loc + 4);
2355 bfd_put_32 (stub_bfd, LDW_M16R30_ARG | ((25 - i) << 16), loc + 8);
2356 loc += 12;
e8f2240a 2357 }
e8f2240a 2358 }
e8f2240a 2359
24f13b03
ILT		 2360 /* Load the high bits of the target address into %r1. */
2361 insn = hppa_rebuild_insn (stub_bfd, LDIL_R1,
2362 hppa_field_adjust (sym_value, 0, e_lrsel), 21);
2363 bfd_put_32 (stub_bfd, insn, loc);
2364 loc += 4;
e8f2240a 2365
24f13b03
ILT		 2366 /* If we are relocating a return value, then we're going to have
2367 to return into the stub, then perform the return value relocation. */
2368 if (strncmp (entry->root.string + 14, "NO", 2))
e8f2240a 2369 {
24f13b03
ILT		 2370 /* To return to the stub we "ble" to the target and copy the return
2371 pointer from %r31 into %r2. */
2372 insn = hppa_rebuild_insn (stub_bfd,
2373 BLE_SR4_R1,
2374 hppa_field_adjust (sym_value, 0,
2375 e_rrsel) >> 2,
2376 17);
2377 bfd_put_32 (stub_bfd, insn, loc);
2378 bfd_put_32 (stub_bfd, COPY_R31_R2, loc + 4);
2379
2380 /* Reload the return pointer for our caller from the stack. */
2381 bfd_put_32 (stub_bfd, LDW_M8R30_R31, loc + 8);
2382 loc += 12;
2383
2384 /* Perform the return value relocation. */
2385 if (!strncmp (entry->root.string + 14, "GF", 2))
e8f2240a 2386 {
24f13b03
ILT		 2387 bfd_put_32 (stub_bfd, STW_ARG_M16R30 | (28 << 16), loc);
2388 bfd_put_32 (stub_bfd, FLDW_M16R30_FARG | 4, loc + 4);
2389 loc += 8;
e8f2240a 2390 }
24f13b03 2391 else if (!strncmp (entry->root.string + 14, "FG", 2))
e8f2240a 2392 {
24f13b03
ILT		 2393 bfd_put_32 (stub_bfd, FSTW_FARG_M16R30 | 4, loc);
2394 bfd_put_32 (stub_bfd, LDW_M16R30_ARG | (28 << 16), loc + 4);
2395 loc += 8;
e8f2240a 2396 }
24f13b03 2397 else if (!strncmp (entry->root.string + 2, "GD", 2))
e8f2240a 2398 {
24f13b03
ILT		 2399 bfd_put_32 (stub_bfd, STW_ARG_M12R30 | (28 << 16), loc);
2400 bfd_put_32 (stub_bfd, STW_ARG_M16R30 | (29 << 16), loc + 4);
2401 bfd_put_32 (stub_bfd, FLDD_M16R30_FARG | 4, loc + 8);
2402 loc += 12;
e8f2240a 2403 }
24f13b03 2404 else if (!strncmp (entry->root.string + 2, "DG", 2))
e8f2240a 2405 {
24f13b03
ILT		 2406 bfd_put_32 (stub_bfd, FSTD_FARG_M16R30 | 4, loc);
2407 bfd_put_32 (stub_bfd, LDW_M12R30_ARG | (28 << 16), loc + 4);
2408 bfd_put_32 (stub_bfd, LDW_M16R30_ARG | (29 << 16), loc + 8);
2409 loc += 12;
e8f2240a 2410 }
24f13b03
ILT		 2411 /* Branch back to the user's code now. */
2412 bfd_put_32 (stub_bfd, BV_N_0_R31, loc);
2413 loc += 4;
2414 }
2415 else
2416 {
2417 /* No return value relocation, so we can simply "be" to the
2418 target and copy out return pointer into %r2. */
2419 insn = hppa_rebuild_insn (stub_bfd, BE_SR4_R1,
2420 hppa_field_adjust (sym_value, 0,
2421 e_rrsel) >> 2, 17);
2422 bfd_put_32 (stub_bfd, insn, loc);
2423 bfd_put_32 (stub_bfd, COPY_R31_R2, loc + 4);
2424 loc += 8;
2425 }
e8f2240a 2426
24f13b03
ILT		 2427 /* Update the location and offsets. */
2428 stub_hash_table->location += (loc - begin_loc);
2429 stub_hash_table->offset += (loc - begin_loc);
2430 }
2431 else
2432 {
2433 /* Create one of two variant long branch stubs. One for $$dyncall and
2434 normal calls, the other for calls to millicode. */
2435 unsigned long insn;
2436 int millicode_call = 0;
2437
2438 if (!strncmp ("$$", sym_name, 2) && strcmp ("$$dyncall", sym_name))
2439 millicode_call = 1;
2440
2441 /* First the return pointer adjustment. Depending on exact calling
2442 sequence this instruction may be skipped. */
2443 bfd_put_32 (stub_bfd, LDO_M4_R31_R31, loc);
2444
2445 /* The next two instructions are the long branch itself. A long branch
2446 is formed with "ldil" loading the upper bits of the target address
2447 into a register, then branching with "be" which adds in the lower bits.
2448 Long branches to millicode nullify the delay slot of the "be". */
2449 insn = hppa_rebuild_insn (stub_bfd, LDIL_R1,
2450 hppa_field_adjust (sym_value, 0, e_lrsel), 21);
2451 bfd_put_32 (stub_bfd, insn, loc + 4);
2452 insn = hppa_rebuild_insn (stub_bfd, BE_SR4_R1 | (millicode_call ? 2 : 0),
2453 hppa_field_adjust (sym_value, 0, e_rrsel) >> 2,
2454 17);
2455 bfd_put_32 (stub_bfd, insn, loc + 8);
2456
2457 if (!millicode_call)
2458 {
2459 /* The sequence to call this stub places the return pointer into %r31,
2460 the final target expects the return pointer in %r2, so copy the
2461 return pointer into the proper register. */
2462 bfd_put_32 (stub_bfd, COPY_R31_R2, loc + 12);
2463
2464 /* Update the location and offsets. */
2465 stub_hash_table->location += 16;
2466 stub_hash_table->offset += 16;
e8f2240a 2467 }
24f13b03
ILT		 2468 else
2469 {
2470 /* Update the location and offsets. */
2471 stub_hash_table->location += 12;
2472 stub_hash_table->offset += 12;
2473 }
2474
e8f2240a 2475 }
24f13b03 2476 return true;
e8f2240a
KR		 2477}
2478
24f13b03 2479/* External entry points for sizing and building linker stubs. */
d9ad93bc 2480
24f13b03
ILT		 2481/* Build all the stubs associated with the current output file. The
2482 stubs are kept in a hash table attached to the main linker hash
2483 table. This is called via hppaelf_finish in the linker. */
e08b9ad7 2484
24f13b03
ILT		 2485boolean
2486elf32_hppa_build_stubs (stub_bfd, info)
2487 bfd *stub_bfd;
2488 struct bfd_link_info *info;
d9ad93bc 2489{
24f13b03
ILT		 2490 /* The stub BFD only has one section. */
2491 asection *stub_sec = stub_bfd->sections;
2492 struct elf32_hppa_stub_hash_table *table;
2493 unsigned int size;
2494 void *args[2];
2495
2496 /* So we can pass both the BFD for the stubs and the link info
2497 structure to the routine which actually builds stubs. */
2498 args[0] = stub_bfd;
2499 args[1] = info;
2500
2501 /* Allocate memory to hold the linker stubs. */
2502 size = bfd_section_size (stub_bfd, stub_sec);
2503 stub_sec->contents = (unsigned char *) bfd_zalloc (stub_bfd, size);
2504 if (stub_sec->contents == NULL)
2505 {
2506 bfd_set_error (bfd_error_no_memory);
2507 return false;
2508 }
2509 table = elf32_hppa_hash_table(info)->stub_hash_table;
2510 table->location = stub_sec->contents;
d9ad93bc 2511
24f13b03
ILT		 2512 /* Build the stubs as directed by the stub hash table. */
2513 elf32_hppa_stub_hash_traverse (table, elf32_hppa_build_one_stub, args);
d9ad93bc 2514
24f13b03 2515 return true;
d9ad93bc
KR		 2516}
2517
24f13b03 2518/* Determine and set the size of the stub section for a final link.
e08b9ad7 2519
24f13b03
ILT		 2520 The basic idea here is to examine all the relocations looking for
2521 PC-relative calls to a target that is unreachable with a "bl"
2522 instruction or calls where the caller and callee disagree on the
2523 location of their arguments or return value. */
e8f2240a 2524
24f13b03
ILT		 2525boolean
2526elf32_hppa_size_stubs (stub_bfd, output_bfd, link_info)
d9ad93bc 2527 bfd *stub_bfd;
e8f2240a 2528 bfd *output_bfd;
4991ebb9 2529 struct bfd_link_info *link_info;
e8f2240a 2530{
24f13b03 2531 bfd *input_bfd;
ede4eed4 2532 asection *section, *stub_sec = 0;
24f13b03 2533 Elf_Internal_Shdr *symtab_hdr;
77712cf0 2534 Elf_Internal_Sym *local_syms, *isym, **all_local_syms;
24f13b03 2535 Elf32_External_Sym *ext_syms, *esym;
77712cf0 2536 unsigned int i, index, bfd_count = 0;
24f13b03
ILT		 2537 struct elf32_hppa_stub_hash_table *stub_hash_table = 0;
2538 struct elf32_hppa_args_hash_table *args_hash_table = 0;
2539
2540 /* Create and initialize the stub hash table. */
2541 stub_hash_table = ((struct elf32_hppa_stub_hash_table *)
2542 malloc (sizeof (struct elf32_hppa_stub_hash_table)));
2543 if (!stub_hash_table)
e8f2240a 2544 {
24f13b03
ILT		 2545 bfd_set_error (bfd_error_no_memory);
2546 goto error_return;
2547 }
e08b9ad7 2548
24f13b03
ILT		 2549 if (!elf32_hppa_stub_hash_table_init (stub_hash_table, stub_bfd,
2550 elf32_hppa_stub_hash_newfunc))
2551 goto error_return;
4c85cbfa 2552
24f13b03
ILT		 2553 /* Likewise for the argument location hash table. */
2554 args_hash_table = ((struct elf32_hppa_args_hash_table *)
2555 malloc (sizeof (struct elf32_hppa_args_hash_table)));
2556 if (!args_hash_table)
2557 {
2558 bfd_set_error (bfd_error_no_memory);
2559 goto error_return;
e8f2240a 2560 }
e08b9ad7 2561
24f13b03
ILT		 2562 if (!elf32_hppa_args_hash_table_init (args_hash_table,
2563 elf32_hppa_args_hash_newfunc))
2564 goto error_return;
4c85cbfa 2565
24f13b03
ILT		 2566 /* Attach the hash tables to the main hash table. */
2567 elf32_hppa_hash_table(link_info)->stub_hash_table = stub_hash_table;
2568 elf32_hppa_hash_table(link_info)->args_hash_table = args_hash_table;
d9ad93bc 2569
5874427f 2570 /* Count the number of input BFDs. */
24f13b03
ILT		 2571 for (input_bfd = link_info->input_bfds;
2572 input_bfd != NULL;
2573 input_bfd = input_bfd->link_next)
5874427f
JL		 2574 bfd_count++;
2575
2576 /* We want to read in symbol extension records only once. To do this
2577 we need to read in the local symbols in parallel and save them for
2578 later use; so hold pointers to the local symbols in an array. */
2579 all_local_syms
2580 = (Elf_Internal_Sym **) malloc (sizeof (Elf_Internal_Sym *) * bfd_count);
2581 if (all_local_syms == NULL)
d9ad93bc 2582 {
5874427f
JL		 2583 bfd_set_error (bfd_error_no_memory);
2584 goto error_return;
d9ad93bc 2585 }
5874427f 2586 memset (all_local_syms, 0, sizeof (Elf_Internal_Sym *) * bfd_count);
4c85cbfa 2587
5874427f
JL		 2588 /* Walk over all the input BFDs adding entries to the args hash table
2589 for all the external functions. */
77712cf0 2590 for (input_bfd = link_info->input_bfds, index = 0;
24f13b03 2591 input_bfd != NULL;
77712cf0 2592 input_bfd = input_bfd->link_next, index++)
e8f2240a 2593 {
24f13b03
ILT		 2594 /* We'll need the symbol table in a second. */
2595 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2596 if (symtab_hdr->sh_info == 0)
2597 continue;
d9ad93bc 2598
24f13b03
ILT		 2599 /* We need an array of the local symbols attached to the input bfd.
2600 Unfortunately, we're going to have to read & swap them in. */
2601 local_syms
2602 = (Elf_Internal_Sym *)malloc (symtab_hdr->sh_info
2603 * sizeof (Elf_Internal_Sym));
2604 if (local_syms == NULL)
2605 {
2606 bfd_set_error (bfd_error_no_memory);
5874427f 2607 for (i = 0; i < bfd_count; i++)
77712cf0
JL		 2608 if (all_local_syms[i])
2609 free (all_local_syms[i]);
2610 free (all_local_syms);
24f13b03
ILT		 2611 goto error_return;
2612 }
77712cf0 2613 all_local_syms[index] = local_syms;
e08b9ad7 2614
24f13b03
ILT		 2615 ext_syms
2616 = (Elf32_External_Sym *)malloc (symtab_hdr->sh_info
2617 * sizeof (Elf32_External_Sym));
2618 if (ext_syms == NULL)
2619 {
2620 bfd_set_error (bfd_error_no_memory);
5874427f 2621 for (i = 0; i < bfd_count; i++)
77712cf0
JL		 2622 if (all_local_syms[i])
2623 free (all_local_syms[i]);
2624 free (all_local_syms);
24f13b03
ILT		 2625 goto error_return;
2626 }
d9ad93bc 2627
24f13b03
ILT		 2628 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2629 || bfd_read (ext_syms, 1,
2630 (symtab_hdr->sh_info
2631 * sizeof (Elf32_External_Sym)), input_bfd)
2632 != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym)))
2633 {
5874427f 2634 for (i = 0; i < bfd_count; i++)
77712cf0
JL		 2635 if (all_local_syms[i])
2636 free (all_local_syms[i]);
2637 free (all_local_syms);
24f13b03
ILT		 2638 free (ext_syms);
2639 goto error_return;
2640 }
d9ad93bc 2641
24f13b03
ILT		 2642 /* Swap the local symbols in. */
2643 isym = local_syms;
2644 esym = ext_syms;
2645 for (i = 0; i < symtab_hdr->sh_info; i++, esym++, isym++)
2646 bfd_elf32_swap_symbol_in (input_bfd, esym, isym);
d9ad93bc 2647
24f13b03
ILT		 2648 /* Now we can free the external symbols. */
2649 free (ext_syms);
d9ad93bc 2650
24f13b03 2651 if (elf32_hppa_read_symext_info (input_bfd, symtab_hdr, args_hash_table,
5874427f 2652 local_syms) == false)
24f13b03 2653 {
5874427f 2654 for (i = 0; i < bfd_count; i++)
77712cf0
JL		 2655 if (all_local_syms[i])
2656 free (all_local_syms[i]);
2657 free (all_local_syms);
24f13b03
ILT		 2658 goto error_return;
2659 }
5874427f 2660 }
d9ad93bc 2661
5874427f
JL		 2662 /* Magic as we know the stub bfd only has one section. */
2663 stub_sec = stub_bfd->sections;
2664
2665 /* If generating a relocateable output file, then we don't
2666 have to examine the relocs. */
2667 if (link_info->relocateable)
2668 {
2669 for (i = 0; i < bfd_count; i++)
77712cf0
JL		 2670 if (all_local_syms[i])
2671 free (all_local_syms[i]);
2672 free (all_local_syms);
5874427f
JL		 2673 return true;
2674 }
2675
2676 /* Now that we have argument location information for all the global
2677 functions we can start looking for stubs. */
77712cf0 2678 for (input_bfd = link_info->input_bfds, index = 0;
5874427f 2679 input_bfd != NULL;
77712cf0 2680 input_bfd = input_bfd->link_next, index++)
5874427f 2681 {
5874427f
JL		 2682 /* We'll need the symbol table in a second. */
2683 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2684 if (symtab_hdr->sh_info == 0)
2685 continue;
2686
77712cf0 2687 local_syms = all_local_syms[index];
d9ad93bc 2688
24f13b03
ILT		 2689 /* Walk over each section attached to the input bfd. */
2690 for (section = input_bfd->sections;
2691 section != NULL;
2692 section = section->next)
2693 {
2694 Elf_Internal_Shdr *input_rel_hdr;
2695 Elf32_External_Rela *external_relocs, *erelaend, *erela;
2696 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2697
2698 /* If there aren't any relocs, then there's nothing to do. */
2699 if ((section->flags & SEC_RELOC) == 0
2700 || section->reloc_count == 0)
2701 continue;
2702
2703 /* Allocate space for the external relocations. */
2704 external_relocs
2705 = (Elf32_External_Rela *) malloc (section->reloc_count * sizeof (Elf32_External_Rela));
2706 if (external_relocs == NULL)
d9ad93bc 2707 {
24f13b03 2708 bfd_set_error (bfd_error_no_memory);
5874427f 2709 for (i = 0; i < bfd_count; i++)
77712cf0
JL		 2710 if (all_local_syms[i])
2711 free (all_local_syms[i]);
2712 free (all_local_syms);
24f13b03 2713 goto error_return;
d9ad93bc 2714 }
d9ad93bc 2715
24f13b03
ILT		 2716 /* Likewise for the internal relocations. */
2717 internal_relocs
2718 = (Elf_Internal_Rela *) malloc (section->reloc_count * sizeof (Elf_Internal_Rela));
2719 if (internal_relocs == NULL)
2720 {
2721 bfd_set_error (bfd_error_no_memory);
2722 free (external_relocs);
5874427f 2723 for (i = 0; i < bfd_count; i++)
77712cf0
JL		 2724 if (all_local_syms[i])
2725 free (all_local_syms[i]);
2726 free (all_local_syms);
24f13b03
ILT		 2727 goto error_return;
2728 }
d9ad93bc 2729
24f13b03
ILT		 2730 /* Read in the external relocs. */
2731 input_rel_hdr = &elf_section_data (section)->rel_hdr;
2732 if (bfd_seek (input_bfd, input_rel_hdr->sh_offset, SEEK_SET) != 0
2733 || bfd_read (external_relocs, 1, input_rel_hdr->sh_size,
2734 input_bfd) != input_rel_hdr->sh_size)
2735 {
2736 free (external_relocs);
2737 free (internal_relocs);
5874427f 2738 for (i = 0; i < bfd_count; i++)
77712cf0
JL		 2739 if (all_local_syms[i])
2740 free (all_local_syms[i]);
2741 free (all_local_syms);
24f13b03
ILT		 2742 goto error_return;
2743 }
d9ad93bc 2744
24f13b03
ILT		 2745 /* Swap in the relocs. */
2746 erela = external_relocs;
2747 erelaend = erela + section->reloc_count;
2748 irela = internal_relocs;
2749 for (; erela < erelaend; erela++, irela++)
2750 bfd_elf32_swap_reloca_in (input_bfd, erela, irela);
d9ad93bc 2751
24f13b03
ILT		 2752 /* We're done with the external relocs, free them. */
2753 free (external_relocs);
d9ad93bc 2754
24f13b03
ILT		 2755 /* Now examine each relocation. */
2756 irela = internal_relocs;
2757 irelaend = irela + section->reloc_count;
2758 for (; irela < irelaend; irela++)
d9ad93bc 2759 {
24f13b03
ILT		 2760 long r_type, callee_args, caller_args, r_index, size_of_stub;
2761 struct elf_link_hash_entry *hash;
2762 struct elf32_hppa_stub_hash_entry *stub_hash;
2763 struct elf32_hppa_args_hash_entry *args_hash;
2764 Elf_Internal_Sym *sym;
2765 asection *sym_sec;
2766 const char *sym_name;
2767 symvalue sym_value;
2768 bfd_vma location, destination;
2769 char *new_name = NULL;
2770
2771 r_type = ELF32_R_TYPE (irela->r_info);
2772 r_index = ELF32_R_SYM (irela->r_info);
2773
2774 if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
2775 {
2776 bfd_set_error (bfd_error_bad_value);
2777 free (internal_relocs);
5874427f 2778 for (i = 0; i < bfd_count; i++)
77712cf0
JL		 2779 if (all_local_syms[i])
2780 free (all_local_syms[i]);
2781 free (all_local_syms);
24f13b03
ILT		 2782 goto error_return;
2783 }
2784
2785 /* Only look for stubs on call instructions or plabel
2786 references. */
2787 if (r_type != R_PARISC_PCREL17F
2788 && r_type != R_PARISC_PLABEL32
2789 && r_type != R_PARISC_PLABEL21L
2790 && r_type != R_PARISC_PLABEL14R)
2791 continue;
2792
2793 /* Now determine the call target, its name, value, section
2794 and argument relocation bits. */
2795 hash = NULL;
2796 sym = NULL;
2797 sym_sec = NULL;
2798 if (r_index < symtab_hdr->sh_info)
d9ad93bc 2799 {
24f13b03
ILT		 2800 /* It's a local symbol. */
2801 Elf_Internal_Shdr *hdr;
2802
2803 sym = local_syms + r_index;
2804 hdr = elf_elfsections (input_bfd)[sym->st_shndx];
2805 sym_sec = hdr->bfd_section;
ede4eed4
KR		 2806 sym_name = bfd_elf_string_from_elf_section (input_bfd,
2807 symtab_hdr->sh_link,
2808 sym->st_name);
24f13b03
ILT		 2809 sym_value = (ELF_ST_TYPE (sym->st_info) == STT_SECTION
2810 ? 0 : sym->st_value);
2811 destination = (sym_value
2812 + sym_sec->output_offset
2813 + sym_sec->output_section->vma);
2814
2815 /* Tack on an ID so we can uniquely identify this local
2816 symbol in the stub or arg info hash tables. */
2817 new_name = malloc (strlen (sym_name) + 10);
2818 if (new_name == 0)
d9ad93bc 2819 {
24f13b03
ILT		 2820 bfd_set_error (bfd_error_bad_value);
2821 free (internal_relocs);
5874427f 2822 for (i = 0; i < bfd_count; i++)
77712cf0
JL		 2823 if (all_local_syms[i])
2824 free (all_local_syms[i]);
2825 free (all_local_syms);
24f13b03 2826 goto error_return;
d9ad93bc 2827 }
24f13b03
ILT		 2828 sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
2829 sym_name = new_name;
d9ad93bc 2830 }
24f13b03 2831 else
d9ad93bc 2832 {
24f13b03
ILT		 2833 /* It's an external symbol. */
2834 long index;
2835
2836 index = r_index - symtab_hdr->sh_info;
2837 hash = elf_sym_hashes (input_bfd)[index];
31dabb6c
JL		 2838 if (hash->root.type == bfd_link_hash_defined
2839 || hash->root.type == bfd_link_hash_defweak)
24f13b03
ILT		 2840 {
2841 sym_sec = hash->root.u.def.section;
2842 sym_name = hash->root.root.string;
2843 sym_value = hash->root.u.def.value;
2844 destination = (sym_value
2845 + sym_sec->output_offset
2846 + sym_sec->output_section->vma);
2847 }
2848 else
2849 {
2850 bfd_set_error (bfd_error_bad_value);
2851 free (internal_relocs);
5874427f 2852 for (i = 0; i < bfd_count; i++)
77712cf0
JL		 2853 if (all_local_syms[i])
2854 free (all_local_syms[i]);
2855 free (all_local_syms);
24f13b03
ILT		 2856 goto error_return;
2857 }
d9ad93bc
KR		 2858 }
2859
24f13b03
ILT		 2860 args_hash = elf32_hppa_args_hash_lookup (args_hash_table,
2861 sym_name, false, false);
d9ad93bc 2862
24f13b03
ILT		 2863 /* Get both caller and callee argument information. */
2864 if (args_hash == NULL)
2865 callee_args = 0;
d9ad93bc 2866 else
24f13b03
ILT		 2867 callee_args = args_hash->arg_bits;
2868
2869 /* For calls get the caller's bits from the addend of
2870 the call relocation. For PLABELS the caller's bits
2871 are assumed to have all args & return values in general
2872 registers (0x155). */
2873 if (r_type == R_PARISC_PCREL17F)
2874 caller_args = HPPA_R_ARG_RELOC (irela->r_addend);
2875 else
2876 caller_args = 0x155;
2877
2878 /* Now determine where the call point is. */
2879 location = (section->output_offset
2880 + section->output_section->vma
2881 + irela->r_offset);
2882
2883 /* We only care about the destination for PCREL function
2884 calls (eg. we don't care for PLABELS). */
2885 if (r_type != R_PARISC_PCREL17F)
2886 location = destination;
2887
2888 /* Determine what (if any) linker stub is needed and its
2889 size (in bytes). */
2890 size_of_stub = elf32_hppa_size_of_stub (callee_args,
2891 caller_args,
2892 location,
2893 destination,
2894 sym_name);
2895 if (size_of_stub != 0)
2896 {
2897 char *stub_name;
2898 unsigned int len;
d9ad93bc 2899
24f13b03
ILT		 2900 /* Get the name of this stub. */
2901 len = strlen (sym_name);
2902 len += 23;
d9ad93bc 2903
24f13b03
ILT		 2904 stub_name = malloc (len);
2905 if (!stub_name)
2906 {
2907 bfd_set_error (bfd_error_no_memory);
d9ad93bc 2908
24f13b03
ILT		 2909 /* Because sym_name was mallocd above for local
2910 symbols. */
2911 if (r_index < symtab_hdr->sh_info)
2912 free (new_name);
d9ad93bc 2913
24f13b03 2914 free (internal_relocs);
5874427f 2915 for (i = 0; i < bfd_count; i++)
77712cf0
JL		 2916 if (all_local_syms[i])
2917 free (all_local_syms[i]);
2918 free (all_local_syms);
24f13b03
ILT		 2919 goto error_return;
2920 }
2921 elf32_hppa_name_of_stub (caller_args, callee_args,
2922 location, destination, stub_name);
2923 strcat (stub_name + 22, sym_name);
2924
2925 /* Because sym_name was malloced above for local symbols. */
2926 if (r_index < symtab_hdr->sh_info)
2927 free (new_name);
2928
2929 stub_hash
2930 = elf32_hppa_stub_hash_lookup (stub_hash_table, stub_name,
2931 false, false);
2932 if (stub_hash != NULL)
2933 {
2934 /* The proper stub has already been created, nothing
2935 else to do. */
2936 free (stub_name);
2937 }
2938 else
2939 {
2940 bfd_set_section_size (stub_bfd, stub_sec,
2941 (bfd_section_size (stub_bfd,
2942 stub_sec)
2943 + size_of_stub));
2944
2945 /* Enter this entry into the linker stub hash table. */
2946 stub_hash
2947 = elf32_hppa_stub_hash_lookup (stub_hash_table,
2948 stub_name, true, true);
2949 if (stub_hash == NULL)
2950 {
2951 bfd_set_error (bfd_error_no_memory);
2952 free (stub_name);
2953 free (internal_relocs);
5874427f 2954 for (i = 0; i < bfd_count; i++)
77712cf0
JL		 2955 if (all_local_syms[i])
2956 free (all_local_syms[i]);
2957 free (all_local_syms);
24f13b03
ILT		 2958 goto error_return;
2959 }
d9ad93bc 2960
24f13b03
ILT		 2961 /* We'll need these to determine the address that the
2962 stub will branch to. */
2963 stub_hash->target_value = sym_value;
2964 stub_hash->target_section = sym_sec;
2965 }
2966 free (stub_name);
2967 }
2968 }
2969 /* We're done with the internal relocs, free them. */
2970 free (internal_relocs);
2971 }
7218bb04 2972 }
77712cf0
JL		 2973 /* We're done with the local symbols, free them. */
2974 for (i = 0; i < bfd_count; i++)
2975 if (all_local_syms[i])
2976 free (all_local_syms[i]);
2977 free (all_local_syms);
24f13b03 2978 return true;
7218bb04 2979
24f13b03
ILT		 2980error_return:
2981 /* Return gracefully, avoiding dangling references to the hash tables. */
2982 if (stub_hash_table)
d9ad93bc 2983 {
24f13b03
ILT		 2984 elf32_hppa_hash_table(link_info)->stub_hash_table = NULL;
2985 free (stub_hash_table);
d9ad93bc 2986 }
24f13b03 2987 if (args_hash_table)
7218bb04 2988 {
24f13b03
ILT		 2989 elf32_hppa_hash_table(link_info)->args_hash_table = NULL;
2990 free (args_hash_table);
7218bb04 2991 }
9fe4fade
JL		 2992 /* Set the size of the stub section to zero since we're never going
2993 to create them. Avoids losing when we try to get its contents
2994 too. */
2995 bfd_set_section_size (stub_bfd, stub_sec, 0);
d9ad93bc 2996 return false;
8ddd7ab3 2997}
4c85cbfa 2998
24f13b03
ILT		 2999/* Misc BFD support code. */
3000#define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
25057836 3001#define bfd_elf32_bfd_is_local_label hppa_elf_is_local_label
d9ad93bc 3002
24f13b03
ILT		 3003/* Symbol extension stuff. */
3004#define bfd_elf32_set_section_contents elf32_hppa_set_section_contents
3005#define elf_backend_symbol_table_processing \
3006 elf32_hppa_backend_symbol_table_processing
459ae909
JL		 3007#define elf_backend_begin_write_processing \
3008 elf32_hppa_backend_begin_write_processing
3009#define elf_backend_final_write_processing \
3010 elf32_hppa_backend_final_write_processing
e08b9ad7 3011
24f13b03
ILT		 3012/* Stuff for the BFD linker. */
3013#define elf_backend_relocate_section elf32_hppa_relocate_section
3014#define elf_backend_add_symbol_hook elf32_hppa_add_symbol_hook
3015#define elf_backend_link_output_symbol_hook \
3016 elf32_hppa_link_output_symbol_hook
3017#define bfd_elf32_bfd_link_hash_table_create \
3018 elf32_hppa_link_hash_table_create
3019
e8f2240a 3020#define TARGET_BIG_SYM bfd_elf32_hppa_vec
8ddd7ab3
KR		 3021#define TARGET_BIG_NAME "elf32-hppa"
3022#define ELF_ARCH bfd_arch_hppa
459ae909 3023#define ELF_MACHINE_CODE EM_PARISC
3a70b01d 3024#define ELF_MAXPAGESIZE 0x1000
8ddd7ab3
KR		 3025
3026#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.256727 seconds and 4 git commands to generate.