projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elf64-ia64.c (ia64_howto_table): Add PCREL60B, PCREL21BI,
[deliverable/binutils-gdb.git] / bfd / elf64-ia64.c
CommitLineData
800eeca4 1/* IA-64 support for 64-bit ELF
748abff6 2 Copyright 1998, 1999, 2000 Free Software Foundation, Inc.
800eeca4
JW		 3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
4
5This file is part of BFD, the Binary File Descriptor library.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21#include "bfd.h"
22#include "sysdep.h"
23#include "libbfd.h"
24#include "elf-bfd.h"
25#include "opcode/ia64.h"
26#include "elf/ia64.h"
27
748abff6 28
800eeca4
JW		 29/*
30 * THE RULES for all the stuff the linker creates --
31 *
32 * GOT Entries created in response to LTOFF or LTOFF_FPTR
33 * relocations. Dynamic relocs created for dynamic
34 * symbols in an application; REL relocs for locals
35 * in a shared library.
36 *
37 * FPTR The canonical function descriptor. Created for local
38 * symbols in applications. Descriptors for dynamic symbols
39 * and local symbols in shared libraries are created by
40 * ld.so. Thus there are no dynamic relocs against these
41 * objects. The FPTR relocs for such _are_ passed through
42 * to the dynamic relocation tables.
43 *
44 * FULL_PLT Created for a PCREL21B relocation against a dynamic symbol.
45 * Requires the creation of a PLTOFF entry. This does not
46 * require any dynamic relocations.
47 *
48 * PLTOFF Created by PLTOFF relocations. For local symbols, this
49 * is an alternate function descriptor, and in shared libraries
50 * requires two REL relocations. Note that this cannot be
51 * transformed into an FPTR relocation, since it must be in
52 * range of the GP. For dynamic symbols, this is a function
53 * descriptor for a MIN_PLT entry, and requires one IPLT reloc.
54 *
55 * MIN_PLT Created by PLTOFF entries against dynamic symbols. This
56 * does not reqire dynamic relocations.
57 */
58
59#define USE_RELA /* we want RELA relocs, not REL */
60
61#define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0])))
62
63typedef struct bfd_hash_entry *(*new_hash_entry_func)
64 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
65
66/* In dynamically (linker-) created sections, we generally need to keep track
67 of the place a symbol or expression got allocated to. This is done via hash
68 tables that store entries of the following type. */
69
70struct elf64_ia64_dyn_sym_info
71{
72 /* The addend for which this entry is relevant. */
73 bfd_vma addend;
74
75 /* Next addend in the list. */
76 struct elf64_ia64_dyn_sym_info *next;
77
78 bfd_vma got_offset;
79 bfd_vma fptr_offset;
80 bfd_vma pltoff_offset;
81 bfd_vma plt_offset;
82 bfd_vma plt2_offset;
83
84 /* The symbol table entry, if any, that this was derrived from. */
85 struct elf_link_hash_entry *h;
86
87 /* Used to count non-got, non-plt relocations for delayed sizing
88 of relocation sections. */
89 struct elf64_ia64_dyn_reloc_entry
90 {
91 struct elf64_ia64_dyn_reloc_entry *next;
92 asection *srel;
93 int type;
94 int count;
95 } *reloc_entries;
96
97 /* True when the section contents have been updated. */
98 unsigned got_done : 1;
99 unsigned fptr_done : 1;
100 unsigned pltoff_done : 1;
101
102 /* True for the different kinds of linker data we want created. */
103 unsigned want_got : 1;
104 unsigned want_fptr : 1;
105 unsigned want_ltoff_fptr : 1;
106 unsigned want_plt : 1;
107 unsigned want_plt2 : 1;
108 unsigned want_pltoff : 1;
109};
110
111struct elf64_ia64_local_hash_entry
112{
113 struct bfd_hash_entry root;
114 struct elf64_ia64_dyn_sym_info *info;
115};
116
117struct elf64_ia64_local_hash_table
118{
119 struct bfd_hash_table root;
120 /* No additional fields for now. */
121};
122
123struct elf64_ia64_link_hash_entry
124{
125 struct elf_link_hash_entry root;
126 struct elf64_ia64_dyn_sym_info *info;
127};
128
129struct elf64_ia64_link_hash_table
130{
131 /* The main hash table */
132 struct elf_link_hash_table root;
133
134 asection *got_sec; /* the linkage table section (or NULL) */
135 asection *rel_got_sec; /* dynamic relocation section for same */
136 asection *fptr_sec; /* function descriptor table (or NULL) */
137 asection *plt_sec; /* the primary plt section (or NULL) */
138 asection *pltoff_sec; /* private descriptors for plt (or NULL) */
139 asection *rel_pltoff_sec; /* dynamic relocation section for same */
140
141 bfd_size_type minplt_entries; /* number of minplt entries */
142
143 struct elf64_ia64_local_hash_table loc_hash_table;
144};
145
146#define elf64_ia64_hash_table(p) \
147 ((struct elf64_ia64_link_hash_table *) ((p)->hash))
148
149static bfd_reloc_status_type elf64_ia64_reloc
150 PARAMS ((bfd *abfd, arelent *reloc, asymbol *sym, PTR data,
151 asection *input_section, bfd *output_bfd, char **error_message));
152static reloc_howto_type * lookup_howto
153 PARAMS ((unsigned int rtype));
154static reloc_howto_type *elf64_ia64_reloc_type_lookup
155 PARAMS ((bfd *abfd, bfd_reloc_code_real_type bfd_code));
156static void elf64_ia64_info_to_howto
157 PARAMS ((bfd *abfd, arelent *bfd_reloc, Elf64_Internal_Rela *elf_reloc));
748abff6
RH		 158static boolean elf64_ia64_relax_section
159 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
160 boolean *again));
800eeca4
JW		 161static boolean elf64_ia64_section_from_shdr
162 PARAMS ((bfd *, Elf64_Internal_Shdr *, char *));
163static boolean elf64_ia64_fake_sections
164 PARAMS ((bfd *abfd, Elf64_Internal_Shdr *hdr, asection *sec));
165static boolean elf64_ia64_add_symbol_hook
166 PARAMS ((bfd *abfd, struct bfd_link_info *info, const Elf_Internal_Sym *sym,
167 const char **namep, flagword *flagsp, asection **secp,
168 bfd_vma *valp));
169static int elf64_ia64_additional_program_headers
170 PARAMS ((bfd *abfd));
171static boolean elf64_ia64_is_local_label_name
172 PARAMS ((bfd *abfd, const char *name));
173static boolean elf64_ia64_dynamic_symbol_p
174 PARAMS ((struct elf_link_hash_entry *h, struct bfd_link_info *info));
175static boolean elf64_ia64_local_hash_table_init
176 PARAMS ((struct elf64_ia64_local_hash_table *ht, bfd *abfd,
177 new_hash_entry_func new));
178static struct bfd_hash_entry *elf64_ia64_new_loc_hash_entry
179 PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
180 const char *string));
181static struct bfd_hash_entry *elf64_ia64_new_elf_hash_entry
182 PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
183 const char *string));
184static struct bfd_link_hash_table *elf64_ia64_hash_table_create
185 PARAMS ((bfd *abfd));
186static struct elf64_ia64_local_hash_entry *elf64_ia64_local_hash_lookup
187 PARAMS ((struct elf64_ia64_local_hash_table *table, const char *string,
188 boolean create, boolean copy));
189static void elf64_ia64_dyn_sym_traverse
190 PARAMS ((struct elf64_ia64_link_hash_table *ia64_info,
191 boolean (*func)(struct elf64_ia64_dyn_sym_info *, PTR),
192 PTR info));
193static boolean elf64_ia64_create_dynamic_sections
194 PARAMS ((bfd *abfd, struct bfd_link_info *info));
195static struct elf64_ia64_dyn_sym_info * get_dyn_sym_info
196 PARAMS ((struct elf64_ia64_link_hash_table *ia64_info,
197 struct elf_link_hash_entry *h,
198 bfd *abfd, const Elf_Internal_Rela *rel, boolean create));
199static asection *get_got
200 PARAMS ((bfd *abfd, struct bfd_link_info *info,
201 struct elf64_ia64_link_hash_table *ia64_info));
202static asection *get_fptr
203 PARAMS ((bfd *abfd, struct bfd_link_info *info,
204 struct elf64_ia64_link_hash_table *ia64_info));
205static asection *get_pltoff
206 PARAMS ((bfd *abfd, struct bfd_link_info *info,
207 struct elf64_ia64_link_hash_table *ia64_info));
208static asection *get_reloc_section
209 PARAMS ((bfd *abfd, struct elf64_ia64_link_hash_table *ia64_info,
210 asection *sec, boolean create));
211static boolean count_dyn_reloc
212 PARAMS ((bfd *abfd, struct elf64_ia64_dyn_sym_info *dyn_i,
213 asection *srel, int type));
214static boolean elf64_ia64_check_relocs
215 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
216 const Elf_Internal_Rela *relocs));
217static boolean elf64_ia64_adjust_dynamic_symbol
218 PARAMS ((struct bfd_link_info *info, struct elf_link_hash_entry *h));
219static unsigned long global_sym_index
220 PARAMS ((struct elf_link_hash_entry *h));
221static boolean allocate_fptr
222 PARAMS ((struct elf64_ia64_dyn_sym_info *dyn_i, PTR data));
223static boolean allocate_global_data_got
224 PARAMS ((struct elf64_ia64_dyn_sym_info *dyn_i, PTR data));
225static boolean allocate_global_fptr_got
226 PARAMS ((struct elf64_ia64_dyn_sym_info *dyn_i, PTR data));
227static boolean allocate_local_got
228 PARAMS ((struct elf64_ia64_dyn_sym_info *dyn_i, PTR data));
229static boolean allocate_pltoff_entries
230 PARAMS ((struct elf64_ia64_dyn_sym_info *dyn_i, PTR data));
231static boolean allocate_plt_entries
232 PARAMS ((struct elf64_ia64_dyn_sym_info *dyn_i, PTR data));
233static boolean allocate_plt2_entries
234 PARAMS ((struct elf64_ia64_dyn_sym_info *dyn_i, PTR data));
235static boolean allocate_dynrel_entries
236 PARAMS ((struct elf64_ia64_dyn_sym_info *dyn_i, PTR data));
237static boolean elf64_ia64_size_dynamic_sections
238 PARAMS ((bfd *output_bfd, struct bfd_link_info *info));
239static bfd_reloc_status_type elf64_ia64_install_value
240 PARAMS ((bfd *abfd, bfd_byte *hit_addr, bfd_vma val, unsigned int r_type));
241static void elf64_ia64_install_dyn_reloc
242 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
243 asection *srel, bfd_vma offset, unsigned int type,
244 long dynindx, bfd_vma addend));
245static bfd_vma set_got_entry
246 PARAMS ((bfd *abfd, struct bfd_link_info *info,
247 struct elf64_ia64_dyn_sym_info *dyn_i, long dynindx,
248 bfd_vma addend, bfd_vma value, unsigned int dyn_r_type));
249static bfd_vma set_fptr_entry
250 PARAMS ((bfd *abfd, struct bfd_link_info *info,
251 struct elf64_ia64_dyn_sym_info *dyn_i,
252 bfd_vma value));
253static bfd_vma set_pltoff_entry
254 PARAMS ((bfd *abfd, struct bfd_link_info *info,
255 struct elf64_ia64_dyn_sym_info *dyn_i,
256 bfd_vma value, boolean));
257static boolean elf64_ia64_final_link
258 PARAMS ((bfd *abfd, struct bfd_link_info *info));
259static boolean elf64_ia64_relocate_section
260 PARAMS ((bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd,
261 asection *input_section, bfd_byte *contents,
262 Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
263 asection **local_sections));
264static boolean elf64_ia64_finish_dynamic_symbol
265 PARAMS ((bfd *output_bfd, struct bfd_link_info *info,
266 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym));
267static boolean elf64_ia64_finish_dynamic_sections
268 PARAMS ((bfd *abfd, struct bfd_link_info *info));
269static boolean elf64_ia64_set_private_flags
270 PARAMS ((bfd *abfd, flagword flags));
271static boolean elf64_ia64_copy_private_bfd_data
272 PARAMS ((bfd *ibfd, bfd *obfd));
273static boolean elf64_ia64_merge_private_bfd_data
274 PARAMS ((bfd *ibfd, bfd *obfd));
275static boolean elf64_ia64_print_private_bfd_data
276 PARAMS ((bfd *abfd, PTR ptr));
277
278\f
279/* ia64-specific relocation */
280
281/* Perform a relocation. Not much to do here as all the hard work is
282 done in elf64_ia64_final_link_relocate. */
283static bfd_reloc_status_type
284elf64_ia64_reloc (abfd, reloc, sym, data, input_section,
285 output_bfd, error_message)
286 bfd *abfd;
287 arelent *reloc;
288 asymbol *sym;
289 PTR data;
290 asection *input_section;
291 bfd *output_bfd;
292 char **error_message;
293{
294 if (output_bfd)
295 {
296 reloc->address += input_section->output_offset;
297 return bfd_reloc_ok;
298 }
299 *error_message = "Unsupported call to elf64_ia64_reloc";
300 return bfd_reloc_notsupported;
301}
302
303#define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN) \
304 HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed, \
305 elf64_ia64_reloc, NAME, false, 0, 0, IN)
306
307/* This table has to be sorted according to increasing number of the
308 TYPE field. */
309static reloc_howto_type ia64_howto_table[] =
310 {
311 IA64_HOWTO (R_IA64_NONE, "NONE", 0, false, true),
312
313 IA64_HOWTO (R_IA64_IMM14, "IMM14", 0, false, true),
314 IA64_HOWTO (R_IA64_IMM22, "IMM22", 0, false, true),
315 IA64_HOWTO (R_IA64_IMM64, "IMM64", 0, false, true),
316 IA64_HOWTO (R_IA64_DIR32MSB, "DIR32MSB", 2, false, true),
317 IA64_HOWTO (R_IA64_DIR32LSB, "DIR32LSB", 2, false, true),
318 IA64_HOWTO (R_IA64_DIR64MSB, "DIR64MSB", 4, false, true),
319 IA64_HOWTO (R_IA64_DIR64LSB, "DIR64LSB", 4, false, true),
320
321 IA64_HOWTO (R_IA64_GPREL22, "GPREL22", 0, false, true),
322 IA64_HOWTO (R_IA64_GPREL64I, "GPREL64I", 0, false, true),
323 IA64_HOWTO (R_IA64_GPREL32MSB, "GPREL32MSB", 2, false, true),
324 IA64_HOWTO (R_IA64_GPREL32LSB, "GPREL32LSB", 2, false, true),
325 IA64_HOWTO (R_IA64_GPREL64MSB, "GPREL64MSB", 4, false, true),
326 IA64_HOWTO (R_IA64_GPREL64LSB, "GPREL64LSB", 4, false, true),
327
328 IA64_HOWTO (R_IA64_LTOFF22, "LTOFF22", 0, false, true),
329 IA64_HOWTO (R_IA64_LTOFF64I, "LTOFF64I", 0, false, true),
330
331 IA64_HOWTO (R_IA64_PLTOFF22, "PLTOFF22", 0, false, true),
332 IA64_HOWTO (R_IA64_PLTOFF64I, "PLTOFF64I", 0, false, true),
333 IA64_HOWTO (R_IA64_PLTOFF64MSB, "PLTOFF64MSB", 4, false, true),
334 IA64_HOWTO (R_IA64_PLTOFF64LSB, "PLTOFF64LSB", 4, false, true),
335
748abff6 336 IA64_HOWTO (R_IA64_FPTR64I, "FPTR64I", 0, false, true),
800eeca4
JW		 337 IA64_HOWTO (R_IA64_FPTR32MSB, "FPTR32MSB", 2, false, true),
338 IA64_HOWTO (R_IA64_FPTR32LSB, "FPTR32LSB", 2, false, true),
339 IA64_HOWTO (R_IA64_FPTR64MSB, "FPTR64MSB", 4, false, true),
340 IA64_HOWTO (R_IA64_FPTR64LSB, "FPTR64LSB", 4, false, true),
341
748abff6 342 IA64_HOWTO (R_IA64_PCREL60B, "PCREL60B", 0, true, true),
800eeca4
JW		 343 IA64_HOWTO (R_IA64_PCREL21B, "PCREL21B", 0, true, true),
344 IA64_HOWTO (R_IA64_PCREL21M, "PCREL21M", 0, true, true),
345 IA64_HOWTO (R_IA64_PCREL21F, "PCREL21F", 0, true, true),
346 IA64_HOWTO (R_IA64_PCREL32MSB, "PCREL32MSB", 2, true, true),
347 IA64_HOWTO (R_IA64_PCREL32LSB, "PCREL32LSB", 2, true, true),
348 IA64_HOWTO (R_IA64_PCREL64MSB, "PCREL64MSB", 4, true, true),
349 IA64_HOWTO (R_IA64_PCREL64LSB, "PCREL64LSB", 4, true, true),
350
748abff6
RH		 351 IA64_HOWTO (R_IA64_LTOFF_FPTR22, "LTOFF_FPTR22", 0, false, true),
352 IA64_HOWTO (R_IA64_LTOFF_FPTR64I, "LTOFF_FPTR64I", 0, false, true),
800eeca4
JW		 353 IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB, "LTOFF_FPTR64MSB", 4, false, true),
354 IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB, "LTOFF_FPTR64LSB", 4, false, true),
355
356 IA64_HOWTO (R_IA64_SEGBASE, "SEGBASE", 4, false, true),
357 IA64_HOWTO (R_IA64_SEGREL32MSB, "SEGREL32MSB", 2, false, true),
358 IA64_HOWTO (R_IA64_SEGREL32LSB, "SEGREL32LSB", 2, false, true),
359 IA64_HOWTO (R_IA64_SEGREL64MSB, "SEGREL64MSB", 4, false, true),
360 IA64_HOWTO (R_IA64_SEGREL64LSB, "SEGREL64LSB", 4, false, true),
361
362 IA64_HOWTO (R_IA64_SECREL32MSB, "SECREL32MSB", 2, false, true),
363 IA64_HOWTO (R_IA64_SECREL32LSB, "SECREL32LSB", 2, false, true),
364 IA64_HOWTO (R_IA64_SECREL64MSB, "SECREL64MSB", 4, false, true),
365 IA64_HOWTO (R_IA64_SECREL64LSB, "SECREL64LSB", 4, false, true),
366
367 IA64_HOWTO (R_IA64_REL32MSB, "REL32MSB", 2, false, true),
368 IA64_HOWTO (R_IA64_REL32LSB, "REL32LSB", 2, false, true),
369 IA64_HOWTO (R_IA64_REL64MSB, "REL64MSB", 4, false, true),
370 IA64_HOWTO (R_IA64_REL64LSB, "REL64LSB", 4, false, true),
371
372 IA64_HOWTO (R_IA64_LTV32MSB, "LTV32MSB", 2, false, true),
373 IA64_HOWTO (R_IA64_LTV32LSB, "LTV32LSB", 2, false, true),
374 IA64_HOWTO (R_IA64_LTV64MSB, "LTV64MSB", 4, false, true),
375 IA64_HOWTO (R_IA64_LTV64LSB, "LTV64LSB", 4, false, true),
376
748abff6
RH		 377 IA64_HOWTO (R_IA64_PCREL21BI, "PCREL21BI", 0, true, true),
378 IA64_HOWTO (R_IA64_PCREL22, "PCREL22", 0, true, true),
379 IA64_HOWTO (R_IA64_PCREL64I, "PCREL64I", 0, true, true),
380
800eeca4
JW		 381 IA64_HOWTO (R_IA64_IPLTMSB, "IPLTMSB", 4, false, true),
382 IA64_HOWTO (R_IA64_IPLTLSB, "IPLTLSB", 4, false, true),
383 IA64_HOWTO (R_IA64_EPLTMSB, "EPLTMSB", 4, false, true),
384 IA64_HOWTO (R_IA64_EPLTLSB, "EPLTLSB", 4, false, true),
385 IA64_HOWTO (R_IA64_COPY, "COPY", 4, false, true),
386 IA64_HOWTO (R_IA64_LTOFF22X, "LTOFF22X", 0, false, true),
387 IA64_HOWTO (R_IA64_LDXMOV, "LDXMOV", 0, false, true),
388
748abff6 389 IA64_HOWTO (R_IA64_TPREL22, "TPREL22", 0, false, false),
800eeca4
JW		 390 IA64_HOWTO (R_IA64_TPREL64MSB, "TPREL64MSB", 8, false, false),
391 IA64_HOWTO (R_IA64_TPREL64LSB, "TPREL64LSB", 8, false, false),
748abff6 392 IA64_HOWTO (R_IA64_LTOFF_TP22, "LTOFF_TP22", 0, false, false),
800eeca4
JW		 393 };
394
395static unsigned char elf_code_to_howto_index[R_IA64_MAX_RELOC_CODE + 1];
396
397/* Given a BFD reloc type, return the matching HOWTO structure. */
398
399static reloc_howto_type*
400lookup_howto (rtype)
401 unsigned int rtype;
402{
403 static int inited = 0;
404 int i;
405
406 if (!inited)
407 {
408 inited = 1;
409
410 memset (elf_code_to_howto_index, 0xff, sizeof (elf_code_to_howto_index));
411 for (i = 0; i < NELEMS (ia64_howto_table); ++i)
412 elf_code_to_howto_index[ia64_howto_table[i].type] = i;
413 }
414
415 BFD_ASSERT (rtype <= R_IA64_MAX_RELOC_CODE);
416 i = elf_code_to_howto_index[rtype];
417 if (i >= NELEMS (ia64_howto_table))
418 return 0;
419 return ia64_howto_table + i;
420}
421
422static reloc_howto_type*
423elf64_ia64_reloc_type_lookup (abfd, bfd_code)
424 bfd *abfd;
425 bfd_reloc_code_real_type bfd_code;
426{
427 unsigned int rtype;
428
429 switch (bfd_code)
430 {
431 case BFD_RELOC_NONE: rtype = R_IA64_NONE; break;
432
433 case BFD_RELOC_IA64_IMM14: rtype = R_IA64_IMM14; break;
434 case BFD_RELOC_IA64_IMM22: rtype = R_IA64_IMM22; break;
435 case BFD_RELOC_IA64_IMM64: rtype = R_IA64_IMM64; break;
436
437 case BFD_RELOC_IA64_DIR32MSB: rtype = R_IA64_DIR32MSB; break;
438 case BFD_RELOC_IA64_DIR32LSB: rtype = R_IA64_DIR32LSB; break;
439 case BFD_RELOC_IA64_DIR64MSB: rtype = R_IA64_DIR64MSB; break;
440 case BFD_RELOC_IA64_DIR64LSB: rtype = R_IA64_DIR64LSB; break;
441
442 case BFD_RELOC_IA64_GPREL22: rtype = R_IA64_GPREL22; break;
443 case BFD_RELOC_IA64_GPREL64I: rtype = R_IA64_GPREL64I; break;
444 case BFD_RELOC_IA64_GPREL32MSB: rtype = R_IA64_GPREL32MSB; break;
445 case BFD_RELOC_IA64_GPREL32LSB: rtype = R_IA64_GPREL32LSB; break;
446 case BFD_RELOC_IA64_GPREL64MSB: rtype = R_IA64_GPREL64MSB; break;
447 case BFD_RELOC_IA64_GPREL64LSB: rtype = R_IA64_GPREL64LSB; break;
448
449 case BFD_RELOC_IA64_LTOFF22: rtype = R_IA64_LTOFF22; break;
450 case BFD_RELOC_IA64_LTOFF64I: rtype = R_IA64_LTOFF64I; break;
451
452 case BFD_RELOC_IA64_PLTOFF22: rtype = R_IA64_PLTOFF22; break;
453 case BFD_RELOC_IA64_PLTOFF64I: rtype = R_IA64_PLTOFF64I; break;
454 case BFD_RELOC_IA64_PLTOFF64MSB: rtype = R_IA64_PLTOFF64MSB; break;
455 case BFD_RELOC_IA64_PLTOFF64LSB: rtype = R_IA64_PLTOFF64LSB; break;
456 case BFD_RELOC_IA64_FPTR64I: rtype = R_IA64_FPTR64I; break;
457 case BFD_RELOC_IA64_FPTR32MSB: rtype = R_IA64_FPTR32MSB; break;
458 case BFD_RELOC_IA64_FPTR32LSB: rtype = R_IA64_FPTR32LSB; break;
459 case BFD_RELOC_IA64_FPTR64MSB: rtype = R_IA64_FPTR64MSB; break;
460 case BFD_RELOC_IA64_FPTR64LSB: rtype = R_IA64_FPTR64LSB; break;
461
462 case BFD_RELOC_IA64_PCREL21B: rtype = R_IA64_PCREL21B; break;
748abff6 463 case BFD_RELOC_IA64_PCREL21BI: rtype = R_IA64_PCREL21BI; break;
800eeca4
JW		 464 case BFD_RELOC_IA64_PCREL21M: rtype = R_IA64_PCREL21M; break;
465 case BFD_RELOC_IA64_PCREL21F: rtype = R_IA64_PCREL21F; break;
748abff6
RH		 466 case BFD_RELOC_IA64_PCREL22: rtype = R_IA64_PCREL22; break;
467 case BFD_RELOC_IA64_PCREL60B: rtype = R_IA64_PCREL60B; break;
468 case BFD_RELOC_IA64_PCREL64I: rtype = R_IA64_PCREL64I; break;
800eeca4
JW		 469 case BFD_RELOC_IA64_PCREL32MSB: rtype = R_IA64_PCREL32MSB; break;
470 case BFD_RELOC_IA64_PCREL32LSB: rtype = R_IA64_PCREL32LSB; break;
471 case BFD_RELOC_IA64_PCREL64MSB: rtype = R_IA64_PCREL64MSB; break;
472 case BFD_RELOC_IA64_PCREL64LSB: rtype = R_IA64_PCREL64LSB; break;
473
474 case BFD_RELOC_IA64_LTOFF_FPTR22: rtype = R_IA64_LTOFF_FPTR22; break;
475 case BFD_RELOC_IA64_LTOFF_FPTR64I: rtype = R_IA64_LTOFF_FPTR64I; break;
476 case BFD_RELOC_IA64_LTOFF_FPTR64MSB: rtype = R_IA64_LTOFF_FPTR64MSB; break;
477 case BFD_RELOC_IA64_LTOFF_FPTR64LSB: rtype = R_IA64_LTOFF_FPTR64LSB; break;
478
479 case BFD_RELOC_IA64_SEGBASE: rtype = R_IA64_SEGBASE; break;
480 case BFD_RELOC_IA64_SEGREL32MSB: rtype = R_IA64_SEGREL32MSB; break;
481 case BFD_RELOC_IA64_SEGREL32LSB: rtype = R_IA64_SEGREL32LSB; break;
482 case BFD_RELOC_IA64_SEGREL64MSB: rtype = R_IA64_SEGREL64MSB; break;
483 case BFD_RELOC_IA64_SEGREL64LSB: rtype = R_IA64_SEGREL64LSB; break;
484
485 case BFD_RELOC_IA64_SECREL32MSB: rtype = R_IA64_SECREL32MSB; break;
486 case BFD_RELOC_IA64_SECREL32LSB: rtype = R_IA64_SECREL32LSB; break;
487 case BFD_RELOC_IA64_SECREL64MSB: rtype = R_IA64_SECREL64MSB; break;
488 case BFD_RELOC_IA64_SECREL64LSB: rtype = R_IA64_SECREL64LSB; break;
489
490 case BFD_RELOC_IA64_REL32MSB: rtype = R_IA64_REL32MSB; break;
491 case BFD_RELOC_IA64_REL32LSB: rtype = R_IA64_REL32LSB; break;
492 case BFD_RELOC_IA64_REL64MSB: rtype = R_IA64_REL64MSB; break;
493 case BFD_RELOC_IA64_REL64LSB: rtype = R_IA64_REL64LSB; break;
494
495 case BFD_RELOC_IA64_LTV32MSB: rtype = R_IA64_LTV32MSB; break;
496 case BFD_RELOC_IA64_LTV32LSB: rtype = R_IA64_LTV32LSB; break;
497 case BFD_RELOC_IA64_LTV64MSB: rtype = R_IA64_LTV64MSB; break;
498 case BFD_RELOC_IA64_LTV64LSB: rtype = R_IA64_LTV64LSB; break;
499
500 case BFD_RELOC_IA64_IPLTMSB: rtype = R_IA64_IPLTMSB; break;
501 case BFD_RELOC_IA64_IPLTLSB: rtype = R_IA64_IPLTLSB; break;
502 case BFD_RELOC_IA64_EPLTMSB: rtype = R_IA64_EPLTMSB; break;
503 case BFD_RELOC_IA64_EPLTLSB: rtype = R_IA64_EPLTLSB; break;
504 case BFD_RELOC_IA64_COPY: rtype = R_IA64_COPY; break;
505 case BFD_RELOC_IA64_LTOFF22X: rtype = R_IA64_LTOFF22X; break;
506 case BFD_RELOC_IA64_LDXMOV: rtype = R_IA64_LDXMOV; break;
507
508 case BFD_RELOC_IA64_TPREL22: rtype = R_IA64_TPREL22; break;
509 case BFD_RELOC_IA64_TPREL64MSB: rtype = R_IA64_TPREL64MSB; break;
510 case BFD_RELOC_IA64_TPREL64LSB: rtype = R_IA64_TPREL64LSB; break;
511 case BFD_RELOC_IA64_LTOFF_TP22: rtype = R_IA64_LTOFF_TP22; break;
512
513 default: return 0;
514 }
515 return lookup_howto (rtype);
516}
517
518/* Given a ELF reloc, return the matching HOWTO structure. */
519
520static void
521elf64_ia64_info_to_howto (abfd, bfd_reloc, elf_reloc)
522 bfd *abfd;
523 arelent *bfd_reloc;
524 Elf64_Internal_Rela *elf_reloc;
525{
526 bfd_reloc->howto = lookup_howto (ELF64_R_TYPE (elf_reloc->r_info));
527}
528\f
529#define PLT_HEADER_SIZE (3 * 16)
530#define PLT_MIN_ENTRY_SIZE (1 * 16)
531#define PLT_FULL_ENTRY_SIZE (2 * 16)
532#define PLT_RESERVED_WORDS 3
533
534static const bfd_byte plt_header[PLT_HEADER_SIZE] =
535{
536 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
537 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
538 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
539 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
540 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
541 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
542 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
543 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
544 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
545};
546
547static const bfd_byte plt_min_entry[PLT_MIN_ENTRY_SIZE] =
548{
549 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
550 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
551 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
552};
553
554static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] =
555{
556 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
557 0x00, 0x41, 0x3c, 0x30, 0x28, 0xc0, /* ld8 r16=[r15],8 */
558 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
559 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
560 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
561 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
562};
563
564#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
748abff6
RH		 565
566/* Select out of range branch fixup type. Note that Itanium does
567 not support brl, and so it gets emulated by the kernel. */
568#undef USE_BRL
569
570static const bfd_byte oor_brl[16] =
571{
572 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
573 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
574 0x00, 0x00, 0x00, 0xc0
575};
576
577static const bfd_byte oor_ip[48] =
578{
579 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
580 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
581 0x01, 0x00, 0x00, 0x60,
582 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
583 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
584 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
585 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
586 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
587 0x60, 0x00, 0x80, 0x00 /* br b6;; */
588};
589\f
590/* These functions do relaxation for IA-64 ELF.
591
592 This is primarily to support branches to targets out of range;
593 relaxation of R_IA64_LTOFF22X and R_IA64_LDXMOV not yet supported. */
594
595static boolean
596elf64_ia64_relax_section (abfd, sec, link_info, again)
597 bfd *abfd;
598 asection *sec;
599 struct bfd_link_info *link_info;
600 boolean *again;
601{
602 struct one_fixup
603 {
604 struct one_fixup *next;
605 asection *tsec;
606 bfd_vma toff;
607 bfd_vma trampoff;
608 };
609
610 Elf_Internal_Shdr *symtab_hdr;
611 Elf_Internal_Rela *internal_relocs;
612 Elf_Internal_Rela *free_relocs;
613 Elf_Internal_Rela *irel, *irelend;
614 bfd_byte *contents;
615 bfd_byte *free_contents;
616 Elf64_External_Sym *extsyms;
617 Elf64_External_Sym *free_extsyms;
618 struct elf64_ia64_link_hash_table *ia64_info;
619 struct one_fixup *fixups = NULL;
620 boolean changed_contents = false;
621 boolean changed_relocs = false;
622
623 /* Assume we're not going to change any sizes, and we we'll only
624 need one pass. */
625 *again = false;
626
627 /* Nothing to do if there are no relocations. */
628 if ((sec->flags & SEC_RELOC) == 0
629 || sec->reloc_count == 0)
630 return true;
631
632 /* If this is the first time we have been called for this section,
633 initialize the cooked size. */
634 if (sec->_cooked_size == 0)
635 sec->_cooked_size = sec->_raw_size;
636
637 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
638
639 /* Load the relocations for this section. */
640 internal_relocs = (_bfd_elf64_link_read_relocs
641 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
642 link_info->keep_memory));
643 if (internal_relocs == NULL)
644 goto error_return;
645 free_relocs = NULL;
646 if (! link_info->keep_memory)
647 free_relocs = internal_relocs;
648
649 ia64_info = elf64_ia64_hash_table (link_info);
650 irelend = internal_relocs + sec->reloc_count;
651
652 for (irel = internal_relocs; irel < irelend; irel++)
653 if (ELF64_R_TYPE (irel->r_info) == (int) R_IA64_PCREL21B)
654 break;
655
656 /* No branch-type relocations. */
657 if (irel == irelend)
658 {
659 if (free_relocs != NULL)
660 free (free_relocs);
661 return true;
662 }
663
664 /* Get the section contents. */
665 free_contents = NULL;
666 if (elf_section_data (sec)->this_hdr.contents != NULL)
667 contents = elf_section_data (sec)->this_hdr.contents;
668 else
669 {
670 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
671 if (contents == NULL)
672 goto error_return;
673 free_contents = contents;
674
675 if (! bfd_get_section_contents (abfd, sec, contents,
676 (file_ptr) 0, sec->_raw_size))
677 goto error_return;
678 }
679
680 /* Read this BFD's symbols. */
681 free_extsyms = NULL;
682 if (symtab_hdr->contents != NULL)
683 extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
684 else
685 {
686 extsyms = (Elf64_External_Sym *) bfd_malloc (symtab_hdr->sh_size);
687 if (extsyms == NULL)
688 goto error_return;
689 free_extsyms = extsyms;
690 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
691 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
692 != symtab_hdr->sh_size))
693 goto error_return;
694 }
695
696 for (; irel < irelend; irel++)
697 {
698 bfd_vma symaddr, reladdr, trampoff, toff, roff;
699 Elf_Internal_Sym isym;
700 asection *tsec;
701 struct one_fixup *f;
702
703 if (ELF64_R_TYPE (irel->r_info) != (int) R_IA64_PCREL21B)
704 continue;
705
706 /* Get the value of the symbol referred to by the reloc. */
707 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
708 {
709 /* A local symbol. */
710 bfd_elf64_swap_symbol_in (abfd,
711 extsyms + ELF64_R_SYM (irel->r_info),
712 &isym);
713 if (isym.st_shndx == SHN_UNDEF)
714 continue; /* We can't do anthing with undefined symbols. */
715 else if (isym.st_shndx == SHN_ABS)
716 tsec = bfd_abs_section_ptr;
717 else if (isym.st_shndx == SHN_COMMON)
718 tsec = bfd_com_section_ptr;
719 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
720 tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
721 else
722 continue; /* who knows. */
723
724 toff = isym.st_value;
725 }
726 else
727 {
728 unsigned long indx;
729 struct elf_link_hash_entry *h;
730 struct elf64_ia64_dyn_sym_info *dyn_i;
731
732 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
733 h = elf_sym_hashes (abfd)[indx];
734 BFD_ASSERT (h != NULL);
735
736 while (h->root.type == bfd_link_hash_indirect
737 || h->root.type == bfd_link_hash_warning)
738 h = (struct elf_link_hash_entry *) h->root.u.i.link;
739
740 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, false);
741
742 /* For branches to dynamic symbols, we're interested instead
743 in a branch to the PLT entry. */
744 if (dyn_i && dyn_i->want_plt2)
745 {
746 tsec = ia64_info->plt_sec;
747 toff = dyn_i->plt2_offset;
748 }
749 else
750 {
751 /* We can't do anthing with undefined symbols. */
752 if (h->root.type == bfd_link_hash_undefined
753 || h->root.type == bfd_link_hash_undefweak)
754 continue;
755
756 tsec = h->root.u.def.section;
757 toff = h->root.u.def.value;
758 }
759 }
760
761 symaddr = (tsec->output_section->vma
762 + tsec->output_offset
763 + toff
764 + irel->r_addend);
765
766 roff = irel->r_offset;
767 reladdr = (sec->output_section->vma
768 + sec->output_offset
769 + roff) & -4;
770
771 /* If the branch is in range, no need to do anything. */
772 if ((bfd_signed_vma) (symaddr - reladdr) >= -0x1000000
773 && (bfd_signed_vma) (symaddr - reladdr) <= 0x0FFFFF0)
774 continue;
775
776 /* If the branch and target are in the same section, you've
777 got one honking big section and we can't help you. You'll
778 get an error message later. */
779 if (tsec == sec)
780 continue;
781
782 /* Look for an existing fixup to this address. */
783 for (f = fixups; f ; f = f->next)
784 if (f->tsec == tsec && f->toff == toff)
785 break;
786
787 if (f == NULL)
788 {
789 /* Two alternatives: If it's a branch to a PLT entry, we can
790 make a copy of the FULL_PLT entry. Otherwise, we'll have
791 to use a `brl' insn to get where we're going. */
792
793 int size;
794
795 if (tsec == ia64_info->plt_sec)
796 size = sizeof (plt_full_entry);
797 else
798 {
799#ifdef USE_BRL
800 size = sizeof (oor_brl);
801#else
802 size = sizeof (oor_ip);
803#endif
804 }
805
806 /* Resize the current section to make room for the new branch. */
807 trampoff = (sec->_cooked_size + 15) & -16;
808 contents = (bfd_byte *) bfd_realloc (contents, trampoff + size);
809 if (contents == NULL)
810 goto error_return;
811 sec->_cooked_size = trampoff + size;
812
813 if (tsec == ia64_info->plt_sec)
814 {
815 memcpy (contents + trampoff, plt_full_entry, size);
816
817 /* Hijack the old relocation for use as the PLTOFF reloc. */
818 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
819 R_IA64_PLTOFF22);
820 irel->r_offset = trampoff;
821 }
822 else
823 {
824#ifdef USE_BRL
825 memcpy (contents + trampoff, oor_brl, size);
826 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
827 R_IA64_PCREL60B);
828 irel->r_offset = trampoff + 2;
829#else
830 memcpy (contents + trampoff, oor_ip, size);
831 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
832 R_IA64_PCREL64I);
833 irel->r_addend -= 16;
834 irel->r_offset = trampoff + 2;
835#endif
836 }
837
838 /* Record the fixup so we don't do it again this section. */
839 f = (struct one_fixup *) bfd_malloc (sizeof (*f));
840 f->next = fixups;
841 f->tsec = tsec;
842 f->toff = toff;
843 f->trampoff = trampoff;
844 fixups = f;
845 }
846 else
847 {
848 /* Nop out the reloc, since we're finalizing things here. */
849 irel->r_info = ELF64_R_INFO (0, R_IA64_NONE);
850 }
851
852 /* Fix up the existing branch to hit the trampoline. Hope like
853 hell this doesn't overflow too. */
854 if (elf64_ia64_install_value (abfd, contents + roff,
855 f->trampoff - (roff & -4),
856 R_IA64_PCREL21B) != bfd_reloc_ok)
857 goto error_return;
858
859 changed_contents = true;
860 changed_relocs = true;
861 }
862
863 /* Clean up and go home. */
864 while (fixups)
865 {
866 struct one_fixup *f = fixups;
867 fixups = fixups->next;
868 free (f);
869 }
870
871 if (changed_relocs)
872 elf_section_data (sec)->relocs = internal_relocs;
873 else if (free_relocs != NULL)
874 free (free_relocs);
875
876 if (changed_contents)
877 elf_section_data (sec)->this_hdr.contents = contents;
878 else if (free_contents != NULL)
879 {
880 if (! link_info->keep_memory)
881 free (free_contents);
882 else
883 {
884 /* Cache the section contents for elf_link_input_bfd. */
885 elf_section_data (sec)->this_hdr.contents = contents;
886 }
887 }
888
889 if (free_extsyms != NULL)
890 {
891 if (! link_info->keep_memory)
892 free (free_extsyms);
893 else
894 {
895 /* Cache the symbols for elf_link_input_bfd. */
896 symtab_hdr->contents = extsyms;
897 }
898 }
899
900 *again = changed_contents || changed_relocs;
901 return true;
902
903 error_return:
904 if (free_relocs != NULL)
905 free (free_relocs);
906 if (free_contents != NULL)
907 free (free_contents);
908 if (free_extsyms != NULL)
909 free (free_extsyms);
910 return false;
911}
800eeca4
JW		 912\f
913/* Handle an IA-64 specific section when reading an object file. This
914 is called when elfcode.h finds a section with an unknown type. */
915
916static boolean
917elf64_ia64_section_from_shdr (abfd, hdr, name)
918 bfd *abfd;
919 Elf64_Internal_Shdr *hdr;
920 char *name;
921{
922 asection *newsect;
923
924 /* There ought to be a place to keep ELF backend specific flags, but
925 at the moment there isn't one. We just keep track of the
926 sections by their name, instead. Fortunately, the ABI gives
927 suggested names for all the MIPS specific sections, so we will
928 probably get away with this. */
929 switch (hdr->sh_type)
930 {
931 case SHT_IA_64_UNWIND:
932 if (strcmp (name, ELF_STRING_ia64_unwind) != 0)
933 return false;
934 break;
935
936 case SHT_IA_64_EXT:
937 if (strcmp (name, ELF_STRING_ia64_archext) != 0)
938 return false;
939 break;
940
941 default:
942 return false;
943 }
944
945 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
946 return false;
947 newsect = hdr->bfd_section;
948
949 if (hdr->sh_flags & SHF_IA_64_SHORT)
950 newsect->flags |= SEC_SMALL_DATA;
951
952 return true;
953}
954
955/* Set the correct type for an IA-64 ELF section. We do this by the
956 section name, which is a hack, but ought to work. */
957
958static boolean
959elf64_ia64_fake_sections (abfd, hdr, sec)
960 bfd *abfd;
961 Elf64_Internal_Shdr *hdr;
962 asection *sec;
963{
964 register const char *name;
965
966 name = bfd_get_section_name (abfd, sec);
967
968 if (strcmp (name, ELF_STRING_ia64_unwind) == 0)
969 hdr->sh_type = SHT_IA_64_UNWIND;
970 else if (strcmp (name, ELF_STRING_ia64_archext) == 0)
971 hdr->sh_type = SHT_IA_64_EXT;
972 else if (strcmp (name, ".reloc") == 0)
973 /*
974 * This is an ugly, but unfortunately necessary hack that is
975 * needed when producing EFI binaries on IA-64. It tells
976 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
977 * containing ELF relocation info. We need this hack in order to
978 * be able to generate ELF binaries that can be translated into
979 * EFI applications (which are essentially COFF objects). Those
980 * files contain a COFF ".reloc" section inside an ELF64 object,
981 * which would normally cause BFD to segfault because it would
982 * attempt to interpret this section as containing relocation
983 * entries for section "oc". With this hack enabled, ".reloc"
984 * will be treated as a normal data section, which will avoid the
985 * segfault. However, you won't be able to create an ELF64 binary
986 * with a section named "oc" that needs relocations, but that's
987 * the kind of ugly side-effects you get when detecting section
988 * types based on their names... In practice, this limitation is
989 * unlikely to bite.
990 */
991 hdr->sh_type = SHT_PROGBITS;
992
993 if (sec->flags & SEC_SMALL_DATA)
994 hdr->sh_flags |= SHF_IA_64_SHORT;
995
996 return true;
997}
998
999/* Hook called by the linker routine which adds symbols from an object
1000 file. We use it to put .comm items in .sbss, and not .bss. */
1001
1002static boolean
1003elf64_ia64_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1004 bfd *abfd;
1005 struct bfd_link_info *info;
1006 const Elf_Internal_Sym *sym;
1007 const char **namep;
1008 flagword *flagsp;
1009 asection **secp;
1010 bfd_vma *valp;
1011{
1012 if (sym->st_shndx == SHN_COMMON
1013 && !info->relocateable
1014 && sym->st_size <= bfd_get_gp_size (abfd))
1015 {
1016 /* Common symbols less than or equal to -G nn bytes are
1017 automatically put into .sbss. */
1018
1019 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1020
1021 if (scomm == NULL)
1022 {
1023 scomm = bfd_make_section (abfd, ".scommon");
1024 if (scomm == NULL
1025 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1026 | SEC_IS_COMMON
1027 | SEC_LINKER_CREATED)))
1028 return false;
1029 }
1030
1031 *secp = scomm;
1032 *valp = sym->st_size;
1033 }
1034
1035 return true;
1036}
1037
1038/* Return the number of additional phdrs we will need. */
1039
1040static int
1041elf64_ia64_additional_program_headers (abfd)
1042 bfd *abfd;
1043{
1044 asection *s;
1045 int ret = 0;
1046
1047 /* See if we need a PT_IA_64_ARCHEXT segment. */
1048 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1049 if (s && (s->flags & SEC_LOAD))
1050 ++ret;
1051
1052 /* See if we need a PT_IA_64_UNWIND segment. */
1053 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
1054 if (s && (s->flags & SEC_LOAD))
1055 ++ret;
1056
1057 return ret;
1058}
1059
1060static boolean
1061elf64_ia64_modify_segment_map (abfd)
1062 bfd *abfd;
1063{
1064 struct elf_segment_map *m, **pm;
1065 asection *s;
1066
1067 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1068 all PT_LOAD segments. */
1069 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1070 if (s && (s->flags & SEC_LOAD))
1071 {
1072 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1073 if (m->p_type == PT_IA_64_ARCHEXT)
1074 break;
1075 if (m == NULL)
1076 {
1077 m = (struct elf_segment_map *) bfd_zalloc (abfd, sizeof *m);
1078 if (m == NULL)
1079 return false;
1080
1081 m->p_type = PT_IA_64_ARCHEXT;
1082 m->count = 1;
1083 m->sections[0] = s;
1084
1085 /* We want to put it after the PHDR and INTERP segments. */
1086 pm = &elf_tdata (abfd)->segment_map;
1087 while (*pm != NULL
1088 && ((*pm)->p_type == PT_PHDR
1089 || (*pm)->p_type == PT_INTERP))
1090 pm = &(*pm)->next;
1091
1092 m->next = *pm;
1093 *pm = m;
1094 }
1095 }
1096
1097 /* Install the PT_IA_64_UNWIND segment, if needed. */
1098 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
1099 if (s && (s->flags & SEC_LOAD))
1100 {
1101 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1102 if (m->p_type == PT_IA_64_UNWIND)
1103 break;
1104 if (m == NULL)
1105 {
1106 m = (struct elf_segment_map *) bfd_zalloc (abfd, sizeof *m);
1107 if (m == NULL)
1108 return false;
1109
1110 m->p_type = PT_IA_64_UNWIND;
1111 m->count = 1;
1112 m->sections[0] = s;
1113 m->next = NULL;
1114
1115 /* We want to put it last. */
1116 pm = &elf_tdata (abfd)->segment_map;
1117 while (*pm != NULL)
1118 pm = &(*pm)->next;
1119 *pm = m;
1120 }
1121 }
1122
1123 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1124 the input sections for each output section in the segment and testing
1125 for SHF_IA_64_NORECOV on each. */
1126 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1127 if (m->p_type == PT_LOAD)
1128 {
1129 int i;
1130 for (i = m->count - 1; i >= 0; --i)
1131 {
1132 struct bfd_link_order *order = m->sections[i]->link_order_head;
1133 while (order)
1134 {
1135 if (order->type == bfd_indirect_link_order)
1136 {
1137 asection *is = order->u.indirect.section;
1138 bfd_vma flags = elf_section_data(is)->this_hdr.sh_flags;
1139 if (flags & SHF_IA_64_NORECOV)
1140 {
1141 m->p_flags |= PF_IA_64_NORECOV;
1142 goto found;
1143 }
1144 }
1145 order = order->next;
1146 }
1147 }
1148 found:;
1149 }
1150
1151 return true;
1152}
1153
1154
1155/* According to the Tahoe assembler spec, all labels starting with a
1156 '.' are local. */
1157
1158static boolean
1159elf64_ia64_is_local_label_name (abfd, name)
1160 bfd *abfd;
1161 const char *name;
1162{
1163 return name[0] == '.';
1164}
1165
1166/* Should we do dynamic things to this symbol? */
1167
1168static boolean
1169elf64_ia64_dynamic_symbol_p (h, info)
1170 struct elf_link_hash_entry *h;
1171 struct bfd_link_info *info;
1172{
1173 if (h == NULL)
1174 return false;
1175
1176 while (h->root.type == bfd_link_hash_indirect
1177 || h->root.type == bfd_link_hash_warning)
1178 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1179
1180 if (h->dynindx == -1)
1181 return false;
1182
1183 if (h->root.type == bfd_link_hash_undefweak
1184 || h->root.type == bfd_link_hash_defweak)
1185 return true;
1186
1187 if ((info->shared && !info->symbolic)
1188 || ((h->elf_link_hash_flags
1189 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
1190 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
1191 return true;
1192
1193 return false;
1194}
1195\f
1196static boolean
1197elf64_ia64_local_hash_table_init (ht, abfd, new)
1198 struct elf64_ia64_local_hash_table *ht;
1199 bfd *abfd;
1200 new_hash_entry_func new;
1201{
1202 memset (ht, 0, sizeof(*ht));
1203 return bfd_hash_table_init (&ht->root, new);
1204}
1205
1206static struct bfd_hash_entry*
1207elf64_ia64_new_loc_hash_entry (entry, table, string)
1208 struct bfd_hash_entry *entry;
1209 struct bfd_hash_table *table;
1210 const char *string;
1211{
1212 struct elf64_ia64_local_hash_entry *ret;
1213 ret = (struct elf64_ia64_local_hash_entry *) entry;
1214
1215 /* Allocate the structure if it has not already been allocated by a
1216 subclass. */
1217 if (!ret)
1218 ret = bfd_hash_allocate (table, sizeof (*ret));
1219
1220 if (!ret)
1221 return 0;
1222
1223 /* Initialize our local data. All zeros, and definitely easier
1224 than setting a handful of bit fields. */
1225 memset (ret, 0, sizeof(*ret));
1226
1227 /* Call the allocation method of the superclass. */
1228 ret = ((struct elf64_ia64_local_hash_entry *)
1229 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
1230
1231 return (struct bfd_hash_entry *) ret;
1232}
1233
1234static struct bfd_hash_entry*
1235elf64_ia64_new_elf_hash_entry (entry, table, string)
1236 struct bfd_hash_entry *entry;
1237 struct bfd_hash_table *table;
1238 const char *string;
1239{
1240 struct elf64_ia64_link_hash_entry *ret;
1241 ret = (struct elf64_ia64_link_hash_entry *) entry;
1242
1243 /* Allocate the structure if it has not already been allocated by a
1244 subclass. */
1245 if (!ret)
1246 ret = bfd_hash_allocate (table, sizeof (*ret));
1247
1248 if (!ret)
1249 return 0;
1250
1251 /* Initialize our local data. All zeros, and definitely easier
1252 than setting a handful of bit fields. */
1253 memset (ret, 0, sizeof(*ret));
1254
1255 /* Call the allocation method of the superclass. */
1256 ret = ((struct elf64_ia64_link_hash_entry *)
1257 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1258 table, string));
1259
1260 return (struct bfd_hash_entry *) ret;
1261}
1262
1263static void
1264elf64_ia64_hash_copy_indirect (xdir, xind)
1265 struct elf_link_hash_entry *xdir, *xind;
1266{
1267 struct elf64_ia64_link_hash_entry *dir, *ind;
1268
1269 dir = (struct elf64_ia64_link_hash_entry *)xdir;
1270 ind = (struct elf64_ia64_link_hash_entry *)xind;
1271
1272 /* Copy down any references that we may have already seen to the
1273 symbol which just became indirect. */
1274
1275 dir->root.elf_link_hash_flags |=
1276 (ind->root.elf_link_hash_flags
1277 & (ELF_LINK_HASH_REF_DYNAMIC
1278 | ELF_LINK_HASH_REF_REGULAR
1279 | ELF_LINK_HASH_REF_REGULAR_NONWEAK));
1280
1281 /* Copy over the got and plt data. This would have been done
1282 by check_relocs. */
1283
1284 if (dir->info == NULL)
1285 {
1286 struct elf64_ia64_dyn_sym_info *dyn_i;
1287
1288 dir->info = dyn_i = ind->info;
1289 ind->info = NULL;
1290
1291 /* Fix up the dyn_sym_info pointers to the global symbol. */
1292 for (; dyn_i; dyn_i = dyn_i->next)
1293 dyn_i->h = &dir->root;
1294 }
1295 BFD_ASSERT (ind->info == NULL);
1296
1297 /* Copy over the dynindx. */
1298
1299 if (dir->root.dynindx == -1)
1300 {
1301 dir->root.dynindx = ind->root.dynindx;
1302 dir->root.dynstr_index = ind->root.dynstr_index;
1303 ind->root.dynindx = -1;
1304 ind->root.dynstr_index = 0;
1305 }
1306 BFD_ASSERT (ind->root.dynindx == -1);
1307}
1308
1309static void
1310elf64_ia64_hash_hide_symbol (xh)
1311 struct elf_link_hash_entry *xh;
1312{
1313 struct elf64_ia64_link_hash_entry *h;
1314 struct elf64_ia64_dyn_sym_info *dyn_i;
1315
1316 h = (struct elf64_ia64_link_hash_entry *)xh;
1317
1318 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1319 h->root.dynindx = -1;
1320
1321 for (dyn_i = h->info; dyn_i; dyn_i = dyn_i->next)
1322 dyn_i->want_plt2 = 0;
1323}
1324
1325/* Create the derived linker hash table. The IA-64 ELF port uses this
1326 derived hash table to keep information specific to the IA-64 ElF
1327 linker (without using static variables). */
1328
1329static struct bfd_link_hash_table*
1330elf64_ia64_hash_table_create (abfd)
1331 bfd *abfd;
1332{
1333 struct elf64_ia64_link_hash_table *ret;
1334
1335 ret = bfd_alloc (abfd, sizeof (*ret));
1336 if (!ret)
1337 return 0;
1338 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1339 elf64_ia64_new_elf_hash_entry))
1340 {
1341 bfd_release (abfd, ret);
1342 return 0;
1343 }
1344
1345 if (!elf64_ia64_local_hash_table_init (&ret->loc_hash_table, abfd,
1346 elf64_ia64_new_loc_hash_entry))
1347 return 0;
1348 return &ret->root.root;
1349}
1350
1351/* Look up an entry in a Alpha ELF linker hash table. */
1352
1353static INLINE struct elf64_ia64_local_hash_entry *
1354elf64_ia64_local_hash_lookup(table, string, create, copy)
1355 struct elf64_ia64_local_hash_table *table;
1356 const char *string;
1357 boolean create, copy;
1358{
1359 return ((struct elf64_ia64_local_hash_entry *)
1360 bfd_hash_lookup (&table->root, string, create, copy));
1361}
1362
1363/* Traverse both local and global hash tables. */
1364
1365struct elf64_ia64_dyn_sym_traverse_data
1366{
1367 boolean (*func) PARAMS ((struct elf64_ia64_dyn_sym_info *, PTR));
1368 PTR data;
1369};
1370
1371static boolean
1372elf64_ia64_global_dyn_sym_thunk (xentry, xdata)
1373 struct bfd_hash_entry *xentry;
1374 PTR xdata;
1375{
1376 struct elf64_ia64_link_hash_entry *entry
1377 = (struct elf64_ia64_link_hash_entry *) xentry;
1378 struct elf64_ia64_dyn_sym_traverse_data *data
1379 = (struct elf64_ia64_dyn_sym_traverse_data *) xdata;
1380 struct elf64_ia64_dyn_sym_info *dyn_i;
1381
1382 for (dyn_i = entry->info; dyn_i; dyn_i = dyn_i->next)
1383 if (! (*data->func) (dyn_i, data->data))
1384 return false;
1385 return true;
1386}
1387
1388static boolean
1389elf64_ia64_local_dyn_sym_thunk (xentry, xdata)
1390 struct bfd_hash_entry *xentry;
1391 PTR xdata;
1392{
1393 struct elf64_ia64_local_hash_entry *entry
1394 = (struct elf64_ia64_local_hash_entry *) xentry;
1395 struct elf64_ia64_dyn_sym_traverse_data *data
1396 = (struct elf64_ia64_dyn_sym_traverse_data *) xdata;
1397 struct elf64_ia64_dyn_sym_info *dyn_i;
1398
1399 for (dyn_i = entry->info; dyn_i; dyn_i = dyn_i->next)
1400 if (! (*data->func) (dyn_i, data->data))
1401 return false;
1402 return true;
1403}
1404
1405static void
1406elf64_ia64_dyn_sym_traverse (ia64_info, func, data)
1407 struct elf64_ia64_link_hash_table *ia64_info;
1408 boolean (*func) PARAMS ((struct elf64_ia64_dyn_sym_info *, PTR));
1409 PTR data;
1410{
1411 struct elf64_ia64_dyn_sym_traverse_data xdata;
1412
1413 xdata.func = func;
1414 xdata.data = data;
1415
1416 elf_link_hash_traverse (&ia64_info->root,
1417 elf64_ia64_global_dyn_sym_thunk, &xdata);
1418 bfd_hash_traverse (&ia64_info->loc_hash_table.root,
1419 elf64_ia64_local_dyn_sym_thunk, &xdata);
1420}
1421\f
1422static boolean
1423elf64_ia64_create_dynamic_sections (abfd, info)
1424 bfd *abfd;
1425 struct bfd_link_info *info;
1426{
1427 struct elf64_ia64_link_hash_table *ia64_info;
1428 struct elf_link_hash_entry *h;
1429 asection *s;
1430
1431 if (! _bfd_elf_create_dynamic_sections (abfd, info))
1432 return false;
1433
1434 ia64_info = elf64_ia64_hash_table (info);
1435
1436 ia64_info->plt_sec = bfd_get_section_by_name (abfd, ".plt");
1437 ia64_info->got_sec = bfd_get_section_by_name (abfd, ".got");
1438
1439 {
1440 flagword flags = bfd_get_section_flags (abfd, ia64_info->got_sec);
1441 bfd_set_section_flags (abfd, ia64_info->got_sec, SEC_SMALL_DATA | flags);
1442 }
1443
1444 if (!get_pltoff (abfd, info, ia64_info))
1445 return false;
1446
1447 s = bfd_make_section(abfd, ".rela.IA_64.pltoff");
1448 if (s == NULL
1449 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1450 | SEC_HAS_CONTENTS
1451 | SEC_IN_MEMORY
1452 | SEC_LINKER_CREATED
1453 | SEC_READONLY))
1454 || !bfd_set_section_alignment (abfd, s, 3))
1455 return false;
1456 ia64_info->rel_pltoff_sec = s;
1457
1458 s = bfd_make_section(abfd, ".rela.got");
1459 if (s == NULL
1460 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1461 | SEC_HAS_CONTENTS
1462 | SEC_IN_MEMORY
1463 | SEC_LINKER_CREATED
1464 | SEC_READONLY))
1465 || !bfd_set_section_alignment (abfd, s, 3))
1466 return false;
1467 ia64_info->rel_got_sec = s;
1468
1469 return true;
1470}
1471
1472/* Find and/or create a descriptor for dynamic symbol info. This will
1473 vary based on global or local symbol, and the addend to the reloc. */
1474
1475static struct elf64_ia64_dyn_sym_info *
1476get_dyn_sym_info (ia64_info, h, abfd, rel, create)
1477 struct elf64_ia64_link_hash_table *ia64_info;
1478 struct elf_link_hash_entry *h;
1479 bfd *abfd;
1480 const Elf_Internal_Rela *rel;
1481 boolean create;
1482{
1483 struct elf64_ia64_dyn_sym_info **pp;
1484 struct elf64_ia64_dyn_sym_info *dyn_i;
1485 bfd_vma addend = rel ? rel->r_addend : 0;
1486
1487 if (h)
1488 pp = &((struct elf64_ia64_link_hash_entry *)h)->info;
1489 else
1490 {
1491 struct elf64_ia64_local_hash_entry *loc_h;
1492 char *addr_name;
1493 size_t len;
1494
1495 /* Construct a string for use in the elf64_ia64_local_hash_table.
1496 The name describes what was once anonymous memory. */
1497
1498 len = sizeof(void*)*2 + 1 + sizeof(bfd_vma)*4 + 1 + 1;
1499 len += 10; /* %p slop */
1500
1501 addr_name = alloca (len);
1502 sprintf (addr_name, "%p:%lx", abfd, ELF64_R_SYM (rel->r_info));
1503
1504 /* Collect the canonical entry data for this address. */
1505 loc_h = elf64_ia64_local_hash_lookup (&ia64_info->loc_hash_table,
1506 addr_name, create, create);
1507 BFD_ASSERT (loc_h);
1508
1509 pp = &loc_h->info;
1510 }
1511
1512 for (dyn_i = *pp; dyn_i && dyn_i->addend != addend; dyn_i = *pp)
1513 pp = &dyn_i->next;
1514
1515 if (dyn_i == NULL && create)
1516 {
1517 dyn_i = (struct elf64_ia64_dyn_sym_info *)
1518 bfd_zalloc (abfd, sizeof *dyn_i);
1519 *pp = dyn_i;
1520 dyn_i->addend = addend;
1521 }
1522
1523 return dyn_i;
1524}
1525
1526static asection *
1527get_got (abfd, info, ia64_info)
1528 bfd *abfd;
1529 struct bfd_link_info *info;
1530 struct elf64_ia64_link_hash_table *ia64_info;
1531{
1532 asection *got, *srel;
1533 bfd *dynobj;
1534
1535 got = ia64_info->got_sec;
1536 if (!got)
1537 {
1538 flagword flags;
1539
1540 dynobj = ia64_info->root.dynobj;
1541 if (!dynobj)
1542 ia64_info->root.dynobj = dynobj = abfd;
1543 if (!_bfd_elf_create_got_section (dynobj, info))
1544 return 0;
1545
1546 got = bfd_get_section_by_name (dynobj, ".got");
1547 BFD_ASSERT (got);
1548 ia64_info->got_sec = got;
1549
1550 flags = bfd_get_section_flags (abfd, got);
1551 bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags);
1552 }
1553
1554 return got;
1555}
1556
1557/* Create function descriptor section (.opd). This section is called .opd
1558 because it contains "official prodecure descriptors". The "official"
1559 refers to the fact that these descriptors are used when taking the address
1560 of a procedure, thus ensuring a unique address for each procedure. */
1561
1562static asection *
1563get_fptr (abfd, info, ia64_info)
1564 bfd *abfd;
1565 struct bfd_link_info *info;
1566 struct elf64_ia64_link_hash_table *ia64_info;
1567{
1568 asection *fptr;
1569 bfd *dynobj;
1570
1571 fptr = ia64_info->fptr_sec;
1572 if (!fptr)
1573 {
1574 dynobj = ia64_info->root.dynobj;
1575 if (!dynobj)
1576 ia64_info->root.dynobj = dynobj = abfd;
1577
1578 fptr = bfd_make_section (dynobj, ".opd");
1579 if (!fptr
1580 || !bfd_set_section_flags (dynobj, fptr,
1581 (SEC_ALLOC
1582 | SEC_LOAD
1583 | SEC_HAS_CONTENTS
1584 | SEC_IN_MEMORY
1585 | SEC_READONLY
1586 | SEC_LINKER_CREATED))
1587 || !bfd_set_section_alignment (abfd, fptr, 4))
1588 {
1589 BFD_ASSERT (0);
1590 return NULL;
1591 }
1592
1593 ia64_info->fptr_sec = fptr;
1594 }
1595
1596 return fptr;
1597}
1598
1599static asection *
1600get_pltoff (abfd, info, ia64_info)
1601 bfd *abfd;
1602 struct bfd_link_info *info;
1603 struct elf64_ia64_link_hash_table *ia64_info;
1604{
1605 asection *pltoff;
1606 bfd *dynobj;
1607
1608 pltoff = ia64_info->pltoff_sec;
1609 if (!pltoff)
1610 {
1611 dynobj = ia64_info->root.dynobj;
1612 if (!dynobj)
1613 ia64_info->root.dynobj = dynobj = abfd;
1614
1615 pltoff = bfd_make_section (dynobj, ELF_STRING_ia64_pltoff);
1616 if (!pltoff
1617 || !bfd_set_section_flags (dynobj, pltoff,
1618 (SEC_ALLOC
1619 | SEC_LOAD
1620 | SEC_HAS_CONTENTS
1621 | SEC_IN_MEMORY
1622 | SEC_SMALL_DATA
1623 | SEC_LINKER_CREATED))
1624 || !bfd_set_section_alignment (abfd, pltoff, 4))
1625 {
1626 BFD_ASSERT (0);
1627 return NULL;
1628 }
1629
1630 ia64_info->pltoff_sec = pltoff;
1631 }
1632
1633 return pltoff;
1634}
1635
1636static asection *
1637get_reloc_section (abfd, ia64_info, sec, create)
1638 bfd *abfd;
1639 struct elf64_ia64_link_hash_table *ia64_info;
1640 asection *sec;
1641 boolean create;
1642{
1643 const char *srel_name;
1644 asection *srel;
1645 bfd *dynobj;
1646
1647 srel_name = (bfd_elf_string_from_elf_section
1648 (abfd, elf_elfheader(abfd)->e_shstrndx,
1649 elf_section_data(sec)->rel_hdr.sh_name));
1650 if (srel_name == NULL)
1651 return NULL;
1652
1653 BFD_ASSERT ((strncmp (srel_name, ".rela", 5) == 0
1654 && strcmp (bfd_get_section_name (abfd, sec),
1655 srel_name+5) == 0)
1656 || (strncmp (srel_name, ".rel", 4) == 0
1657 && strcmp (bfd_get_section_name (abfd, sec),
1658 srel_name+4) == 0));
1659
1660 dynobj = ia64_info->root.dynobj;
1661 if (!dynobj)
1662 ia64_info->root.dynobj = dynobj = abfd;
1663
1664 srel = bfd_get_section_by_name (dynobj, srel_name);
1665 if (srel == NULL && create)
1666 {
1667 srel = bfd_make_section (dynobj, srel_name);
1668 if (srel == NULL
1669 || !bfd_set_section_flags (dynobj, srel,
1670 (SEC_ALLOC
1671 | SEC_LOAD
1672 | SEC_HAS_CONTENTS
1673 | SEC_IN_MEMORY
1674 | SEC_LINKER_CREATED
1675 | SEC_READONLY))
1676 || !bfd_set_section_alignment (dynobj, srel, 3))
1677 return NULL;
1678 }
1679
1680 return srel;
1681}
1682
1683static boolean
1684count_dyn_reloc (abfd, dyn_i, srel, type)
1685 bfd *abfd;
1686 struct elf64_ia64_dyn_sym_info *dyn_i;
1687 asection *srel;
1688 int type;
1689{
1690 struct elf64_ia64_dyn_reloc_entry *rent;
1691
1692 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
1693 if (rent->srel == srel && rent->type == type)
1694 break;
1695
1696 if (!rent)
1697 {
1698 rent = (struct elf64_ia64_dyn_reloc_entry *)
1699 bfd_alloc (abfd, sizeof (*rent));
1700 if (!rent)
1701 return false;
1702
1703 rent->next = dyn_i->reloc_entries;
1704 rent->srel = srel;
1705 rent->type = type;
1706 rent->count = 0;
1707 dyn_i->reloc_entries = rent;
1708 }
1709 rent->count++;
1710
1711 return true;
1712}
1713
1714static boolean
1715elf64_ia64_check_relocs (abfd, info, sec, relocs)
1716 bfd *abfd;
1717 struct bfd_link_info *info;
1718 asection *sec;
1719 const Elf_Internal_Rela *relocs;
1720{
1721 struct elf64_ia64_link_hash_table *ia64_info;
1722 const Elf_Internal_Rela *relend;
1723 Elf_Internal_Shdr *symtab_hdr;
1724 const Elf_Internal_Rela *rel;
1725 asection *got, *fptr, *srel;
1726
1727 if (info->relocateable)
1728 return true;
1729
1730 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1731 ia64_info = elf64_ia64_hash_table (info);
1732
1733 got = fptr = srel = NULL;
1734
1735 relend = relocs + sec->reloc_count;
1736 for (rel = relocs; rel < relend; ++rel)
1737 {
1738 enum {
1739 NEED_GOT = 1,
1740 NEED_FPTR = 2,
1741 NEED_PLTOFF = 4,
1742 NEED_MIN_PLT = 8,
1743 NEED_FULL_PLT = 16,
1744 NEED_DYNREL = 32,
1745 NEED_LTOFF_FPTR = 64,
1746 };
1747
1748 struct elf_link_hash_entry *h = NULL;
1749 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
1750 struct elf64_ia64_dyn_sym_info *dyn_i;
1751 int need_entry;
1752 boolean maybe_dynamic;
1753 int dynrel_type;
1754
1755 if (r_symndx >= symtab_hdr->sh_info)
1756 {
1757 /* We're dealing with a global symbol -- find its hash entry
1758 and mark it as being referenced. */
1759 long indx = r_symndx - symtab_hdr->sh_info;
1760 h = elf_sym_hashes (abfd)[indx];
1761 while (h->root.type == bfd_link_hash_indirect
1762 || h->root.type == bfd_link_hash_warning)
1763 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1764
1765 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
1766 }
1767
1768 /* We can only get preliminary data on whether a symbol is
1769 locally or externally defined, as not all of the input files
1770 have yet been processed. Do something with what we know, as
1771 this may help reduce memory usage and processing time later. */
1772 maybe_dynamic = false;
1773 if (h && ((info->shared && ! info->symbolic)
1774 || ! (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
1775 || h->root.type == bfd_link_hash_defweak))
1776 maybe_dynamic = true;
1777
1778 need_entry = 0;
1779 switch (ELF64_R_TYPE (rel->r_info))
1780 {
1781 case R_IA64_TPREL22:
1782 case R_IA64_TPREL64MSB:
1783 case R_IA64_TPREL64LSB:
1784 case R_IA64_LTOFF_TP22:
1785 return false;
1786
1787 case R_IA64_LTOFF_FPTR22:
1788 case R_IA64_LTOFF_FPTR64I:
1789 case R_IA64_LTOFF_FPTR64MSB:
1790 case R_IA64_LTOFF_FPTR64LSB:
1791 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
1792 break;
1793
1794 case R_IA64_FPTR64I:
1795 case R_IA64_FPTR32MSB:
1796 case R_IA64_FPTR32LSB:
1797 case R_IA64_FPTR64MSB:
1798 case R_IA64_FPTR64LSB:
1799 if (info->shared || h)
1800 need_entry = NEED_FPTR | NEED_DYNREL;
1801 else
1802 need_entry = NEED_FPTR;
1803 dynrel_type = R_IA64_FPTR64LSB;
1804 break;
1805
1806 case R_IA64_LTOFF22:
1807 case R_IA64_LTOFF22X:
1808 case R_IA64_LTOFF64I:
1809 need_entry = NEED_GOT;
1810 break;
1811
1812 case R_IA64_PLTOFF22:
1813 case R_IA64_PLTOFF64I:
1814 case R_IA64_PLTOFF64MSB:
1815 case R_IA64_PLTOFF64LSB:
1816 need_entry = NEED_PLTOFF;
1817 if (h)
1818 {
1819 if (maybe_dynamic)
1820 need_entry |= NEED_MIN_PLT;
1821 }
1822 else
1823 {
1824 (*info->callbacks->warning)
1825 (info, _("@pltoff reloc against local symbol"), 0,
1826 abfd, 0, 0);
1827 }
1828 break;
1829
1830 case R_IA64_PCREL21B:
748abff6 1831 case R_IA64_PCREL60B:
800eeca4
JW		 1832 /* Depending on where this symbol is defined, we may or may not
1833 need a full plt entry. Only skip if we know we'll not need
1834 the entry -- static or symbolic, and the symbol definition
1835 has already been seen. */
1836 if (maybe_dynamic && rel->r_addend == 0)
1837 need_entry = NEED_FULL_PLT;
1838 break;
1839
1840 case R_IA64_IMM14:
1841 case R_IA64_IMM22:
1842 case R_IA64_IMM64:
1843 case R_IA64_DIR32MSB:
1844 case R_IA64_DIR32LSB:
1845 case R_IA64_DIR64MSB:
1846 case R_IA64_DIR64LSB:
1847 /* Shared objects will always need at least a REL relocation. */
1848 if (info->shared || maybe_dynamic)
1849 need_entry = NEED_DYNREL;
1850 dynrel_type = R_IA64_DIR64LSB;
1851 break;
1852
748abff6
RH		 1853 case R_IA64_PCREL22:
1854 case R_IA64_PCREL64I:
800eeca4
JW		 1855 case R_IA64_PCREL32MSB:
1856 case R_IA64_PCREL32LSB:
1857 case R_IA64_PCREL64MSB:
1858 case R_IA64_PCREL64LSB:
1859 if (maybe_dynamic)
1860 need_entry = NEED_DYNREL;
1861 dynrel_type = R_IA64_PCREL64LSB;
1862 break;
1863 }
1864
1865 if (!need_entry)
1866 continue;
1867
1868 if ((need_entry & NEED_FPTR) != 0
1869 && rel->r_addend)
1870 {
1871 (*info->callbacks->warning)
1872 (info, _("non-zero addend in @fptr reloc"), 0,
1873 abfd, 0, 0);
1874 }
1875
1876 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, true);
1877
1878 /* Record whether or not this is a local symbol. */
1879 dyn_i->h = h;
1880
1881 /* Create what's needed. */
1882 if (need_entry & NEED_GOT)
1883 {
1884 if (!got)
1885 {
1886 got = get_got (abfd, info, ia64_info);
1887 if (!got)
1888 return false;
1889 }
1890 dyn_i->want_got = 1;
1891 }
1892 if (need_entry & NEED_FPTR)
1893 {
1894 if (!fptr)
1895 {
1896 fptr = get_fptr (abfd, info, ia64_info);
1897 if (!fptr)
1898 return false;
1899 }
1900
1901 /* FPTRs for shared libraries are allocated by the dynamic
1902 linker. Make sure this local symbol will appear in the
1903 dynamic symbol table. */
1904 if (!h && info->shared)
1905 {
1906 if (! (_bfd_elf64_link_record_local_dynamic_symbol
1907 (info, abfd, r_symndx)))
1908 return false;
1909 }
1910
1911 dyn_i->want_fptr = 1;
1912 }
1913 if (need_entry & NEED_LTOFF_FPTR)
1914 dyn_i->want_ltoff_fptr = 1;
1915 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
1916 {
1917 if (!ia64_info->root.dynobj)
1918 ia64_info->root.dynobj = abfd;
1919 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1920 dyn_i->want_plt = 1;
1921 }
1922 if (need_entry & NEED_FULL_PLT)
1923 dyn_i->want_plt2 = 1;
1924 if (need_entry & NEED_PLTOFF)
1925 dyn_i->want_pltoff = 1;
1926 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
1927 {
1928 if (!srel)
1929 {
1930 srel = get_reloc_section (abfd, ia64_info, sec, true);
1931 if (!srel)
1932 return false;
1933 }
1934 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type))
1935 return false;
1936 }
1937 }
1938
1939 return true;
1940}
1941
1942struct elf64_ia64_allocate_data
1943{
1944 struct bfd_link_info *info;
1945 bfd_size_type ofs;
1946};
1947
1948/* For cleanliness, and potentially faster dynamic loading, allocate
1949 external GOT entries first. */
1950
1951static boolean
1952allocate_global_data_got (dyn_i, data)
1953 struct elf64_ia64_dyn_sym_info *dyn_i;
1954 PTR data;
1955{
1956 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
1957
1958 if (dyn_i->want_got
1959 && ! dyn_i->want_fptr
1960 && elf64_ia64_dynamic_symbol_p (dyn_i->h, x->info))
1961 {
1962 dyn_i->got_offset = x->ofs;
1963 x->ofs += 8;
1964 }
1965 return true;
1966}
1967
1968/* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
1969
1970static boolean
1971allocate_global_fptr_got (dyn_i, data)
1972 struct elf64_ia64_dyn_sym_info *dyn_i;
1973 PTR data;
1974{
1975 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
1976
1977 if (dyn_i->want_got
1978 && dyn_i->want_fptr
1979 && elf64_ia64_dynamic_symbol_p (dyn_i->h, x->info))
1980 {
1981 dyn_i->got_offset = x->ofs;
1982 x->ofs += 8;
1983 }
1984 return true;
1985}
1986
1987/* Lastly, allocate all the GOT entries for local data. */
1988
1989static boolean
1990allocate_local_got (dyn_i, data)
1991 struct elf64_ia64_dyn_sym_info *dyn_i;
1992 PTR data;
1993{
1994 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
1995
1996 if (dyn_i->want_got
1997 && ! elf64_ia64_dynamic_symbol_p (dyn_i->h, x->info))
1998 {
1999 dyn_i->got_offset = x->ofs;
2000 x->ofs += 8;
2001 }
2002 return true;
2003}
2004
2005/* Search for the index of a global symbol in it's defining object file. */
2006
2007static unsigned long
2008global_sym_index (h)
2009 struct elf_link_hash_entry *h;
2010{
2011 struct elf_link_hash_entry **p;
2012 bfd *obj;
2013
2014 BFD_ASSERT (h->root.type == bfd_link_hash_defined
2015 || h->root.type == bfd_link_hash_defweak);
2016
2017 obj = h->root.u.def.section->owner;
2018 for (p = elf_sym_hashes (obj); *p != h; ++p)
2019 continue;
2020
2021 return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
2022}
2023
2024/* Allocate function descriptors. We can do these for every function
2025 in a main executable that is not exported. */
2026
2027static boolean
2028allocate_fptr (dyn_i, data)
2029 struct elf64_ia64_dyn_sym_info *dyn_i;
2030 PTR data;
2031{
2032 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2033
2034 if (dyn_i->want_fptr)
2035 {
2036 struct elf_link_hash_entry *h = dyn_i->h;
2037
2038 if (h)
2039 while (h->root.type == bfd_link_hash_indirect
2040 || h->root.type == bfd_link_hash_warning)
2041 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2042
2043 if (x->info->shared)
2044 {
2045 if (h && h->dynindx == -1)
2046 {
2047 BFD_ASSERT ((h->root.type == bfd_link_hash_defined)
2048 || (h->root.type == bfd_link_hash_defweak));
2049
2050 if (!_bfd_elf64_link_record_local_dynamic_symbol
2051 (x->info, h->root.u.def.section->owner,
2052 global_sym_index (h)))
2053 return false;
2054 }
2055
2056 dyn_i->want_fptr = 0;
2057 }
2058 else if (h == NULL || h->dynindx == -1)
2059 {
2060 dyn_i->fptr_offset = x->ofs;
2061 x->ofs += 16;
2062 }
2063 else
2064 dyn_i->want_fptr = 0;
2065 }
2066 return true;
2067}
2068
2069/* Allocate all the minimal PLT entries. */
2070
2071static boolean
2072allocate_plt_entries (dyn_i, data)
2073 struct elf64_ia64_dyn_sym_info *dyn_i;
2074 PTR data;
2075{
2076 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2077
2078 if (dyn_i->want_plt)
2079 {
2080 struct elf_link_hash_entry *h = dyn_i->h;
2081
2082 if (h)
2083 while (h->root.type == bfd_link_hash_indirect
2084 || h->root.type == bfd_link_hash_warning)
2085 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2086
2087 /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT. */
2088 if (elf64_ia64_dynamic_symbol_p (h, x->info))
2089 {
2090 bfd_size_type offset = x->ofs;
2091 if (offset == 0)
2092 offset = PLT_HEADER_SIZE;
2093 dyn_i->plt_offset = offset;
2094 x->ofs = offset + PLT_MIN_ENTRY_SIZE;
2095
2096 dyn_i->want_pltoff = 1;
2097 }
2098 else
2099 {
2100 dyn_i->want_plt = 0;
2101 dyn_i->want_plt2 = 0;
2102 }
2103 }
2104 return true;
2105}
2106
2107/* Allocate all the full PLT entries. */
2108
2109static boolean
2110allocate_plt2_entries (dyn_i, data)
2111 struct elf64_ia64_dyn_sym_info *dyn_i;
2112 PTR data;
2113{
2114 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2115
2116 if (dyn_i->want_plt2)
2117 {
2118 struct elf_link_hash_entry *h = dyn_i->h;
2119 bfd_size_type ofs = x->ofs;
2120
2121 dyn_i->plt2_offset = ofs;
2122 x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2123
2124 while (h->root.type == bfd_link_hash_indirect
2125 || h->root.type == bfd_link_hash_warning)
2126 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2127 dyn_i->h->plt.offset = ofs;
2128 }
2129 return true;
2130}
2131
2132/* Allocate all the PLTOFF entries requested by relocations and
2133 plt entries. We can't share space with allocated FPTR entries,
2134 because the latter are not necessarily addressable by the GP.
2135 ??? Relaxation might be able to determine that they are. */
2136
2137static boolean
2138allocate_pltoff_entries (dyn_i, data)
2139 struct elf64_ia64_dyn_sym_info *dyn_i;
2140 PTR data;
2141{
2142 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2143
2144 if (dyn_i->want_pltoff)
2145 {
2146 dyn_i->pltoff_offset = x->ofs;
2147 x->ofs += 16;
2148 }
2149 return true;
2150}
2151
2152/* Allocate dynamic relocations for those symbols that turned out
2153 to be dynamic. */
2154
2155static boolean
2156allocate_dynrel_entries (dyn_i, data)
2157 struct elf64_ia64_dyn_sym_info *dyn_i;
2158 PTR data;
2159{
2160 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2161 struct elf64_ia64_link_hash_table *ia64_info;
2162 struct elf64_ia64_dyn_reloc_entry *rent;
2163 boolean dynamic_symbol, shared;
2164
2165 ia64_info = elf64_ia64_hash_table (x->info);
2166 dynamic_symbol = elf64_ia64_dynamic_symbol_p (dyn_i->h, x->info);
2167 shared = x->info->shared;
2168
2169 /* Take care of the normal data relocations. */
2170
2171 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2172 {
2173 switch (rent->type)
2174 {
2175 case R_IA64_FPTR64LSB:
2176 /* Allocate one iff !want_fptr, which by this point will
2177 be true only if we're actually allocating one statically
2178 in the main executable. */
2179 if (dyn_i->want_fptr)
2180 continue;
2181 break;
2182 case R_IA64_PCREL64LSB:
2183 if (!dynamic_symbol)
2184 continue;
2185 break;
2186 case R_IA64_DIR64LSB:
2187 if (!dynamic_symbol && !shared)
2188 continue;
2189 break;
2190 }
2191 rent->srel->_raw_size += sizeof (Elf64_External_Rela) * rent->count;
2192 }
2193
2194 /* Take care of the GOT and PLT relocations. */
2195
2196 if (((dynamic_symbol || shared) && dyn_i->want_got)
2197 || (dyn_i->want_ltoff_fptr && dyn_i->h && dyn_i->h->dynindx != -1))
2198 ia64_info->rel_got_sec->_raw_size += sizeof (Elf64_External_Rela);
2199
2200 if (dyn_i->want_pltoff)
2201 {
2202 bfd_size_type t = 0;
2203
2204 /* Dynamic symbols get one IPLT relocation. Local symbols in
2205 shared libraries get two REL relocations. Local symbols in
2206 main applications get nothing. */
2207 if (dynamic_symbol)
2208 t = sizeof (Elf64_External_Rela);
2209 else if (shared)
2210 t = 2 * sizeof (Elf64_External_Rela);
2211
2212 ia64_info->rel_pltoff_sec->_raw_size += t;
2213 }
2214
2215 return true;
2216}
2217
2218static boolean
2219elf64_ia64_adjust_dynamic_symbol (info, h)
2220 struct bfd_link_info *info;
2221 struct elf_link_hash_entry *h;
2222{
2223 /* ??? Undefined symbols with PLT entries should be re-defined
2224 to be the PLT entry. */
2225
2226 /* If this is a weak symbol, and there is a real definition, the
2227 processor independent code will have arranged for us to see the
2228 real definition first, and we can just use the same value. */
2229 if (h->weakdef != NULL)
2230 {
2231 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2232 || h->weakdef->root.type == bfd_link_hash_defweak);
2233 h->root.u.def.section = h->weakdef->root.u.def.section;
2234 h->root.u.def.value = h->weakdef->root.u.def.value;
2235 return true;
2236 }
2237
2238 /* If this is a reference to a symbol defined by a dynamic object which
2239 is not a function, we might allocate the symbol in our .dynbss section
2240 and allocate a COPY dynamic relocation.
2241
2242 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2243 of hackery. */
2244
2245 return true;
2246}
2247
2248static boolean
2249elf64_ia64_size_dynamic_sections (output_bfd, info)
2250 bfd *output_bfd;
2251 struct bfd_link_info *info;
2252{
2253 struct elf64_ia64_allocate_data data;
2254 struct elf64_ia64_link_hash_table *ia64_info;
2255 asection *sec;
2256 bfd *dynobj;
2257 boolean reltext = false;
2258 boolean relplt = false;
2259
2260 dynobj = elf_hash_table(info)->dynobj;
2261 ia64_info = elf64_ia64_hash_table (info);
2262 BFD_ASSERT(dynobj != NULL);
2263 data.info = info;
2264
2265 /* Set the contents of the .interp section to the interpreter. */
2266 if (ia64_info->root.dynamic_sections_created
2267 && !info->shared)
2268 {
2269 sec = bfd_get_section_by_name (dynobj, ".interp");
2270 BFD_ASSERT (sec != NULL);
2271 sec->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
2272 sec->_raw_size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
2273 }
2274
2275 /* DT_INIT and DT_FINI get function descriptors not raw code addresses.
2276 Force their symbols to have pltoff entries so we can use those. */
2277 if (ia64_info->root.dynamic_sections_created)
2278 {
2279 struct elf_link_hash_entry *h;
2280 struct elf64_ia64_dyn_sym_info *dyn_i;
2281
2282 if (info->init_function
2283 && (h = elf_link_hash_lookup (elf_hash_table (info),
2284 info->init_function, false,
2285 false, false))
2286 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
2287 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
2288 {
2289 dyn_i = get_dyn_sym_info (ia64_info, h, output_bfd, NULL, true);
2290 dyn_i->want_pltoff = 1;
2291 }
2292
2293 if (info->fini_function
2294 && (h = elf_link_hash_lookup (elf_hash_table (info),
2295 info->fini_function, false,
2296 false, false))
2297 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
2298 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
2299 {
2300 dyn_i = get_dyn_sym_info (ia64_info, h, output_bfd, NULL, true);
2301 dyn_i->want_pltoff = 1;
2302 }
2303 }
2304
2305 /* Allocate the GOT entries. */
2306
2307 if (ia64_info->got_sec)
2308 {
2309 data.ofs = 0;
2310 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
2311 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
2312 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
2313 ia64_info->got_sec->_raw_size = data.ofs;
2314 }
2315
2316 /* Allocate the FPTR entries. */
2317
2318 if (ia64_info->fptr_sec)
2319 {
2320 data.ofs = 0;
2321 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
2322 ia64_info->fptr_sec->_raw_size = data.ofs;
2323 }
2324
2325 /* Now that we've seen all of the input files, we can decide which
2326 symbols need plt entries. Allocate the minimal PLT entries first.
2327 We do this even though dynamic_sections_created may be false, because
2328 this has the side-effect of clearing want_plt and want_plt2. */
2329
2330 data.ofs = 0;
2331 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
2332
2333 ia64_info->minplt_entries = 0;
2334 if (data.ofs)
2335 {
2336 ia64_info->minplt_entries
2337 = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
2338 }
2339
2340 /* Align the pointer for the plt2 entries. */
2341 data.ofs = (data.ofs + 31) & -32;
2342
2343 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
2344 if (data.ofs != 0)
2345 {
2346 BFD_ASSERT (ia64_info->root.dynamic_sections_created);
2347
2348 ia64_info->plt_sec->_raw_size = data.ofs;
2349
2350 /* If we've got a .plt, we need some extra memory for the dynamic
2351 linker. We stuff these in .got.plt. */
2352 sec = bfd_get_section_by_name (dynobj, ".got.plt");
2353 sec->_raw_size = 8 * PLT_RESERVED_WORDS;
2354 }
2355
2356 /* Allocate the PLTOFF entries. */
2357
2358 if (ia64_info->pltoff_sec)
2359 {
2360 data.ofs = 0;
2361 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
2362 ia64_info->pltoff_sec->_raw_size = data.ofs;
2363 }
2364
2365 if (ia64_info->root.dynamic_sections_created)
2366 {
2367 /* Allocate space for the dynamic relocations that turned out to be
2368 required. */
2369
2370 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
2371 }
2372
2373 /* We have now determined the sizes of the various dynamic sections.
2374 Allocate memory for them. */
2375 for (sec = dynobj->sections; sec != NULL; sec = sec->next)
2376 {
2377 boolean strip;
2378
2379 if (!(sec->flags & SEC_LINKER_CREATED))
2380 continue;
2381
2382 /* If we don't need this section, strip it from the output file.
2383 There were several sections primarily related to dynamic
2384 linking that must be create before the linker maps input
2385 sections to output sections. The linker does that before
2386 bfd_elf_size_dynamic_sections is called, and it is that
2387 function which decides whether anything needs to go into
2388 these sections. */
2389
2390 strip = (sec->_raw_size == 0);
2391
2392 if (sec == ia64_info->got_sec)
2393 strip = false;
2394 else if (sec == ia64_info->rel_got_sec)
2395 {
2396 if (strip)
2397 ia64_info->rel_got_sec = NULL;
2398 else
2399 /* We use the reloc_count field as a counter if we need to
2400 copy relocs into the output file. */
2401 sec->reloc_count = 0;
2402 }
2403 else if (sec == ia64_info->fptr_sec)
2404 {
2405 if (strip)
2406 ia64_info->fptr_sec = NULL;
2407 }
2408 else if (sec == ia64_info->plt_sec)
2409 {
2410 if (strip)
2411 ia64_info->plt_sec = NULL;
2412 }
2413 else if (sec == ia64_info->pltoff_sec)
2414 {
2415 if (strip)
2416 ia64_info->pltoff_sec = NULL;
2417 }
2418 else if (sec == ia64_info->rel_pltoff_sec)
2419 {
2420 if (strip)
2421 ia64_info->rel_pltoff_sec = NULL;
2422 else
2423 {
2424 relplt = true;
2425 /* We use the reloc_count field as a counter if we need to
2426 copy relocs into the output file. */
2427 sec->reloc_count = 0;
2428 }
2429 }
2430 else
2431 {
2432 const char *name;
2433
2434 /* It's OK to base decisions on the section name, because none
2435 of the dynobj section names depend upon the input files. */
2436 name = bfd_get_section_name (dynobj, sec);
2437
2438 if (strcmp (name, ".got.plt") == 0)
2439 strip = false;
2440 else if (strncmp (name, ".rel", 4) == 0)
2441 {
2442 if (!strip)
2443 {
2444 const char *outname;
2445 asection *target;
2446
2447 /* If this relocation section applies to a read only
2448 section, then we probably need a DT_TEXTREL entry. */
2449 outname = bfd_get_section_name (output_bfd,
2450 sec->output_section);
2451 if (outname[4] == 'a')
2452 outname += 5;
2453 else
2454 outname += 4;
2455
2456 target = bfd_get_section_by_name (output_bfd, outname);
2457 if (target != NULL
2458 && (target->flags & SEC_READONLY) != 0
2459 && (target->flags & SEC_ALLOC) != 0)
2460 reltext = true;
2461
2462 /* We use the reloc_count field as a counter if we need to
2463 copy relocs into the output file. */
2464 sec->reloc_count = 0;
2465 }
2466 }
2467 else
2468 continue;
2469 }
2470
2471 if (strip)
2472 _bfd_strip_section_from_output (info, sec);
2473 else
2474 {
2475 /* Allocate memory for the section contents. */
2476 sec->contents = (bfd_byte *) bfd_zalloc(dynobj, sec->_raw_size);
2477 if (sec->contents == NULL && sec->_raw_size != 0)
2478 return false;
2479 }
2480 }
2481
2482 if (elf_hash_table (info)->dynamic_sections_created)
2483 {
2484 /* Add some entries to the .dynamic section. We fill in the values
2485 later (in finish_dynamic_sections) but we must add the entries now
2486 so that we get the correct size for the .dynamic section. */
2487
2488 if (!info->shared)
2489 {
2490 /* The DT_DEBUG entry is filled in by the dynamic linker and used
2491 by the debugger. */
2492 if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
2493 return false;
2494 }
2495
2496 if (! bfd_elf64_add_dynamic_entry (info, DT_IA_64_PLT_RESERVE, 0))
2497 return false;
2498 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
2499 return false;
2500
2501 if (relplt)
2502 {
2503 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2504 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
2505 || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
2506 return false;
2507 }
2508
2509 if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
2510 || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
2511 || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
2512 sizeof(Elf64_External_Rela)))
2513 return false;
2514
2515 if (reltext)
2516 {
2517 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
2518 return false;
2519 }
2520 }
2521
2522 /* ??? Perhaps force __gp local. */
2523
2524 return true;
2525}
2526
2527static bfd_reloc_status_type
2528elf64_ia64_install_value (abfd, hit_addr, val, r_type)
2529 bfd *abfd;
2530 bfd_byte *hit_addr;
2531 bfd_vma val;
2532 unsigned int r_type;
2533{
2534 const struct ia64_operand *op;
2535 int bigendian = 0, shift = 0;
2536 bfd_vma t0, t1, insn, dword;
2537 enum ia64_opnd opnd;
2538 const char *err;
2539 size_t size = 8;
2540
2541 opnd = IA64_OPND_NIL;
2542 switch (r_type)
2543 {
2544 case R_IA64_NONE:
2545 case R_IA64_LDXMOV:
2546 return bfd_reloc_ok;
2547
2548 /* Instruction relocations. */
2549
2550 case R_IA64_IMM14: opnd = IA64_OPND_IMM14; break;
748abff6 2551
800eeca4
JW		 2552 case R_IA64_PCREL21F: opnd = IA64_OPND_TGT25; break;
2553 case R_IA64_PCREL21M: opnd = IA64_OPND_TGT25b; break;
748abff6
RH		 2554 case R_IA64_PCREL60B: opnd = IA64_OPND_TGT64; break;
2555 case R_IA64_PCREL21B:
2556 case R_IA64_PCREL21BI:
2557 opnd = IA64_OPND_TGT25c;
2558 break;
800eeca4
JW		 2559
2560 case R_IA64_IMM22:
2561 case R_IA64_GPREL22:
2562 case R_IA64_LTOFF22:
2563 case R_IA64_LTOFF22X:
2564 case R_IA64_PLTOFF22:
748abff6 2565 case R_IA64_PCREL22:
800eeca4
JW		 2566 case R_IA64_LTOFF_FPTR22:
2567 opnd = IA64_OPND_IMM22;
2568 break;
2569
2570 case R_IA64_IMM64:
2571 case R_IA64_GPREL64I:
2572 case R_IA64_LTOFF64I:
2573 case R_IA64_PLTOFF64I:
748abff6 2574 case R_IA64_PCREL64I:
800eeca4
JW		 2575 case R_IA64_FPTR64I:
2576 case R_IA64_LTOFF_FPTR64I:
2577 opnd = IA64_OPND_IMMU64;
2578 break;
2579
2580 /* Data relocations. */
2581
2582 case R_IA64_DIR32MSB:
2583 case R_IA64_GPREL32MSB:
2584 case R_IA64_FPTR32MSB:
2585 case R_IA64_PCREL32MSB:
2586 case R_IA64_SEGREL32MSB:
2587 case R_IA64_SECREL32MSB:
2588 case R_IA64_LTV32MSB:
2589 size = 4; bigendian = 1;
2590 break;
2591
2592 case R_IA64_DIR32LSB:
2593 case R_IA64_GPREL32LSB:
2594 case R_IA64_FPTR32LSB:
2595 case R_IA64_PCREL32LSB:
2596 case R_IA64_SEGREL32LSB:
2597 case R_IA64_SECREL32LSB:
2598 case R_IA64_LTV32LSB:
2599 size = 4; bigendian = 0;
2600 break;
2601
2602 case R_IA64_DIR64MSB:
2603 case R_IA64_GPREL64MSB:
2604 case R_IA64_PLTOFF64MSB:
2605 case R_IA64_FPTR64MSB:
2606 case R_IA64_PCREL64MSB:
2607 case R_IA64_LTOFF_FPTR64MSB:
2608 case R_IA64_SEGREL64MSB:
2609 case R_IA64_SECREL64MSB:
2610 case R_IA64_LTV64MSB:
2611 size = 8; bigendian = 1;
2612 break;
2613
2614 case R_IA64_DIR64LSB:
2615 case R_IA64_GPREL64LSB:
2616 case R_IA64_PLTOFF64LSB:
2617 case R_IA64_FPTR64LSB:
2618 case R_IA64_PCREL64LSB:
2619 case R_IA64_LTOFF_FPTR64LSB:
2620 case R_IA64_SEGREL64LSB:
2621 case R_IA64_SECREL64LSB:
2622 case R_IA64_LTV64LSB:
2623 size = 8; bigendian = 0;
2624 break;
2625
2626 /* Unsupported / Dynamic relocations. */
2627
2628 case R_IA64_REL32MSB:
2629 case R_IA64_REL32LSB:
2630 case R_IA64_REL64MSB:
2631 case R_IA64_REL64LSB:
2632
2633 case R_IA64_IPLTMSB:
2634 case R_IA64_IPLTLSB:
2635 case R_IA64_EPLTMSB:
2636 case R_IA64_EPLTLSB:
2637 case R_IA64_COPY:
2638
2639 case R_IA64_SEGBASE:
2640
2641 case R_IA64_TPREL22:
2642 case R_IA64_TPREL64MSB:
2643 case R_IA64_TPREL64LSB:
2644 case R_IA64_LTOFF_TP22:
2645
2646 default:
2647 return bfd_reloc_notsupported;
2648 }
2649
2650 switch (opnd)
2651 {
2652 case IA64_OPND_IMMU64:
2653 hit_addr -= (long) hit_addr & 0x3;
2654 t0 = bfd_get_64 (abfd, hit_addr);
2655 t1 = bfd_get_64 (abfd, hit_addr + 8);
2656
2657 /* tmpl/s: bits 0.. 5 in t0
2658 slot 0: bits 5..45 in t0
2659 slot 1: bits 46..63 in t0, bits 0..22 in t1
2660 slot 2: bits 23..63 in t1 */
2661
2662 /* First, clear the bits that form the 64 bit constant. */
2663 t0 &= ~(0x3ffffLL << 46);
2664 t1 &= ~(0x7fffffLL
2665 | (( (0x07fLL << 13) | (0x1ffLL << 27)
2666 | (0x01fLL << 22) | (0x001LL << 21)
2667 | (0x001LL << 36)) << 23));
2668
2669 t0 |= ((val >> 22) & 0x03ffffLL) << 46; /* 18 lsbs of imm41 */
2670 t1 |= ((val >> 40) & 0x7fffffLL) << 0; /* 23 msbs of imm41 */
2671 t1 |= ( (((val >> 0) & 0x07f) << 13) /* imm7b */
2672 | (((val >> 7) & 0x1ff) << 27) /* imm9d */
2673 | (((val >> 16) & 0x01f) << 22) /* imm5c */
2674 | (((val >> 21) & 0x001) << 21) /* ic */
2675 | (((val >> 63) & 0x001) << 36)) << 23; /* i */
2676
2677 bfd_put_64 (abfd, t0, hit_addr);
2678 bfd_put_64 (abfd, t1, hit_addr + 8);
2679 break;
2680
748abff6
RH		 2681 case IA64_OPND_TGT64:
2682 hit_addr -= (long) hit_addr & 0x3;
2683 t0 = bfd_get_64 (abfd, hit_addr);
2684 t1 = bfd_get_64 (abfd, hit_addr + 8);
2685
2686 /* tmpl/s: bits 0.. 5 in t0
2687 slot 0: bits 5..45 in t0
2688 slot 1: bits 46..63 in t0, bits 0..22 in t1
2689 slot 2: bits 23..63 in t1 */
2690
2691 /* First, clear the bits that form the 64 bit constant. */
2692 t0 &= ~(0x3ffffLL << 46);
2693 t1 &= ~(0x7fffffLL
2694 | ((1LL << 36 | 0xfffffLL << 13) << 23));
2695
2696 val >>= 4;
2697 t0 |= ((val >> 20) & 0xffffLL) << 2 << 46; /* 16 lsbs of imm39 */
2698 t1 |= ((val >> 36) & 0x7fffffLL) << 0; /* 23 msbs of imm39 */
2699 t1 |= ((((val >> 0) & 0xfffffLL) << 13) /* imm20b */
2700 | (((val >> 59) & 0x1LL) << 36)) << 23; /* i */
2701
2702 bfd_put_64 (abfd, t0, hit_addr);
2703 bfd_put_64 (abfd, t1, hit_addr + 8);
2704 break;
2705
800eeca4
JW		 2706 default:
2707 switch ((long) hit_addr & 0x3)
2708 {
2709 case 0: shift = 5; break;
2710 case 1: shift = 14; hit_addr += 3; break;
2711 case 2: shift = 23; hit_addr += 6; break;
2712 case 3: return bfd_reloc_notsupported; /* shouldn't happen... */
2713 }
2714 dword = bfd_get_64 (abfd, hit_addr);
2715 insn = (dword >> shift) & 0x1ffffffffffLL;
2716
2717 op = elf64_ia64_operands + opnd;
2718 err = (*op->insert) (op, val, &insn);
2719 if (err)
2720 return bfd_reloc_overflow;
2721
2722 dword &= ~(0x1ffffffffffLL << shift);
2723 dword |= (insn << shift);
2724 bfd_put_64 (abfd, dword, hit_addr);
2725 break;
2726
2727 case IA64_OPND_NIL:
2728 /* A data relocation. */
2729 if (bigendian)
2730 if (size == 4)
2731 bfd_putb32 (val, hit_addr);
2732 else
2733 bfd_putb64 (val, hit_addr);
2734 else
2735 if (size == 4)
2736 bfd_putl32 (val, hit_addr);
2737 else
2738 bfd_putl64 (val, hit_addr);
2739 break;
2740 }
2741
2742 return bfd_reloc_ok;
2743}
2744
2745static void
2746elf64_ia64_install_dyn_reloc (abfd, info, sec, srel, offset, type,
2747 dynindx, addend)
2748 bfd *abfd;
2749 struct bfd_link_info *info;
2750 asection *sec;
2751 asection *srel;
2752 bfd_vma offset;
2753 unsigned int type;
2754 long dynindx;
2755 bfd_vma addend;
2756{
2757 Elf_Internal_Rela outrel;
2758
2759 outrel.r_offset = (sec->output_section->vma
2760 + sec->output_offset
2761 + offset);
2762
2763 BFD_ASSERT (dynindx != -1);
2764 outrel.r_info = ELF64_R_INFO (dynindx, type);
2765 outrel.r_addend = addend;
2766
2767 if (elf_section_data (sec)->stab_info != NULL)
2768 {
2769 /* This may be NULL for linker-generated relocations, as it is
2770 inconvenient to pass all the bits around. And this shouldn't
2771 happen. */
2772 BFD_ASSERT (info != NULL);
2773
2774 offset = (_bfd_stab_section_offset
2775 (abfd, &elf_hash_table (info)->stab_info, sec,
2776 &elf_section_data (sec)->stab_info, offset));
2777 if (offset == (bfd_vma) -1)
2778 {
2779 /* Run for the hills. We shouldn't be outputting a relocation
2780 for this. So do what everyone else does and output a no-op. */
2781 outrel.r_info = ELF64_R_INFO (0, R_IA64_NONE);
2782 outrel.r_addend = 0;
2783 offset = 0;
2784 }
2785 outrel.r_offset = offset;
2786 }
2787
2788 bfd_elf64_swap_reloca_out (abfd, &outrel,
2789 ((Elf64_External_Rela *) srel->contents
2790 + srel->reloc_count++));
2791 BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
2792 <= srel->_cooked_size);
2793}
2794
2795/* Store an entry for target address TARGET_ADDR in the linkage table
2796 and return the gp-relative address of the linkage table entry. */
2797
2798static bfd_vma
2799set_got_entry (abfd, info, dyn_i, dynindx, addend, value, dyn_r_type)
2800 bfd *abfd;
2801 struct bfd_link_info *info;
2802 struct elf64_ia64_dyn_sym_info *dyn_i;
2803 long dynindx;
2804 bfd_vma addend;
2805 bfd_vma value;
2806 unsigned int dyn_r_type;
2807{
2808 struct elf64_ia64_link_hash_table *ia64_info;
2809 asection *got_sec;
2810
2811 ia64_info = elf64_ia64_hash_table (info);
2812 got_sec = ia64_info->got_sec;
2813
2814 BFD_ASSERT ((dyn_i->got_offset & 7) == 0);
2815
2816 if (! dyn_i->got_done)
2817 {
2818 dyn_i->got_done = true;
2819
2820 /* Store the target address in the linkage table entry. */
2821 bfd_put_64 (abfd, value, got_sec->contents + dyn_i->got_offset);
2822
2823 /* Install a dynamic relocation if needed. */
2824 if (info->shared
2825 || elf64_ia64_dynamic_symbol_p (dyn_i->h, info)
2826 || (dynindx != -1 && dyn_r_type == R_IA64_FPTR64LSB))
2827 {
2828 if (dynindx == -1)
2829 {
2830 dyn_r_type = R_IA64_REL64LSB;
2831 dynindx = 0;
2832 addend = value;
2833 }
2834
2835 if (bfd_big_endian (abfd))
2836 {
2837 switch (dyn_r_type)
2838 {
2839 case R_IA64_REL64LSB:
2840 dyn_r_type = R_IA64_REL64MSB;
2841 break;
2842 case R_IA64_DIR64LSB:
2843 dyn_r_type = R_IA64_DIR64MSB;
2844 break;
2845 case R_IA64_FPTR64LSB:
2846 dyn_r_type = R_IA64_FPTR64MSB;
2847 break;
2848 default:
2849 BFD_ASSERT (false);
2850 break;
2851 }
2852 }
2853
2854 elf64_ia64_install_dyn_reloc (abfd, NULL, got_sec,
2855 ia64_info->rel_got_sec,
2856 dyn_i->got_offset, dyn_r_type,
2857 dynindx, addend);
2858 }
2859 }
2860
2861 /* Return the address of the linkage table entry. */
2862 value = (got_sec->output_section->vma
2863 + got_sec->output_offset
2864 + dyn_i->got_offset);
2865
2866 return value;
2867}
2868
2869/* Fill in a function descriptor consisting of the function's code
2870 address and its global pointer. Return the descriptor's address. */
2871
2872static bfd_vma
2873set_fptr_entry (abfd, info, dyn_i, value)
2874 bfd *abfd;
2875 struct bfd_link_info *info;
2876 struct elf64_ia64_dyn_sym_info *dyn_i;
2877 bfd_vma value;
2878{
2879 struct elf64_ia64_link_hash_table *ia64_info;
2880 asection *fptr_sec;
2881
2882 ia64_info = elf64_ia64_hash_table (info);
2883 fptr_sec = ia64_info->fptr_sec;
2884
2885 if (!dyn_i->fptr_done)
2886 {
2887 dyn_i->fptr_done = 1;
2888
2889 /* Fill in the function descriptor. */
2890 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
2891 bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
2892 fptr_sec->contents + dyn_i->fptr_offset + 8);
2893 }
2894
2895 /* Return the descriptor's address. */
2896 value = (fptr_sec->output_section->vma
2897 + fptr_sec->output_offset
2898 + dyn_i->fptr_offset);
2899
2900 return value;
2901}
2902
2903/* Fill in a PLTOFF entry consisting of the function's code address
2904 and its global pointer. Return the descriptor's address. */
2905
2906static bfd_vma
2907set_pltoff_entry (abfd, info, dyn_i, value, is_plt)
2908 bfd *abfd;
2909 struct bfd_link_info *info;
2910 struct elf64_ia64_dyn_sym_info *dyn_i;
2911 bfd_vma value;
2912 boolean is_plt;
2913{
2914 struct elf64_ia64_link_hash_table *ia64_info;
2915 asection *pltoff_sec;
2916
2917 ia64_info = elf64_ia64_hash_table (info);
2918 pltoff_sec = ia64_info->pltoff_sec;
2919
2920 /* Don't do anything if this symbol uses a real PLT entry. In
2921 that case, we'll fill this in during finish_dynamic_symbol. */
2922 if ((! dyn_i->want_plt || is_plt)
2923 && !dyn_i->pltoff_done)
2924 {
2925 /* Fill in the function descriptor. */
2926 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
2927 bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
2928 pltoff_sec->contents + dyn_i->pltoff_offset + 8);
2929
2930 /* Install dynamic relocations if needed. */
2931 if (!is_plt && info->shared)
2932 {
2933 unsigned int dyn_r_type;
2934
2935 if (bfd_big_endian (abfd))
2936 dyn_r_type = R_IA64_REL64MSB;
2937 else
2938 dyn_r_type = R_IA64_REL64LSB;
2939
2940 elf64_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
2941 ia64_info->rel_pltoff_sec,
2942 dyn_i->pltoff_offset,
2943 dyn_r_type, 0, 0);
2944 elf64_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
2945 ia64_info->rel_pltoff_sec,
2946 dyn_i->pltoff_offset + 8,
2947 dyn_r_type, 0, 0);
2948 }
2949
2950 dyn_i->pltoff_done = 1;
2951 }
2952
2953 /* Return the descriptor's address. */
2954 value = (pltoff_sec->output_section->vma
2955 + pltoff_sec->output_offset
2956 + dyn_i->pltoff_offset);
2957
2958 return value;
2959}
2960
2961static boolean
2962elf64_ia64_final_link (abfd, info)
2963 bfd *abfd;
2964 struct bfd_link_info *info;
2965{
2966 struct elf64_ia64_link_hash_table *ia64_info;
2967 ia64_info = elf64_ia64_hash_table (info);
2968
2969 /* Make sure we've got ourselves a nice fat __gp value. */
2970 if (!info->relocateable)
2971 {
2972 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
2973 bfd_vma min_short_vma = min_vma, max_short_vma = 0;
2974 struct elf_link_hash_entry *gp;
2975 bfd_vma gp_val;
2976 asection *os;
2977
2978 /* Find the min and max vma of all sections marked short. Also
2979 collect min and max vma of any type, for use in selecting a
2980 nice gp. */
2981 for (os = abfd->sections; os ; os = os->next)
2982 {
2983 bfd_vma lo, hi;
2984
2985 if ((os->flags & SEC_ALLOC) == 0)
2986 continue;
2987
2988 lo = os->vma;
2989 hi = os->vma + os->_raw_size;
2990 if (hi < lo)
2991 hi = (bfd_vma) -1;
2992
2993 if (min_vma > lo)
2994 min_vma = lo;
2995 if (max_vma < hi)
2996 max_vma = hi;
2997 if (os->flags & SEC_SMALL_DATA)
2998 {
2999 if (min_short_vma > lo)
3000 min_short_vma = lo;
3001 if (max_short_vma < hi)
3002 max_short_vma = hi;
3003 }
3004 }
3005
3006 /* See if the user wants to force a value. */
3007 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false,
3008 false, false);
3009
3010 if (gp
3011 && (gp->root.type == bfd_link_hash_defined
3012 || gp->root.type == bfd_link_hash_defweak))
3013 {
3014 asection *gp_sec = gp->root.u.def.section;
3015 gp_val = (gp->root.u.def.value
3016 + gp_sec->output_section->vma
3017 + gp_sec->output_offset);
3018 }
3019 else
3020 {
3021 /* Pick a sensible value. */
3022
3023 asection *got_sec = ia64_info->got_sec;
3024
3025 /* Start with just the address of the .got. */
3026 if (got_sec)
3027 gp_val = got_sec->output_section->vma;
3028 else if (max_short_vma != 0)
3029 gp_val = min_short_vma;
3030 else
3031 gp_val = min_vma;
3032
3033 /* If it is possible to address the entire image, but we
3034 don't with the choice above, adjust. */
3035 if (max_vma - min_vma < 0x400000
3036 && max_vma - gp_val <= 0x200000
3037 && gp_val - min_vma > 0x200000)
3038 gp_val = min_vma + 0x200000;
3039 else if (max_short_vma != 0)
3040 {
3041 /* If we don't cover all the short data, adjust. */
3042 if (max_short_vma - gp_val >= 0x200000)
3043 gp_val = min_short_vma + 0x200000;
3044
3045 /* If we're addressing stuff past the end, adjust back. */
3046 if (gp_val > max_vma)
3047 gp_val = max_vma - 0x200000 + 8;
3048 }
3049 }
3050
3051 /* Validate whether all SHF_IA_64_SHORT sections are within
3052 range of the chosen GP. */
3053
3054 if (max_short_vma != 0)
3055 {
3056 if (max_short_vma - min_short_vma >= 0x400000)
3057 {
3058 (*_bfd_error_handler)
3059 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3060 bfd_get_filename (abfd),
3061 (unsigned long)(max_short_vma - min_short_vma));
3062 return false;
3063 }
3064 else if ((gp_val > min_short_vma
3065 && gp_val - min_short_vma > 0x200000)
3066 || (gp_val < max_short_vma
3067 && max_short_vma - gp_val >= 0x200000))
3068 {
3069 (*_bfd_error_handler)
3070 (_("%s: __gp does not cover short data segment"),
3071 bfd_get_filename (abfd));
3072 return false;
3073 }
3074 }
3075
3076 _bfd_set_gp_value (abfd, gp_val);
3077 }
3078
3079 /* Tricky bits. DT_INIT and DT_FINI use a pltoff entry, which is
3080 normally initialized in finish_dynamic_sections. Except that
3081 we need all non-plt pltoff entries to be initialized before
3082 finish_dynamic_symbols. This because the array of relocations
3083 used for plt entries (aka DT_JMPREL) begins after all the
3084 non-plt pltoff relocations. If the order gets confused, we
3085 munge either the array or the array base. */
3086 if (ia64_info->root.dynamic_sections_created)
3087 {
3088 struct elf_link_hash_entry *h;
3089 struct elf64_ia64_dyn_sym_info *dyn_i;
3090 bfd_vma addr;
3091
3092 if (info->init_function
3093 && (h = elf_link_hash_lookup (elf_hash_table (info),
3094 info->init_function, false,
3095 false, false))
3096 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
3097 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
3098 {
3099 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
3100 addr = (h->root.u.def.section->output_section->vma
3101 + h->root.u.def.section->output_offset
3102 + h->root.u.def.value);
3103 (void) set_pltoff_entry (abfd, info, dyn_i, addr, false);
3104 }
3105
3106 if (info->fini_function
3107 && (h = elf_link_hash_lookup (elf_hash_table (info),
3108 info->fini_function, false,
3109 false, false))
3110 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
3111 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
3112 {
3113 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
3114 addr = (h->root.u.def.section->output_section->vma
3115 + h->root.u.def.section->output_offset
3116 + h->root.u.def.value);
3117 (void) set_pltoff_entry (abfd, info, dyn_i, addr, false);
3118 }
3119 }
3120
3121 /* Invoke the regular ELF backend linker to do all the work. */
3122 return bfd_elf64_bfd_final_link (abfd, info);
3123}
3124
3125static boolean
3126elf64_ia64_relocate_section (output_bfd, info, input_bfd, input_section,
3127 contents, relocs, local_syms, local_sections)
3128 bfd *output_bfd;
3129 struct bfd_link_info *info;
3130 bfd *input_bfd;
3131 asection *input_section;
3132 bfd_byte *contents;
3133 Elf_Internal_Rela *relocs;
3134 Elf_Internal_Sym *local_syms;
3135 asection **local_sections;
3136{
3137 struct elf64_ia64_link_hash_table *ia64_info;
3138 Elf_Internal_Shdr *symtab_hdr;
3139 Elf_Internal_Rela *rel;
3140 Elf_Internal_Rela *relend;
3141 asection *srel;
3142 boolean ret_val = true; /* for non-fatal errors */
3143 bfd_vma gp_val;
3144
3145 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3146 ia64_info = elf64_ia64_hash_table (info);
3147
3148 /* Infect various flags from the input section to the output section. */
3149 if (info->relocateable)
3150 {
3151 bfd_vma flags;
3152
3153 flags = elf_section_data(input_section)->this_hdr.sh_flags;
3154 flags &= SHF_IA_64_NORECOV;
3155
3156 elf_section_data(input_section->output_section)
3157 ->this_hdr.sh_flags |= flags;
3158 }
3159
3160 gp_val = _bfd_get_gp_value (output_bfd);
3161 srel = get_reloc_section (input_bfd, ia64_info, input_section, false);
3162
3163 rel = relocs;
3164 relend = relocs + input_section->reloc_count;
3165 for (; rel < relend; ++rel)
3166 {
3167 struct elf_link_hash_entry *h;
3168 struct elf64_ia64_dyn_sym_info *dyn_i;
3169 bfd_reloc_status_type r;
3170 reloc_howto_type *howto;
3171 unsigned long r_symndx;
3172 Elf_Internal_Sym *sym;
3173 unsigned int r_type;
3174 bfd_vma value;
3175 asection *sym_sec;
3176 bfd_byte *hit_addr;
3177 boolean dynamic_symbol_p;
3178 boolean undef_weak_ref;
3179
3180 r_type = ELF64_R_TYPE (rel->r_info);
3181 if (r_type > R_IA64_MAX_RELOC_CODE)
3182 {
3183 (*_bfd_error_handler)
3184 (_("%s: unknown relocation type %d"),
3185 bfd_get_filename (input_bfd), (int)r_type);
3186 bfd_set_error (bfd_error_bad_value);
3187 ret_val = false;
3188 continue;
3189 }
3190 howto = lookup_howto (r_type);
3191 r_symndx = ELF64_R_SYM (rel->r_info);
3192
3193 if (info->relocateable)
3194 {
3195 /* This is a relocateable link. We don't have to change
3196 anything, unless the reloc is against a section symbol,
3197 in which case we have to adjust according to where the
3198 section symbol winds up in the output section. */
3199 if (r_symndx < symtab_hdr->sh_info)
3200 {
3201 sym = local_syms + r_symndx;
3202 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3203 {
3204 sym_sec = local_sections[r_symndx];
3205 rel->r_addend += sym_sec->output_offset;
3206 }
3207 }
3208 continue;
3209 }
3210
3211 /* This is a final link. */
3212
3213 h = NULL;
3214 sym = NULL;
3215 sym_sec = NULL;
3216 undef_weak_ref = false;
3217
3218 if (r_symndx < symtab_hdr->sh_info)
3219 {
3220 /* Reloc against local symbol. */
3221 sym = local_syms + r_symndx;
3222 sym_sec = local_sections[r_symndx];
3223 value = (sym_sec->output_section->vma
3224 + sym_sec->output_offset
3225 + sym->st_value);
3226 }
3227 else
3228 {
3229 long indx;
3230
3231 /* Reloc against global symbol. */
3232 indx = r_symndx - symtab_hdr->sh_info;
3233 h = elf_sym_hashes (input_bfd)[indx];
3234 while (h->root.type == bfd_link_hash_indirect
3235 || h->root.type == bfd_link_hash_warning)
3236 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3237
3238 value = 0;
3239 if (h->root.type == bfd_link_hash_defined
3240 || h->root.type == bfd_link_hash_defweak)
3241 {
3242 sym_sec = h->root.u.def.section;
3243
3244 /* Detect the cases that sym_sec->output_section is
3245 expected to be NULL -- all cases in which the symbol
3246 is defined in another shared module. This includes
3247 PLT relocs for which we've created a PLT entry and
3248 other relocs for which we're prepared to create
3249 dynamic relocations. */
3250 /* ??? Just accept it NULL and continue. */
3251
3252 if (sym_sec->output_section != NULL)
3253 {
3254 value = (h->root.u.def.value
3255 + sym_sec->output_section->vma
3256 + sym_sec->output_offset);
3257 }
3258 }
3259 else if (h->root.type == bfd_link_hash_undefweak)
3260 undef_weak_ref = true;
3261 else if (info->shared && !info->symbolic && !info->no_undefined)
3262 ;
3263 else
3264 {
3265 if (! ((*info->callbacks->undefined_symbol)
3266 (info, h->root.root.string, input_bfd,
3267 input_section, rel->r_offset,
3268 (!info->shared || info->no_undefined))))
3269 return false;
3270 ret_val = false;
3271 continue;
3272 }
3273 }
3274
3275 hit_addr = contents + rel->r_offset;
3276 value += rel->r_addend;
3277 dynamic_symbol_p = elf64_ia64_dynamic_symbol_p (h, info);
3278
3279 switch (r_type)
3280 {
3281 case R_IA64_NONE:
3282 case R_IA64_LDXMOV:
3283 continue;
3284
3285 case R_IA64_IMM14:
3286 case R_IA64_IMM22:
3287 case R_IA64_IMM64:
3288 case R_IA64_DIR32MSB:
3289 case R_IA64_DIR32LSB:
3290 case R_IA64_DIR64MSB:
3291 case R_IA64_DIR64LSB:
3292 /* Install a dynamic relocation for this reloc. */
3293 if ((dynamic_symbol_p || info->shared)
3294 && (input_section->flags & SEC_ALLOC) != 0)
3295 {
3296 unsigned int dyn_r_type;
3297 long dynindx;
3298
3299 BFD_ASSERT (srel != NULL);
3300
3301 /* If we don't need dynamic symbol lookup, find a
3302 matching RELATIVE relocation. */
3303 dyn_r_type = r_type;
3304 if (dynamic_symbol_p)
3305 dynindx = h->dynindx;
3306 else
3307 {
3308 switch (r_type)
3309 {
3310 case R_IA64_DIR32MSB:
3311 dyn_r_type = R_IA64_REL32MSB;
3312 break;
3313 case R_IA64_DIR32LSB:
3314 dyn_r_type = R_IA64_REL32LSB;
3315 break;
3316 case R_IA64_DIR64MSB:
3317 dyn_r_type = R_IA64_REL64MSB;
3318 break;
3319 case R_IA64_DIR64LSB:
3320 dyn_r_type = R_IA64_REL64LSB;
3321 break;
3322
3323 default:
3324 /* We can't represent this without a dynamic symbol.
3325 Adjust the relocation to be against an output
3326 section symbol, which are always present in the
3327 dynamic symbol table. */
3328 /* ??? People shouldn't be doing non-pic code in
3329 shared libraries. Hork. */
3330 (*_bfd_error_handler)
3331 (_("%s: linking non-pic code in a shared library"),
3332 bfd_get_filename (input_bfd));
3333 ret_val = false;
3334 continue;
3335 }
3336 dynindx = 0;
3337 }
3338
3339 elf64_ia64_install_dyn_reloc (output_bfd, info, input_section,
3340 srel, rel->r_offset, dyn_r_type,
3341 dynindx, rel->r_addend);
3342 }
3343 /* FALLTHRU */
3344
3345 case R_IA64_LTV32MSB:
3346 case R_IA64_LTV32LSB:
3347 case R_IA64_LTV64MSB:
3348 case R_IA64_LTV64LSB:
3349 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3350 break;
3351
3352 case R_IA64_GPREL22:
3353 case R_IA64_GPREL64I:
3354 case R_IA64_GPREL32MSB:
3355 case R_IA64_GPREL32LSB:
3356 case R_IA64_GPREL64MSB:
3357 case R_IA64_GPREL64LSB:
3358 if (dynamic_symbol_p)
3359 {
3360 (*_bfd_error_handler)
3361 (_("%s: @gprel relocation against dynamic symbol %s"),
3362 bfd_get_filename (input_bfd), h->root.root.string);
3363 ret_val = false;
3364 continue;
3365 }
3366 value -= gp_val;
3367 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3368 break;
3369
3370 case R_IA64_LTOFF22:
3371 case R_IA64_LTOFF22X:
3372 case R_IA64_LTOFF64I:
3373 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3374 value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
3375 rel->r_addend, value, R_IA64_DIR64LSB);
3376 value -= gp_val;
3377 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3378 break;
3379
3380 case R_IA64_PLTOFF22:
3381 case R_IA64_PLTOFF64I:
3382 case R_IA64_PLTOFF64MSB:
3383 case R_IA64_PLTOFF64LSB:
3384 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3385 value = set_pltoff_entry (output_bfd, info, dyn_i, value, false);
3386 value -= gp_val;
3387 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3388 break;
3389
3390 case R_IA64_FPTR64I:
3391 case R_IA64_FPTR32MSB:
3392 case R_IA64_FPTR32LSB:
3393 case R_IA64_FPTR64MSB:
3394 case R_IA64_FPTR64LSB:
3395 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3396 if (dyn_i->want_fptr)
3397 {
3398 if (!undef_weak_ref)
3399 value = set_fptr_entry (output_bfd, info, dyn_i, value);
3400 }
3401 else
3402 {
3403 long dynindx;
3404
3405 /* Otherwise, we expect the dynamic linker to create
3406 the entry. */
3407
3408 if (h)
3409 {
3410 if (h->dynindx != -1)
3411 dynindx = h->dynindx;
3412 else
3413 dynindx = (_bfd_elf_link_lookup_local_dynindx
3414 (info, h->root.u.def.section->owner,
3415 global_sym_index (h)));
3416 }
3417 else
3418 {
3419 dynindx = (_bfd_elf_link_lookup_local_dynindx
3420 (info, input_bfd, r_symndx));
3421 }
3422
3423 elf64_ia64_install_dyn_reloc (output_bfd, info, input_section,
3424 srel, rel->r_offset, r_type,
3425 dynindx, rel->r_addend);
3426 value = 0;
3427 }
3428
3429 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3430 break;
3431
3432 case R_IA64_LTOFF_FPTR22:
3433 case R_IA64_LTOFF_FPTR64I:
3434 case R_IA64_LTOFF_FPTR64MSB:
3435 case R_IA64_LTOFF_FPTR64LSB:
3436 {
3437 long dynindx;
3438
3439 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3440 if (dyn_i->want_fptr)
3441 {
3442 BFD_ASSERT (h == NULL || h->dynindx == -1)
3443 if (!undef_weak_ref)
3444 value = set_fptr_entry (output_bfd, info, dyn_i, value);
3445 dynindx = -1;
3446 }
3447 else
3448 {
3449 /* Otherwise, we expect the dynamic linker to create
3450 the entry. */
3451 if (h)
3452 {
3453 if (h->dynindx != -1)
3454 dynindx = h->dynindx;
3455 else
3456 dynindx = (_bfd_elf_link_lookup_local_dynindx
3457 (info, h->root.u.def.section->owner,
3458 global_sym_index (h)));
3459 }
3460 else
3461 dynindx = (_bfd_elf_link_lookup_local_dynindx
3462 (info, input_bfd, r_symndx));
3463 value = 0;
3464 }
3465
3466 value = set_got_entry (output_bfd, info, dyn_i, dynindx,
3467 rel->r_addend, value, R_IA64_FPTR64LSB);
3468 value -= gp_val;
3469 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3470 }
3471 break;
3472
3473 case R_IA64_PCREL32MSB:
3474 case R_IA64_PCREL32LSB:
3475 case R_IA64_PCREL64MSB:
3476 case R_IA64_PCREL64LSB:
3477 /* Install a dynamic relocation for this reloc. */
3478 if (dynamic_symbol_p)
3479 {
3480 BFD_ASSERT (srel != NULL);
3481
3482 elf64_ia64_install_dyn_reloc (output_bfd, info, input_section,
3483 srel, rel->r_offset, r_type,
3484 h->dynindx, rel->r_addend);
3485 }
3486 goto finish_pcrel;
3487
748abff6 3488 case R_IA64_PCREL21BI:
800eeca4
JW		 3489 case R_IA64_PCREL21F:
3490 case R_IA64_PCREL21M:
3491 /* ??? These two are only used for speculation fixup code.
3492 They should never be dynamic. */
3493 if (dynamic_symbol_p)
3494 {
3495 (*_bfd_error_handler)
3496 (_("%s: dynamic relocation against speculation fixup"),
3497 bfd_get_filename (input_bfd));
3498 ret_val = false;
3499 continue;
3500 }
3501 if (undef_weak_ref)
3502 {
3503 (*_bfd_error_handler)
3504 (_("%s: speculation fixup against undefined weak symbol"),
3505 bfd_get_filename (input_bfd));
3506 ret_val = false;
3507 continue;
3508 }
3509 goto finish_pcrel;
3510
3511 case R_IA64_PCREL21B:
748abff6 3512 case R_IA64_PCREL60B:
800eeca4 3513 /* We should have created a PLT entry for any dynamic symbol. */
800eeca4
JW		 3514 dyn_i = NULL;
3515 if (h)
3516 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
3517
3518 if (dyn_i && dyn_i->want_plt2)
3519 {
3520 /* Should have caught this earlier. */
3521 BFD_ASSERT (rel->r_addend == 0);
3522
3523 value = (ia64_info->plt_sec->output_section->vma
3524 + ia64_info->plt_sec->output_offset
3525 + dyn_i->plt2_offset);
3526 }
3527 else
3528 {
3529 /* Since there's no PLT entry, Validate that this is
3530 locally defined. */
3531 BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
3532
3533 /* If the symbol is undef_weak, we shouldn't be trying
3534 to call it. There's every chance that we'd wind up
3535 with an out-of-range fixup here. Don't bother setting
3536 any value at all. */
3537 if (undef_weak_ref)
3538 continue;
3539 }
3540 goto finish_pcrel;
3541
748abff6
RH		 3542 case R_IA64_PCREL22:
3543 case R_IA64_PCREL64I:
800eeca4
JW		 3544 finish_pcrel:
3545 /* Make pc-relative. */
3546 value -= (input_section->output_section->vma
3547 + input_section->output_offset
3548 + rel->r_offset) & ~ (bfd_vma) 0x3;
3549 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3550 break;
3551
3552 case R_IA64_SEGREL32MSB:
3553 case R_IA64_SEGREL32LSB:
3554 case R_IA64_SEGREL64MSB:
3555 case R_IA64_SEGREL64LSB:
3556 {
3557 struct elf_segment_map *m;
3558 Elf_Internal_Phdr *p;
3559
3560 /* Find the segment that contains the output_section. */
3561 for (m = elf_tdata (output_bfd)->segment_map,
3562 p = elf_tdata (output_bfd)->phdr;
3563 m != NULL;
3564 m = m->next, p++)
3565 {
3566 int i;
3567 for (i = m->count - 1; i >= 0; i--)
3568 if (m->sections[i] == sym_sec->output_section)
3569 break;
3570 if (i >= 0)
3571 break;
3572 }
3573
3574 if (m == NULL)
3575 {
3576 /* If the input section was discarded from the output, then
3577 do nothing. */
3578
3579 if (bfd_is_abs_section (sym_sec->output_section))
3580 r = bfd_reloc_ok;
3581 else
3582 r = bfd_reloc_notsupported;
3583 }
3584 else
3585 {
3586 /* The VMA of the segment is the vaddr of the associated
3587 program header. */
3588 if (value > p->p_vaddr)
3589 value -= p->p_vaddr;
3590 else
3591 value = 0;
3592 r = elf64_ia64_install_value (output_bfd, hit_addr, value,
3593 r_type);
3594 }
3595 break;
3596 }
3597
3598 case R_IA64_SECREL32MSB:
3599 case R_IA64_SECREL32LSB:
3600 case R_IA64_SECREL64MSB:
3601 case R_IA64_SECREL64LSB:
3602 /* Make output-section relative. */
3603 if (value > input_section->output_section->vma)
3604 value -= input_section->output_section->vma;
3605 else
3606 value = 0;
3607 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3608 break;
3609
3610 case R_IA64_SEGBASE:
3611
3612 case R_IA64_REL32MSB:
3613 case R_IA64_REL32LSB:
3614 case R_IA64_REL64MSB:
3615 case R_IA64_REL64LSB:
3616
3617 case R_IA64_IPLTMSB:
3618 case R_IA64_IPLTLSB:
3619 case R_IA64_EPLTMSB:
3620 case R_IA64_EPLTLSB:
3621 case R_IA64_COPY:
3622
3623 case R_IA64_TPREL22:
3624 case R_IA64_TPREL64MSB:
3625 case R_IA64_TPREL64LSB:
3626 case R_IA64_LTOFF_TP22:
3627 default:
3628 r = bfd_reloc_notsupported;
3629 break;
3630 }
3631
3632 switch (r)
3633 {
3634 case bfd_reloc_ok:
3635 break;
3636
3637 case bfd_reloc_undefined:
3638 /* This can happen for global table relative relocs if
3639 __gp is undefined. This is a panic situation so we
3640 don't try to continue. */
3641 (*info->callbacks->undefined_symbol)
3642 (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
3643 return false;
3644
3645 case bfd_reloc_notsupported:
3646 {
3647 const char *name;
3648
3649 if (h)
3650 name = h->root.root.string;
3651 else
3652 {
3653 name = bfd_elf_string_from_elf_section (input_bfd,
3654 symtab_hdr->sh_link,
3655 sym->st_name);
3656 if (name == NULL)
3657 return false;
3658 if (*name == '\0')
3659 name = bfd_section_name (input_bfd, input_section);
3660 }
3661 if (!(*info->callbacks->warning) (info, _("unsupported reloc"),
3662 name, input_bfd,
3663 input_section, rel->r_offset))
3664 return false;
3665 ret_val = false;
3666 }
3667 break;
3668
3669 case bfd_reloc_dangerous:
3670 case bfd_reloc_outofrange:
3671 case bfd_reloc_overflow:
3672 default:
3673 {
3674 const char *name;
3675
3676 if (h)
3677 name = h->root.root.string;
3678 else
3679 {
3680 name = bfd_elf_string_from_elf_section (input_bfd,
3681 symtab_hdr->sh_link,
3682 sym->st_name);
3683 if (name == NULL)
3684 return false;
3685 if (*name == '\0')
3686 name = bfd_section_name (input_bfd, input_section);
3687 }
3688 if (!(*info->callbacks->reloc_overflow) (info, name,
3689 howto->name, 0,
3690 input_bfd,
3691 input_section,
3692 rel->r_offset))
3693 return false;
3694 ret_val = false;
3695 }
3696 break;
3697 }
3698 }
3699
3700 return ret_val;
3701}
3702
3703static boolean
3704elf64_ia64_finish_dynamic_symbol (output_bfd, info, h, sym)
3705 bfd *output_bfd;
3706 struct bfd_link_info *info;
3707 struct elf_link_hash_entry *h;
3708 Elf_Internal_Sym *sym;
3709{
3710 struct elf64_ia64_link_hash_table *ia64_info;
3711 struct elf64_ia64_dyn_sym_info *dyn_i;
3712
3713 ia64_info = elf64_ia64_hash_table (info);
3714 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
3715
3716 /* Fill in the PLT data, if required. */
3717 if (dyn_i && dyn_i->want_plt)
3718 {
3719 Elf_Internal_Rela outrel;
3720 bfd_byte *loc;
3721 asection *plt_sec;
3722 bfd_vma plt_addr, pltoff_addr, gp_val, index;
3723 Elf64_External_Rela *rel;
3724
3725 gp_val = _bfd_get_gp_value (output_bfd);
3726
3727 /* Initialize the minimal PLT entry. */
3728
3729 index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
3730 plt_sec = ia64_info->plt_sec;
3731 loc = plt_sec->contents + dyn_i->plt_offset;
3732
3733 memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE);
3734 elf64_ia64_install_value (output_bfd, loc, index, R_IA64_IMM22);
3735 elf64_ia64_install_value (output_bfd, loc+2, -dyn_i->plt_offset,
3736 R_IA64_PCREL21B);
3737
3738 plt_addr = (plt_sec->output_section->vma
3739 + plt_sec->output_offset
3740 + dyn_i->plt_offset);
3741 pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, true);
3742
3743 /* Initialize the FULL PLT entry, if needed. */
3744 if (dyn_i->want_plt2)
3745 {
3746 loc = plt_sec->contents + dyn_i->plt2_offset;
3747
3748 memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
3749 elf64_ia64_install_value (output_bfd, loc, pltoff_addr - gp_val,
3750 R_IA64_IMM22);
3751
3752 /* Mark the symbol as undefined, rather than as defined in the
3753 plt section. Leave the value alone. */
3754 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
3755 first place. But perhaps elflink.h did some for us. */
3756 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3757 sym->st_shndx = SHN_UNDEF;
3758 }
3759
3760 /* Create the dynamic relocation. */
3761 outrel.r_offset = pltoff_addr;
3762 if (bfd_little_endian (output_bfd))
3763 outrel.r_info = ELF64_R_INFO (h->dynindx, R_IA64_IPLTLSB);
3764 else
3765 outrel.r_info = ELF64_R_INFO (h->dynindx, R_IA64_IPLTMSB);
3766 outrel.r_addend = 0;
3767
3768 /* This is fun. In the .IA_64.pltoff section, we've got entries
3769 that correspond both to real PLT entries, and those that
3770 happened to resolve to local symbols but need to be created
3771 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
3772 relocations for the real PLT should come at the end of the
3773 section, so that they can be indexed by plt entry at runtime.
3774
3775 We emitted all of the relocations for the non-PLT @pltoff
3776 entries during relocate_section. So we can consider the
3777 existing sec->reloc_count to be the base of the array of
3778 PLT relocations. */
3779
3780 rel = (Elf64_External_Rela *)ia64_info->rel_pltoff_sec->contents;
3781 rel += ia64_info->rel_pltoff_sec->reloc_count;
3782
3783 bfd_elf64_swap_reloca_out (output_bfd, &outrel, rel + index);
3784 }
3785
3786 /* Mark some specially defined symbols as absolute. */
3787 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3788 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3789 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3790 sym->st_shndx = SHN_ABS;
3791
3792 return true;
3793}
3794
3795static boolean
3796elf64_ia64_finish_dynamic_sections (abfd, info)
3797 bfd *abfd;
3798 struct bfd_link_info *info;
3799{
3800 struct elf64_ia64_link_hash_table *ia64_info;
3801 bfd *dynobj;
3802
3803 ia64_info = elf64_ia64_hash_table (info);
3804 dynobj = ia64_info->root.dynobj;
3805
3806 if (elf_hash_table (info)->dynamic_sections_created)
3807 {
3808 Elf64_External_Dyn *dyncon, *dynconend;
3809 asection *sdyn, *sgotplt;
3810 bfd_vma gp_val;
3811
3812 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3813 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3814 BFD_ASSERT (sdyn != NULL);
3815 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3816 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3817
3818 gp_val = _bfd_get_gp_value (abfd);
3819
3820 for (; dyncon < dynconend; dyncon++)
3821 {
3822 Elf_Internal_Dyn dyn;
3823 const char *name;
3824 asection *s;
3825
3826 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3827
3828 switch (dyn.d_tag)
3829 {
3830 case DT_PLTGOT:
3831 dyn.d_un.d_ptr = gp_val;
3832 break;
3833
3834 case DT_PLTRELSZ:
3835 dyn.d_un.d_val = (ia64_info->minplt_entries
3836 * sizeof (Elf64_External_Rela));
3837 break;
3838
3839 case DT_JMPREL:
3840 /* See the comment above in finish_dynamic_symbol. */
3841 dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma
3842 + ia64_info->rel_pltoff_sec->output_offset
3843 + (ia64_info->rel_pltoff_sec->reloc_count
3844 * sizeof (Elf64_External_Rela)));
3845 break;
3846
3847 case DT_IA_64_PLT_RESERVE:
3848 dyn.d_un.d_ptr = (sgotplt->output_section->vma
3849 + sgotplt->output_offset);
3850 break;
3851
3852 case DT_RELASZ:
3853 /* Do not have RELASZ include JMPREL. This makes things
3854 easier on ld.so. This is not what the rest of BFD set up. */
3855 dyn.d_un.d_val -= (ia64_info->minplt_entries
3856 * sizeof (Elf64_External_Rela));
3857 break;
3858
3859 case DT_INIT:
3860 case DT_FINI:
3861 {
3862 struct elf_link_hash_entry *h;
3863 struct elf64_ia64_dyn_sym_info *dyn_i;
3864 const char *which;
3865
3866 if (dyn.d_tag == DT_INIT)
3867 which = info->init_function;
3868 else
3869 which = info->fini_function;
3870
3871 h = elf_link_hash_lookup (elf_hash_table (info), which,
3872 false, false, false);
3873 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
3874 dyn.d_un.d_ptr = set_pltoff_entry (abfd, info, dyn_i,
3875 dyn.d_un.d_ptr, 0);
3876 }
3877 }
3878
3879 bfd_elf64_swap_dyn_out (abfd, &dyn, dyncon);
3880 }
3881
3882 /* Initialize the PLT0 entry */
3883 if (ia64_info->plt_sec)
3884 {
3885 bfd_byte *loc = ia64_info->plt_sec->contents;
3886 bfd_vma pltres;
3887
3888 memcpy (loc, plt_header, PLT_HEADER_SIZE);
3889
3890 pltres = (sgotplt->output_section->vma
3891 + sgotplt->output_offset
3892 - gp_val);
3893
3894 elf64_ia64_install_value (abfd, loc+1, pltres, R_IA64_GPREL22);
3895 }
3896 }
3897
3898 return true;
3899}
3900\f
3901/* ELF file flag handling: */
3902
3903/* Function to keep IA-64 specific file flags. */
3904static boolean
3905elf64_ia64_set_private_flags (abfd, flags)
3906 bfd *abfd;
3907 flagword flags;
3908{
3909 BFD_ASSERT (!elf_flags_init (abfd)
3910 || elf_elfheader (abfd)->e_flags == flags);
3911
3912 elf_elfheader (abfd)->e_flags = flags;
3913 elf_flags_init (abfd) = true;
3914 return true;
3915}
3916
3917/* Copy backend specific data from one object module to another */
3918static boolean
3919elf64_ia64_copy_private_bfd_data (ibfd, obfd)
3920 bfd *ibfd, *obfd;
3921{
3922 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3923 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3924 return true;
3925
3926 BFD_ASSERT (!elf_flags_init (obfd)
3927 || (elf_elfheader (obfd)->e_flags
3928 == elf_elfheader (ibfd)->e_flags));
3929
3930 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
3931 elf_flags_init (obfd) = true;
3932 return true;
3933}
3934
3935/* Merge backend specific data from an object file to the output
3936 object file when linking. */
3937static boolean
3938elf64_ia64_merge_private_bfd_data (ibfd, obfd)
3939 bfd *ibfd, *obfd;
3940{
3941 flagword out_flags;
3942 flagword in_flags;
3943 boolean ok = true;
3944
3945 /* Don't even pretend to support mixed-format linking. */
3946 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3947 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3948 return false;
3949
3950 in_flags = elf_elfheader (ibfd)->e_flags;
3951 out_flags = elf_elfheader (obfd)->e_flags;
3952
3953 if (! elf_flags_init (obfd))
3954 {
3955 elf_flags_init (obfd) = true;
3956 elf_elfheader (obfd)->e_flags = in_flags;
3957
3958 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3959 && bfd_get_arch_info (obfd)->the_default)
3960 {
3961 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3962 bfd_get_mach (ibfd));
3963 }
3964
3965 return true;
3966 }
3967
3968 /* Check flag compatibility. */
3969 if (in_flags == out_flags)
3970 return true;
3971
3972 if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
3973 {
3974 (*_bfd_error_handler)
3975 (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
3976 bfd_get_filename (ibfd));
3977
3978 bfd_set_error (bfd_error_bad_value);
3979 ok = false;
3980 }
3981 if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
3982 {
3983 (*_bfd_error_handler)
3984 (_("%s: linking big-endian files with little-endian files"),
3985 bfd_get_filename (ibfd));
3986
3987 bfd_set_error (bfd_error_bad_value);
3988 ok = false;
3989 }
3990 if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
3991 {
3992 (*_bfd_error_handler)
3993 (_("%s: linking 64-bit files with 32-bit files"),
3994 bfd_get_filename (ibfd));
3995
3996 bfd_set_error (bfd_error_bad_value);
3997 ok = false;
3998 }
3999
4000 return ok;
4001}
4002
4003static boolean
4004elf64_ia64_print_private_bfd_data (abfd, ptr)
4005 bfd *abfd;
4006 PTR ptr;
4007{
4008 FILE *file = (FILE *) ptr;
4009 flagword flags = elf_elfheader (abfd)->e_flags;
4010
4011 BFD_ASSERT (abfd != NULL && ptr != NULL);
4012
4013 fprintf (file, "private flags = %s%s%s%s\n",
4014 (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
4015 (flags & EF_IA_64_EXT) ? "EXT, " : "",
4016 (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
4017 (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
4018 _bfd_elf_print_private_bfd_data (abfd, ptr);
4019 return true;
4020}
4021\f
4022#define TARGET_LITTLE_SYM bfd_elf64_ia64_little_vec
4023#define TARGET_LITTLE_NAME "elf64-ia64-little"
4024#define TARGET_BIG_SYM bfd_elf64_ia64_big_vec
4025#define TARGET_BIG_NAME "elf64-ia64-big"
4026#define ELF_ARCH bfd_arch_ia64
4027#define ELF_MACHINE_CODE EM_IA_64
4028#define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
4029#define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
4030#define ELF_MAXPAGESIZE 0x10000 /* 64KB */
4031
4032#define elf_backend_section_from_shdr \
4033 elf64_ia64_section_from_shdr
4034#define elf_backend_fake_sections \
4035 elf64_ia64_fake_sections
4036#define elf_backend_add_symbol_hook \
4037 elf64_ia64_add_symbol_hook
4038#define elf_backend_additional_program_headers \
4039 elf64_ia64_additional_program_headers
4040#define elf_backend_modify_segment_map \
4041 elf64_ia64_modify_segment_map
4042#define elf_info_to_howto \
4043 elf64_ia64_info_to_howto
4044
4045#define bfd_elf64_bfd_reloc_type_lookup \
4046 elf64_ia64_reloc_type_lookup
4047#define bfd_elf64_bfd_is_local_label_name \
4048 elf64_ia64_is_local_label_name
748abff6
RH		 4049#define bfd_elf64_bfd_relax_section \
4050 elf64_ia64_relax_section
800eeca4
JW		 4051
4052/* Stuff for the BFD linker: */
4053#define bfd_elf64_bfd_link_hash_table_create \
4054 elf64_ia64_hash_table_create
4055#define elf_backend_create_dynamic_sections \
4056 elf64_ia64_create_dynamic_sections
4057#define elf_backend_check_relocs \
4058 elf64_ia64_check_relocs
4059#define elf_backend_adjust_dynamic_symbol \
4060 elf64_ia64_adjust_dynamic_symbol
4061#define elf_backend_size_dynamic_sections \
4062 elf64_ia64_size_dynamic_sections
4063#define elf_backend_relocate_section \
4064 elf64_ia64_relocate_section
4065#define elf_backend_finish_dynamic_symbol \
4066 elf64_ia64_finish_dynamic_symbol
4067#define elf_backend_finish_dynamic_sections \
4068 elf64_ia64_finish_dynamic_sections
4069#define bfd_elf64_bfd_final_link \
4070 elf64_ia64_final_link
4071
4072#define bfd_elf64_bfd_copy_private_bfd_data \
4073 elf64_ia64_copy_private_bfd_data
4074#define bfd_elf64_bfd_merge_private_bfd_data \
4075 elf64_ia64_merge_private_bfd_data
4076#define bfd_elf64_bfd_set_private_flags \
4077 elf64_ia64_set_private_flags
4078#define bfd_elf64_bfd_print_private_bfd_data \
4079 elf64_ia64_print_private_bfd_data
4080
4081#define elf_backend_plt_readonly 1
4082#define elf_backend_want_plt_sym 0
4083#define elf_backend_plt_alignment 5
4084#define elf_backend_got_header_size 0
4085#define elf_backend_plt_header_size PLT_HEADER_SIZE
4086#define elf_backend_want_got_plt 1
4087#define elf_backend_may_use_rel_p 1
4088#define elf_backend_may_use_rela_p 1
4089#define elf_backend_default_use_rela_p 1
4090#define elf_backend_want_dynbss 0
4091#define elf_backend_copy_indirect_symbol elf64_ia64_hash_copy_indirect
4092#define elf_backend_hide_symbol elf64_ia64_hash_hide_symbol
4093
4094#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.1736 seconds and 4 git commands to generate.